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);
        }
    }
}