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 方法