Java基础进阶集合-Collection接口

关于java.util.Collection接口中常用的方法。

什么是集合？有什么用？

• 数组其实就是一个集合。集合实际上就是一个容器。可以来容纳其它类型的数据。

1、Collection中能存放什么元素？

• 没有使用“泛型”之前，Collection中可以存储Object的所有子类型

• 使用了“泛型”之后，Collection中只能存储某个具体的类型

集合后期学习“泛型”语法。目前先不用管。Collection中什么都能存，

只要是Object的子类型就行。（集合中不能直接存储基本数据类型，也不能存储

java对象，只能存储java对象的内存地址）

2、Collection中的常用方法

boolean add(Object e) 向元素中添加元素

int size() 获取集合中元素的个数

void clear() 清空集合

boolean contians(Object o) 判断当前集合中是否包含元素o，包含返回true，不包含返回false

boolean remove(Object o) 删除集合中的某个元素

boolean isEmpty() 判断该集合中元素的个数是否为0

Object[] toArray() 调用这个方法可以把集合转换成数组

示例代码01：

public class CollectionTest01 {
    public static void main(String[] args) {

        // 创建一个集合对象
        //Collection c = new Collection(); // 接口是抽象的，无法实例化。
        // 多态
        Collection c = new ArrayList();
        c.add(100);//java5新特性，实际上是放进去了对象的内存地址，自动装箱 Integer i = new Integer(100);
        c.add(new Object());
        c.add(new String());
        c.add(true);//自动装箱

        //查看集合里有几个元素
        System.out.println("集合中元素的个数是：" + c.size());

        //清空集合元素
        c.clear();
        System.out.println("集合中元素的个数是：" + c.size());

        //再次向集合中添加元素
        c.add("hello");//实际上存储的是hello字符串对象的内存地址
        c.add("world");
        c.add("绿巨人");
        c.add("浩克");
        c.add(1);
        System.out.println("集合中元素的个数是：" + c.size());

        //查看集合中是否包含该元素
        boolean flag = c.contains("绿巨人");
        System.out.println(flag);//true
        boolean flag2 = c.contains("绿巨人1");
        System.out.println(flag2);//false

        //删除部分集合元素
        c.remove(1);

        System.out.println("集合中元素的个数是：" + c.size());

        //判断集合是否为空
        boolean flag3 = c.isEmpty();
        System.out.println(flag3);//false
        c.clear();
        boolean flag4 = c.isEmpty();
        System.out.println(flag4);//true

        //往集合中添加元素
        c.add("abc");
        c.add("def");
        c.add(100);
        c.add("helloworld");
        c.add(new Student());

        //把集合中转换成数组
        Object[] obj = c.toArray();
        //把转换的数组进行遍历
        for(int i=0;i<obj.length;i++){
            Object o = obj[i];
            System.out.println(o);
//            System.out.println(0.toString());
        }
    }
}

class Student{

}

运行结果：

3、集合的遍历迭代：

示例代码02：

public class CollectionTest02 {
    public static void main(String[] args) {

        //以下的遍历/迭代是所有Collection通用的一种方式
        //在map集合中不能用。在所有的Collection以及子类中使用
        //创建集合对象
        Collection c = new ArrayList();

        c.add("abc");
        c.add("def");
        c.add(100);
        c.add("helloworld");
        c.add(new Object());

        //对集合Collection进行遍历/迭代
        //第一步：获取集合对象的迭代器对象Iterator
        Iterator it = c.iterator();

        //第二步：通过以上获取的迭代器对象开始迭代/遍历集合
        /*
        * 以下两个方法是迭代器对象Iterator中的方法
        * boolean hasnext()如果仍有元素可以迭代，则返回true
        * Object next() 返回迭代的下一个元素
        * */
        while(it.hasNext()){
            Object o = it.next();
            System.out.println(o);
        }

    }
}

运行结果：

示例代码03：

public class CollectionTest03 {
    public static void main(String[] args) {

        //List存储有序可重复的元素，有序(存进去的顺序和取出来的顺序是一致的)
        Collection c1 = new ArrayList();
        c1.add(1);
        c1.add(3);
        c1.add(5);
        c1.add(7);
        c1.add(9);
        c1.add(1);
        Iterator it = c1.iterator();
        while(it.hasNext()){
            Object o = it.next();//存进去的是什么类型，取出的也是什么类型
             /*if(obj instanceof Integer){
                System.out.println("Integer类型");
            }*/
            // 只不过在输出的时候会转换成字符串。因为这里println会调用toString()方法。
            System.out.println(o);
        }

        //set存储无序不可重复的元素，无序（存进去的顺序和取出的顺序不一致）
        Collection c2 = new HashSet();
        c2.add(100);
        c2.add(50);
        c2.add(400);
        c2.add(300);
        c2.add(200);
        c2.add(600);
        c2.add(100);
        c2.add(300);
        Iterator it1 = c2.iterator();
        while(it1.hasNext()){
            Object o = it1.next();
            System.out.println(o);
        }
    }
}

运行结果:

4、深入Collection集合的contains方法：

• boolean contains(Object o)
• 判断集合中是否包含某个对象o、
• 如果包含返回true， 如果不包含返回false。

contains方法是用来判断集合中是否包含某个元素的方法，
那么它在底层是怎么判断集合中是否包含某个元素的呢？

• 调用了equals方法进行比对。
• equals方法返回true，就表示包含这个元素。
  

示例代码04：

public class CollectionTest04 {

    public static void main(String[] args) {

        Collection c = new ArrayList();

        String s1 = new String("abc");
        c.add(s1);

        String s2 = new String("def");
        c.add(s2);

        String s3 = new String("abc");
        // c集合中是否包含x？结果猜测一下是true还是false？
        System.out.println(c.contains(s3));//判断集合中是否存在"abc" true
    }

}

5、测试contains方法 测试remove方法。
结论：存放在一个集合中的类型，一定要重写equals方法。

示例代码05：

public class CollectionTest05 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        User u1 =new User("jack");
        c.add(u1);

        // 没有重写equals之前：这个结果是false
        //System.out.println(c.contains(u2)); // false
        // 重写equals方法之后，比较的时候会比较name。
        User u2 = new User("jack");
        System.out.println(c.contains(u2));//true

        Collection cc = new ArrayList();
        String s1 = new String("jack");
        cc.add(s1);

        String s2 = new String("jack");
        c.remove(s2);//remove底层调用equals方法进行比较
        System.out.println(c.size());//0


    }
}

class User{
    private String name;

    public User() {
    }

    public User(String name) {
        this.name = name;
    }

    @Override
    // 重写equals方法
    // 将来调用equals方法的时候，一定是调用这个重写的equals方法。
    // 这个equals方法的比较原理是：只要姓名一样就表示同一个用户。
    //java中默认的equals方法比较的是对象的内存地址
    public boolean equals(Object o) {
       if(o == null || !(o instanceof User)) return false;
       if(this == o) return true;
        User o1 = (User) o;
        return this.name.equals(o1.name);
    }

}

6、集合结构只要发生改变，迭代器必须重新获取。

示例代码06：

public class CollectionTest06 {
    public static void main(String[] args) {

        Collection c = new ArrayList();

        // 注意：此时获取的迭代器，指向的是那是集合中没有元素状态下的迭代器。
        // 一定要注意：集合结构只要发生改变，迭代器必须重新获取。
        // 当集合结构发生了改变，迭代器没有重新获取时，调用next()方法时：java.util.ConcurrentModificationException
        Iterator it = c.iterator();
        c.add("abc");
        c.add("def");
        c.add(100);
        c.add("helloworld");
        while(it.hasNext()){
            // 编写代码时next()方法返回值类型必须是Object。
            Object o = it.next();
            System.out.println(o);
        }

        Collection cc = new ArrayList();
        cc.add("abc");
        cc.add("def");
        cc.add("xyz");

        Iterator it1 = cc.iterator();
        while(it1.hasNext()){
            Object o = it1.next();
            //删除元素
            //删除元素之后，集合的结构发生了变化，应该重新去获取迭代器
            //但是，循环下一次的时候并没有重新获取迭代器，所以会出现异常：java,util,ConcurrentModificationException
            //出异常的根本原因是：集合中元素删除了，但是没有更新迭代器（迭代器不知道集合变化）
            //c.remove(o);//直接通过集合去删除元素，没有通知迭代器。（导致迭代器的快照和原来的集合状态不同）
            //使用迭代器来删除可以吗？
            //迭代器去删除时，会自动更新迭代器，并且更新集合（删除集合中的元素）
            it1.remove();//删除的一定是迭代器指向的当前元素
            System.out.println(o);
        }
    }
}