Java集合笔记一 —— Collection

当我们想用一个容器来存放学生对象的时候，我们可以选择对象数组

package review.ListDemo1;

public class demo1 {
    public static void main(String[] args) {
        //创建学生对象数组，长度为3
        Student[] arr = new Student[3];

        //创建3个学生对象，并赋值
        Student s1 = new Student("feng", 18);
        Student s2 = new Student("tang", 19);
        Student s3 = new Student("zhou", 20);

        //把创建好的3个学生对象，放入到数组中
        arr[0] = s1;
        arr[1] = s2;
        arr[2] = s3;
        
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
            System.out.println(arr[i].getName()+"---"+arr[i].getAge());
        }
    }
}

这样虽然可以存放学生对象，但是并不适用于现实中的情况
现实中随时都有可能会有学生对象的加入与离开，对于这个数组来说，不能动态的改变数组长度

如果有一个东西，在存放的时候可以根据存放内容的多少，自由的改变长度就好了。
这时候也许会想到StringBuffer，它可以根据元素的多少来改变长度。但是StringBuffer里面存放的内容最终都是字符串，而我们想存放的是学生对象，所以也不行。

这时候就要提起java的容器——集合
集合与数组有什么不同：

1. 数组的长度不可变，集合可变的
2. 数组中存放的数据类型是与定义的时候一致的，集合中可以存放各种数据类型
   （虽说集合中可以存放各种数据类型，但是一般情况下，都是一个集合存放一种数据类型）
3. 集合只能存放引用数据类型
   （比如往集合中添加数字20，这里的20不是int类型，而是Integer类型）

集合中可以存放各种各样的数据，每种数据长度，大小以及自身的特点都不一样
但是不同的集合之间总会有一些共性，都是存放数据，而且可以拥有获取，判断等行为

我们把这些集合类的共性内容不断地向上提取，最终形成了一个集合的继承体系

Collection: 是集合的顶层接口，根据是否唯一，是否有序来区分出不同的集合

Collection的功能方法：

集合与元素

1. 添加功能
   boolean add(Object obj) ：添加一个元素
2. 删除功能
   boolean remove(Object o)：从该集合中删除指定元素的单个实例
   void clear()：删除集合中所有的元素
3. 判断功能
   boolean contains(Object o)：如果此集合包含指定的元素，则返回 true 。
   boolean isEmpty()如果此集合不包含元素，则返回 true 。
4. 长度功能
   int size()返回此集合中的元素数。

import java.util.ArrayList;
import java.util.Collection;
public class demo3 {
    public static void main(String[] args) {
        // Collection collection = new Collection();是不行的
        //因为Collection是一个接口，这里需要用到实现接口的子类
        Collection alist1 = new ArrayList();
        //这里是接口多态的表现

        //add(Object obj) 添加一个元素
        alist1.add("java");
        alist1.add("hive");
        alist1.add("hello");
        System.out.println(alist1.toString()); //[java, hive, hello]
        System.out.println("============");


        // remove(Object o) 删除一个元素
        alist1.remove("hello");
        System.out.println(alist1.toString()); //[java, hive]
        System.out.println("============");


        //contains(Object o)：如果此集合包含指定的元素，则返回 true
        System.out.println(alist1.contains("hive")); //true
        System.out.println("============");

        //int size()返回此集合中的元素数
        System.out.println(alist1.size()); //2
        System.out.println("============");

        //clear() 删除集合中所有的元素
        alist1.clear();

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

    }
}

集合与集合

1. 添加功能
   boolean addAll(Collection c)：添加一个集合的元素
2. 删除功能
   boolean removeAll(Collection c) ：删除指定集合中包含的所有此集合的元素
3. 判断功能
   boolean containsAll(Collection c) ：如果此集合包含指定集合中的所有元素，则返回true。
4. 交集功能
   boolean retainAll(Collection c)：仅保留此集合中包含在指定集合中的元素

package review.ListDemo1;
import java.util.ArrayList;
import java.util.Collection;
public class demo4 {
    public static void main(String[] args) {
        Collection c1 = new ArrayList();
        c1.add("java");
        c1.add("hadoop");

        Collection c2 = new ArrayList();
        c2.add("hive");
        c2.add("java");
        c2.add("hadoop");

        //addAll(Collection c) 添加一个集合元素
        System.out.println(c1.addAll(c2)); //true
        System.out.println(c1.toString());
        System.out.println(c2.toString());

        //boolean containsAll(Collection c) 判断此集合包含指定集合中的所有元素
        System.out.println(c1.containsAll(c2)); //true
        System.out.println(c1.toString()); //[java, hadoop, hive, java, hadoop]
        System.out.println(c2.toString()); //[hive, java, hadoop]

        //boolean retainAll(Collection c) 两个集合求交集
        //c1对c2做交集，最终的交集的结果保存在c1中，c2不变
        System.out.println(c1.retainAll(c2)); //false，当两个集合元素相同时返回false
        c1.add("test");
        System.out.println(c1.retainAll(c2)); //true
        System.out.println(c1.toString()); //[java, hadoop, hive, java, hadoop]删去不重复的元素，结果保存在c1
        System.out.println(c2.toString());

        //removeAll(Collection c) 删除指定集合中包含的所有此集合的元素
        c1.removeAll(c2);
        //这里集合为空，因为c2集合中包括了hive,java,hadoop，将会从c1中删去这些元素
        System.out.println(c1.toString()); //[]


    }
}

将集合转为数组

Object[] toArray()：返回一个包含此集合中所有元素的数组

package review.ListDemo1;
import java.util.ArrayList;
import java.util.Collection;
public class demo5 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("apple");
        c.add("pear");
        c.add("banana");

        Object[] objects = c.toArray();
        for(int i=0;i<objects.length;i++){
            System.out.println(objects[i]);
            //向下转型，获取每个字符串的长度
            String s = (String)objects[i];
            System.out.println("字符串长度为"+s.length());
        }
    }
}

遍历集合

Iterator iterator()：获取集合的迭代器对象

package review.ListDemo1;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class demo6 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        Student s1 = new Student("zhang",12);
        Student s2 = new Student("zhao",13);
        Student s3 = new Student("zhou",14);

        c.add(s1);
        c.add(s2);
        c.add(s3);

        //方法一
        Object[] objects = c.toArray();
        for(int i=0;i<objects.length;i++){
            //这里可以直接打印是因为调用了toString方法
            //这是Object类型的数组元素却可以调用toString，是因为Object类有toString方法
            //Student类重写了这个方法，所以才能调用
            System.out.println(objects[i]);
            //Object类里面没有getName等方法，所以需要向下转型
            Student s = (Student)objects[i];
            System.out.println(s.getName()+"---"+s.getAge());
        }

        //方法二
        Iterator it = c.iterator();
        while(it.hasNext()){
            Object o = it.next();
            System.out.println(o);
            Student s  = (Student)o;
            System.out.println(s.getName()+"---"+s.getAge());
        }

    }
}