Java:集合：Collection

集合的概述：

集合可以存储各种各样的数据，大小，长度自身特点都可不一样。所以Java提供的数据集合也不应该是一样的，底层的数据结构也是不同的，，占用的内存空间也是不同的。不同不重要，我们只需要知道集合是可以存放数据的，不光可以存放还可以使用，比如查找数据，获取数据，删除数据等等。

 

Collection：是集合中的顶层接口，它存放由他展开而来的继承体系。

Collection：由于是一个接口，无法被实例化，我们要找它一个子类来进行接口多态方式进行实an

 1、添加功能
                boolean add(Object e)确保此集合包含指定的元素（可选操作）
                boolean addAll(Collection c) 将指定集合中的所有元素添加到此集合（可选操作）
            2、删除功能
                boolean remove(Object o) 从该集合中删除指定元素的单个实例（如果存在）（可选操作）。
                boolean removeAll(Collection c) 删除指定集合中包含的所有此集合的元素（可选操作）。
                void clear() 从此集合中删除所有元素（可选操作）。
            3、获取功能
                Iterator iterator() 返回此集合中的元素的迭代器。
            4、判断功能
                boolean contains(Object o) 如果此集合包含指定的元素，则返回 true 。
                boolean containsAll(Collection c) 如果此集合包含指定 集合中的所有元素，则返回true。
                boolean isEmpty() 如果此集合不包含元素，则返回 true 。
            5、获取长度方法：
                int size() 返回此集合中的元素数
            6、求交集功能
                boolean retainAll(Collection c) 仅保留此集合中包含在指定集合中的元素（可选操作）。
            7、将集合转成数组
                Object[] toArray() 返回一个包含此集合中所有元素的数组。

 */
public class CollectionDemo1 {
    public static void main(String[] args) {
        Collection c = new ArrayList();


        //boolean add(Object e)确保此集合包含指定的元素（可选操作）
        System.out.println(c.add("hello"));
        System.out.println(c.add("world"));
        System.out.println(c.add("hello"));
        c.add(20);
        c.add(12.34);
        System.out.println(c);

        //void clear() 从此集合中删除所有元素（可选操作）。
//        c.clear();

        //boolean remove(Object o) 从该集合中删除指定元素的单个实例（如果存在）（可选操作）。
        //删除指定的元素
        //只移除一个符合条件的元素
//        System.out.println("从该集合中删除指定的元素："+c.remove("world"));
        System.out.println("从该集合中删除指定的元素："+c.remove("hello"));

        //boolean contains(Object o) 如果此集合包含指定的元素，则返回 true 。
        //判断该集合中是否包含某个元素，如果包含，返回true
        System.out.println(c.contains("hello"));

        //boolean isEmpty() 如果此集合不包含元素，则返回 true 。
        System.out.println(c.isEmpty());

        //int size() 返回此集合中的元素数
        //集合集合的长度
        System.out.println("集合的长度为："+c.size());




        /**
         * java.lang.Object
         *      java.util.AbstractCollection<E>
         *              java.util.AbstractList<E>
         *                      java.util.ArrayList<E>
         */
        System.out.println(c); //这里调用的是AbstractCollection类中的toString()方法



    }

import java.util.ArrayList;
import java.util.Collection;

/*
        boolean addAll(Collection c) 将指定集合中的所有元素添加到此集合（可选操作）
        boolean removeAll(Collection c) 删除指定集合中包含的所有此集合的元素（可选操作）。
        boolean containsAll(Collection c) 如果此集合包含指定 集合中的所有元素，则返回true。
        boolean retainAll(Collection c) 仅保留此集合中包含在指定集合中的元素（可选操作）。
 */
public class CollectionDemo2 {
    public static void main(String[] args) {
        //创建集合对象
        Collection c1 = new ArrayList();
        //向集合中添加元素
//        c1.add("hello");
//        c1.add("world");
//        c1.add("java");
        c1.add("hadoop");
        c1.add("hive");
        c1.add("spark");

        //创建另一个集合对象
        Collection c2 = new ArrayList();
        c2.add("hello");
        c2.add("world");
        c2.add("java");
        System.out.println("c1:" + c1);
        System.out.println("c2:" + c2);
        System.out.println("=========================================");
//        //boolean addAll(Collection c) 将指定集合中的所有元素添加到此集合（可选操作）
//        System.out.println("将c2添加到集合c1中：");
//        System.out.println(c1.addAll(c2));
//        System.out.println("c1:" + c1);
//        System.out.println("c2:" + c2);
//        System.out.println("==========================================");
//        //boolean removeAll(Collection c) 删除指定集合中包含的所有此集合的元素（可选操作）。
//        System.out.println(c1.removeAll(c2));
//        System.out.println("c1:" + c1);
//        System.out.println("c2:" + c2);
//        System.out.println("==========================================");
        //boolean containsAll(Collection c) 如果此集合包含指定 集合中的所有元素，则返回true。
//        System.out.println(c1.containsAll(c2));
//        System.out.println("==========================================");
        //boolean retainAll(Collection c) 仅保留此集合中包含在指定集合中的元素（可选操作）。
        /**
         *  假设现在有两个集合c1,c2
         *  c1对c2交集，最终交集的结果保存在c1中，c2不变
         *  并且c1删除与c2不是共同的元素。
         */
//        System.out.println(c1.retainAll(c2));
        System.out.println(c2.retainAll(c1));
        System.out.println("c1:" + c1);
        System.out.println("c2:" + c2);


    }
}

集合的遍历：

目的就是将集合中元素依次取出来，Object[] toArry()返回一个包含此集合中所有元素的数组，将集合转换为数组然后再遍历。

import java.util.ArrayList;
import java.util.Collection;

/*
    
 */
public class CollectionDemo3 {
    public static void main(String[] args) {
        //创建集合对象
        Collection c = new ArrayList();
        //向集合中添加元素
        c.add("hello");
        c.add("world");
        c.add("java");
        c.add("hadoop");
        c.add("hive");

        //Object[] toArray() 返回一个包含此集合中所有元素的数组。
        Object[] objects = c.toArray();

        //遍历数组获取每一个元素
        for (int i = 0; i < objects.length; i++) {
//            System.out.println(objects[i]); // Object o = objects[i](String类型的);
            //因为获取到的元素是由Object类型接收的，实际是String类型
            //这样就形成了多态
            //而多态调用成员方法，编译看左，运行看右
            //Object类中没有length()方法，所以报错
            //要想使用子类中特有的方法，就要向下转型
            String s = (String) objects[i];
            //需求：想要获取每一个字符串元素的长度？
//            System.out.println(objects[i].length());
            System.out.println(s + "---" + s.length());
        }
    }
}

需求：向集合中添加三个学生的信息，并遍历

import java.util.ArrayList;
import java.util.Collection;

/*
    
 */
public class CollectionDemo4 {
    public static void main(String[] args) {
        //创建集合对象
        Collection c = new ArrayList();

        //创建3个学生对象
        Student s1 = new Student("明旺", 18);
        Student s2 = new Student("王宇", 17);
        Student s3 = new Student("周家祥", 16);

        //将学生对象添加到集合中
        c.add(s1);
        c.add(s2);
        c.add(s3);

        //将集合转换成数组
        Object[] arr = c.toArray();

        //遍历数组
        for (int i = 0; i < arr.length; i++) {
//            Object obj = arr[i];
            //向下转型，转成元素的类型
            Student s = (Student) arr[i];
            System.out.println(s.getName() + "---" + s.getAge());
        }

    }
}

Iterator iterator:返回此集合中的元素迭代器；它是collection集合遍历的专有方式；

boolean hasNext:判断迭代器中是否还有元素；

Object next:返回迭代器中的元素；

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;


public class CollectionDemo5 {
    public static void main(String[] args) {
        //创建一个集合对象
        Collection c = new ArrayList();
        //向集合中添加元素
        c.add("hello");
        c.add("world");
        c.add("java");
        c.add("hadoop");
        c.add("hive");
//        System.out.println(c);

        //获取集合c的迭代器对象
        //Iterator iterator() 返回此集合中的元素的迭代器。  它是Collection集合遍历的专有方式
        Iterator iterator = c.iterator(); // Iterator iterator = new Itr();
//        System.out.println(iterator); //java.util.ArrayList$Itr@4554617c
//        Object next = iterator.next();
//        System.out.println(next);
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next()); //NoSuchElementException
        //当我们多调用了一次next方法的时候，报错了
        //原因是，我们发现在调用之前，迭代器中的元素就已经遍历完了，不应该再指向下一个，是多余的
        //如何解决呢？实际上我们应该在获取元素之前判断一下下一个位置是否有元素，如果有元素，我们就调用next方法获取
        //如何去判断呢
        //boolean hasNext() 判断迭代器中是否还有元素
//        if(iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
//            System.out.println(iterator.next());
//        }
//
//        if(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
//
//        if(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
//
//        if(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
//
//        if(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
//
//        if(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
//
//        if(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
//
//        if(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }

        //通过加入判断后我们发现，虽然代码不报错，并且也可以正确的将结果打印出来
        //但是，我们并不知道什么时候遍历到迭代器中的最后一个元素
        //怎么改进？循环改进
        //由于我们不知道要循环多少次，所以我们采用while循环
        while (iterator.hasNext()) {
            Object next = iterator.next();

            //向下转型使用元素数据类型特有的方法
            String s = (String) next;
            System.out.println(s + "--长度为：" + s.length());

//            System.out.println(iterator.next());
        }

    }
}

能否将while循环改为for循环呢？能，但是不推荐

同一个迭代器只遍历一次，多次遍历没有结果，因为遍历一次后，指针指向末尾；

Java为什么要将iterator定义一个接口而不是一个类呢？

将来你需要根据不同的数据创建不同的集合去存储，每个集合都有自己的特点，很有可能每个集合遍历的方法和顺序都不一样，将来取值的时候，使用的方式也不一定是一样的，所以迭代器不应该直接实现如何遍历，而是提供一个接口。将来特有的集合类去实现这个接口中的取值方法，来实现自身的方法。

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;


public class CollectionDemo6 {
    public static void main(String[] args) {
        Collection c = new ArrayList();

        //创建3个学生对象
        Student s1 = new Student("小白", 18);
        Student s2 = new Student("小黑", 17);
        Student s3 = new Student("小灰", 16);

        //将学生对象添加到集合中
        c.add(s1);
        c.add(s2);
        c.add(s3);

        //获取迭代器对象
        Iterator iterator = c.iterator();
        //遍历迭代器对象，获取迭代器中每一个元素
        //推荐遍历做法
        while (iterator.hasNext()) {
            Object next = iterator.next();
            //向下转型
            Student s = (Student) next;
            System.out.println(s.getName() + "---" + s.getAge());
        }

//        System.out.println(iterator.next()); //NoSuchElementException

//        while (iterator.hasNext()) {
//            Object next = iterator.next();
//            //向下转型
//            Student s = (Student) next;
//            System.out.println(s.getName() + "---" + s.getAge());
//        }




//        System.out.println("============用普通for循环遍历(不推荐)=========================");
//        for (Iterator iterator1 = c.iterator(); iterator1.hasNext(); ) {
//            Object next = iterator1.next();
//            Student s = (Student) next;
//            System.out.println(s.getName() + "---" + s.getAge());
//        }

    }
}