java之Collection类

@SuppressWarnings({ "unchecked", "rawtypes" })   //注解
public class Demo1_Collection {
    /*
     * 引用数据类型数组中存的都是对象的地址值，而非对象中的属性值
     *A：集合和数组的区别：
     * 区别1：
     *  数组可以存储基本数据类型（值），也可以存储引用数据类型（地址值）
     *  集合只能存储引用数据类型，但是也可以存储基本数据类型，只不过是存储是会自动装箱变成对象
     * 区别2：
     *  数组的长度是固定的，不能自动增长
     *  集合的长度是可变的，可以根据元素的增加而增加
     * B：数组和集合何时使用对应的哪种：
     *   1.当元素个数固定的时候推荐使用数组；固定元素个数的时候用数组效率更高，因为它是上来就创建好了
     *   2.当元素个数变化时候推荐使用集合
     * C:Collection中的成员方法
     *      boolean add(Object c)           增加元素
     *   boolean remove(Object c)        移除元素
     *   void clear()                    清空集合
     *   boolean contains(Object o)      判断是否包含某个元素
     *   boolean isEmpty()               判断集合是否为空
     *   int size()                      获取元素的个数
     * D:注意
     *   add方法List集合一直都返回true，是因为List集合可以存储重复元素，但是如果是Set集合存储重复元素时是会返回false的
     *   ArrayList的父类的父类重写了toString方法，所以打印对象时输出的结果不是Object类中toString的结果
     *   
     */
    public static void main(String[] args) {
        
        //demo1();
        demo2();

    }

    public static void demo2() {
        Collection c = new ArrayList();
        c.add(new String("abc"));
        c.add("b");
        c.add("c");
        c.add("d");
        c.add(new Student("adda", 19));
        System.out.println(c);   //[a, b, c, d]
        c.remove("c");
        System.out.println(c);   //[a, b, d]
        System.out.println(c.contains("a"));   //true
        System.out.println(c.isEmpty());       //false
        System.out.println(c.size());          //3
        c.clear();
        System.out.println(c);   //[]
    }

    public static void demo1() {
        Collection c = new ArrayList();
        boolean b = c.add("abc");
        c.add(true);             //这里会自动装箱将基本数据类型true转换成包装类型存入
        c.add(100);              //同上，会自动装箱
        System.out.println(b);
        System.out.println(c);
    }
}

public class Demo2_Collection {

    /*
     * a. 集合的遍历，其实就是依次获取集合中的元素
     * b. 把集合转换成数组，就可以实现集合的遍历  
     *    toArray()
     * c.注意
     *    自定义类中需要重写toString方法，否则打印出的对象c是打印的自定义类的地址
     */
    public static void main(String[] args) {
        //demo1();
        Collection c = new ArrayList();
        c.add(new Student("lisi", 18));
        c.add(new Student("zhangsan", 16));
        System.out.println(c);
        Object[] arr = c.toArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
            Student s = (Student) arr[i];         //向下转型
            System.out.println(s.getName() + "...." + s.getAge());
        }

    }

    public static void demo1() {
        Collection c = new ArrayList();
        c.add("a");
        c.add("b");
        Object[] arr = c.toArray();       //将集合转换成数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

}

public class Demo3_CollectionAll {

    /*
     * all相关的方法
     *         boolean addAll(Collection c)      
     *         boolean removeAll(Collection c)     实质删除的是两个集合的交集
     *         boolean containsAll(Collection c)   判断c中的所有元素是否都在调用集合中存在
     *         boolean retainAll(Collection c)     取交集
     */
    public static void main(String[] args) {

        //demo1();
        //demo2();
        //demo3();
        Collection c1 = new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");
        
        /*Collection c2 = new ArrayList();
        c2.add("a");
        c2.add("b");
        c2.add("z");
        boolean b = c1.retainAll(c2);
        System.out.println(b);          //true  
        System.out.println(c1);         //[a, b]
        
        Collection c3 = new ArrayList();
        c3.add("aa");
        c3.add("bb");
        boolean b2 = c1.retainAll(c3);
        System.out.println(b2);           //true
        System.out.println(c1);           //[]
*/        
        //看调用集合是否改变（即交集是否和调用集合相同），不变则为false，改变则为true
        Collection c4 = new ArrayList();
        c4.add("a");
        c4.add("b");
        c4.add("c");
        c4.add("d");
        boolean b3 = c1.retainAll(c4);
        System.out.println(b3);           //false
        System.out.println(c1);           //[a, b, c, d]
        
        Collection c5 = new ArrayList();
        c5.add("a");
        c5.add("b");
        c5.add("c");
        c5.add("f");
        c5.add("e");
        boolean b4 = c1.retainAll(c5);
        System.out.println(b4);           //true
        System.out.println(c1);           //[a, b, c]
        
        
    }

    public static void demo3() {
        Collection c1 = new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");
        
        Collection c2 = new ArrayList();
        c2.add("a");
        c2.add("b");
        c2.add("z");
        boolean b = c1.containsAll(c2);
        System.out.println(b);           //false
        
        Collection c3 = new ArrayList();
        c3.add("a");
        c3.add("b");
        boolean b2 = c1.containsAll(c3);
        System.out.println(b2);           //true
    }

    public static void demo2() {
        Collection c1 = new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");
        
        Collection c2 = new ArrayList();
        c2.add("a");
        c2.add("b");
        c2.add("z");
        boolean b = c1.removeAll(c2);
        System.out.println(b);
        System.out.println(c1);     //[c, d]
    }

    public static void demo1() {
        Collection c1 = new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");
        
        Collection c2 = new ArrayList();
        c2.add("a");
        c2.add("b");
        
        c1.addAll(c2);               //会将c2当做一个对象添加到c1中
        System.out.println(c1);      //[a, b, c, d, a, b]
    }

}

使用迭代器Iterator遍历集合：

public class Demo4_Iterator {

    /*
     * 迭代遍历集合
     * 迭代器原理：
     *     迭代器是对集合进行遍历，但是每个集合内部的存储结构都是不同的，所以每一个集合存和取都是不一样的，
     *     那么就需要在每个类中定义hasNext()和next()方法，如果这样做会使集合体系过于臃肿，迭代器将这样的方法向上抽取出接口，
     *     然后在每个类的内部定义自己迭代方式，这样做有两种好处：第一. 规定了整个集合体系的遍历方式都是hasNext()和next()方法，
     *     第二. 代码由底层内部实现，使用者不用管是怎么实现的，只要会用即可
     *     
     * 迭代器源码分析：
     *     1. 在Eclipse中Ctrl + shift + t 找到ArrayList类
     *     2. Ctrl + o 找到 iterator()方法
     *     3. 查看返回值是 new itr() ,说明是Iterator类的子类对象
     *     4. Itr这个类重写了Iterator中的所有抽象方法
     */
    public static void main(String[] args) {

        //demo1();
        Collection c = new ArrayList();
        c.add(new Student("张三", 18));
        c.add(new Student("李四", 19));
        c.add(new Student("王五", 20));
        c.add(new Student("赵六", 21));
        
        Iterator it = c.iterator();
        while (it.hasNext()) {
            //System.out.println(it.next());
            Student s = (Student) it.next();        //向下转型
            System.out.println(s.getName() + " " + s.getAge());
        }
        
    }

    public static void demo1() {
        Collection c = new ArrayList();
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");

        Iterator it = c.iterator(); // 获取迭代器
        /*
         * boolean b = it.hasNext(); //判断集合中是否有元素 System.out.println(b);
         * System.out.println(it.next()); //通过next()方法获取元素值
         */
        while (it.hasNext()) {
            System.out.println(it.next());

        }
    }

}