java 集合学习笔记2-ArrayList LinkedList Vector 泛型 增强for 可变参数

1、集合-去除ArrayList中重复字符串元素

        public static void main(String[] args) {

            ArrayList list = new ArrayList();

            list.add("a");

            list.add("a");

            list.add("b");

            list.add("b");

            list.add("b");

            list.add("c");

            list.add("c");

            list.add("c");

            list.add("c");

            

            System.out.println(list);

            ArrayList newList = getSingle(list);//调用getSingle方法处理

            System.out.println(newList);

        }

        public static ArrayList getSingle(ArrayList list) {

            ArrayList newList = new ArrayList();
//创建一个新集合

            Iterator it = list.iterator(); //获取迭代器

            while(it.hasNext()) { //判断老集合中是否有元素

                String temp = (String)it.next();
//将每一个元素临时记录住

                if(!newList.contains(temp)) {
//如果新集合中不包含该元素

                    newList.add(temp); //将该元素添加到新集合中

                }

            }

            return newList; //将新集合返回

        }

        

        

2、集合-去除ArrayList中重复自定义对象元素

    需要重写自定义对象的equals()方法

    

    例如：

    public static void main(String[] args) {

            ArrayList list = new ArrayList();
//创建集合对象

            list.add(new Person("张三", 23));

            list.add(new Person("张三", 23));

            list.add(new Person("李四", 24));

            list.add(new Person("李四", 24));

            list.add(new Person("李四", 24));

            list.add(new Person("李四", 24));

            

            //ArrayList newList = getSingle(list);
//调用方法去除重复

            //System.out.println(newList);

            list.remove(new Person("张三", 23));

            System.out.println(list);

        }

        public static ArrayList getSingle(ArrayList list) {

            ArrayList newList = new ArrayList<>();
//1,创建新集合

            Iterator it = list.iterator(); //2,根据传入的集合(老集合)获取迭代器

            

            while(it.hasNext()) { //3,遍历老集合

                Object obj = it.next(); //记录住每一个元素

                if(!newList.contains(obj)) {
//如果新集合中不包含老集合中的元素，会调用obj的equals方法去和newList的每个对象对比

                    newList.add(obj); //将该元素添加

                }

            }

            

            return newList;

        }

        

        自定义类：需要重写equals方法，不然必然判断是不一样的

        public class Person {

            private String name;

            private int age;

            public Person() {

                super();

                

            }

            public Person(String name, int age) {

                super();

                this.name = name;

                this.age = age;

            }

            public String getName() {

                return name;

            }

            public int getAge() {

                return age;

            }

            @Override

            public String toString() {

                return "Person [name=" + name + ", age=" + age + "]";

            }

            @Override//重写equals方法

            public boolean equals(Object obj) {

                Person p = (Person)obj;

                return this.name.equals(p.name) && this.age == p.age;

            }

        

        }

        

        

3、集合-LinkedList的特有功能：

    获取或删除第一个 最后一个元素

    public void addFirst(E e)及addLast(E e)

    public E getFirst()及getLast()

    public E removeFirst()及public E removeLast()

    

    

    

4、集合-泛型：

    泛型的由来:通过Object转型问题引入

    早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。

    

     a、泛型好处
提高安全性(将运行期的错误转换到编译期) 
省去强转的麻烦
b、泛型基本使用
<>中放的必须是引用数据类型 
c、泛型使用注意事项
前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型)  

    

5、集合-泛型类：把泛型定义在类上

    public class 类名<泛型类型1,…>

    泛型类型必须是引用类型

    

    public class Tool<Q> {

        private Q q;

        public Q getObj() {

            return q;

        }

        public void setObj(Q q) {

            this.q = q;

        }

        

        public<T> void show(T t) { //方法泛型最好与类的泛型一致

            System.out.println(t); //如果不一致,需要在方法上声明该泛型

        }

        

        public static<W> void print(W w) { //静态方法必须声明自己的泛型

            System.out.println(w);

        }

    }

    Tool<Student> t = new Tool<Student>(); //创建工具类对象

    泛型类中的Q在调用的时候就会被赋值，例如上面的例子就是将Student对象赋值给了Q

    

    

6、集合-泛型方法：把泛型定义在方法上 

    public <泛型类型> 返回类型 方法名(泛型类型 变量名)

    有2种方式：

    

    public class Tool<Q> {

        private Q q;

        public Q getObj() {

            return q;

        }

        public void setObj(Q q) {

            this.q = q;

        }

        

        //第一种，方法泛型和类的泛型一致

        public<Q> void show1(Q q) { //方法泛型最好与类的泛型一致

            System.out.println(q);

        }

        //第二种，方法泛型和类的泛型不一致

        public<T> void show(T t) { //方法泛型最好与类的泛型一致

            System.out.println(t); //如果不一致,需要在方法上声明该泛型

        }

        

        //静态方法的泛型，也可以写成和类的泛型一致，但是是不一样的，static

        public static<W> void print(W w) { //静态方法必须声明自己的泛型，因为静态方法在导入包的时候就会分配内存，必须要赋值。

            System.out.println(w);              //<W>必须写在static的后面

        }

    }

    

    

7、集合-泛型接口：把泛型定义在接口上

    public interface 接口名<泛型类型>

    

    例如：

        interface Inter<T> {

            public void show(T t);

        }

        class Demo implements Inter<String> {
//推荐用这种

            @Override

            public void show(String t) {

                System.out.println(t);

            }

        }

        //不推荐

        class Demo<T> implements Inter<T> {
//没有必要在实现接口的时候给自己类加泛型

            @Override

            public void show(T t) {

                System.out.println(t);

            }

        }

    

    

8、集合-泛型：泛型高级之通配符

    泛型通配符<?>

    a、泛型通配符<?>

        任意类型，如果没有明确，那么就是Object以及任意的Java类了

    b、? extends E

        向下限定，E及其子类

    c、? super E

        向上限定，E及其父类

    

    

9、集合-增强for循环

    ArrayList<String> list = new ArrayList<>();

    list.add("a");

    list.add("b");

    list.add("c");

    list.add("d");

    

    //增强for循环

    for(String s : list) {

        System.out.println(s);

    }

    

    

10、集合-可变参数（就和Python中的 **args定义的参数是一样的）

    定义方法的时候不知道该定义多少个参数

    

    例如：

    public static void print(int ... arr) {//可变参数其实是一个数组

            for (int i = 0; i < arr.length; i++) {

                System.out.println(arr[i]);

            }

        }

        //调用

        print(11,22,33,44,55);

    注意：如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

    

    

    

11、Arrays工具类的asList()方法的使用

    可以将数组转化为集合

    例如：

        Integer[] arr = {11,22,33,44,55}; //将数组转换成集合,数组必须是引用数据类型（Integer）
List<Integer> list = Arrays.asList(arr);

    

    

    集合转数组使用 toArray 方法