• 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{

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66

    运行结果：

    在这里插入图片描述

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

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    运行结果：

    在这里插入图片描述

    示例代码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);
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    运行结果:

    在这里插入图片描述

    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
    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

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

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47

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


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
  • 相关阅读:
    42、集合的第一大类：List
    SAFe术语表
    Flink 实时数仓（七）【DWS 层搭建（一）流量域汇总表创建】
    计算机竞赛 大数据疫情分析及可视化系统
    python自动化测试 | 接口自动化测试脚本如何写好？
    基于Matlab实现标准规划问题求解（源码+数据）
    Android-SQLite数据库实战
    深入剖析Golang中单例模式
    Expo项目 通过EAS update发布
    StarRocks实战——云览科技存算分离实践
  • 原文地址：https://blog.csdn.net/qq_46096136/article/details/126660927