Java基础进阶集合-Collection接口

末蓝、 2023-10-08 16:47 24阅读 0赞

关于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() 调用这个方法可以把集合转换成数组  
![在这里插入图片描述][b14af13729e94c1db35f362eb8d80fbc.png]

#### 示例代码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{
        
    
    }

#### 运行结果： ####

![在这里插入图片描述][9094058edfb74a9a801cb799736787db.png]

3、集合的遍历迭代：

![图片分析：][8b0420c403954cbdb362551d70579c66.png]  
![在这里插入图片描述][a07f017d5bf04d65a411523c1a57ba00.png]

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

#### 运行结果： ####

![在这里插入图片描述][fe27e8e541cd4766ae8f1e75227e0e4c.png]

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

#### 运行结果: ####

![在这里插入图片描述][6ecfb33d8f724c758bcc2054b24c977f.png]

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

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

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

*  调用了equals方法进行比对。
 *  equals方法返回true，就表示包含这个元素。  
    ![在这里插入图片描述][1841bfa4a6cb4c4380024578188536e1.png]

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

[b14af13729e94c1db35f362eb8d80fbc.png]: https://img-blog.csdnimg.cn/b14af13729e94c1db35f362eb8d80fbc.png
[9094058edfb74a9a801cb799736787db.png]: https://img-blog.csdnimg.cn/9094058edfb74a9a801cb799736787db.png
[8b0420c403954cbdb362551d70579c66.png]: https://img-blog.csdnimg.cn/8b0420c403954cbdb362551d70579c66.png
[a07f017d5bf04d65a411523c1a57ba00.png]: https://img-blog.csdnimg.cn/a07f017d5bf04d65a411523c1a57ba00.png
[fe27e8e541cd4766ae8f1e75227e0e4c.png]: https://img-blog.csdnimg.cn/fe27e8e541cd4766ae8f1e75227e0e4c.png
[6ecfb33d8f724c758bcc2054b24c977f.png]: https://img-blog.csdnimg.cn/6ecfb33d8f724c758bcc2054b24c977f.png
[1841bfa4a6cb4c4380024578188536e1.png]: https://img-blog.csdnimg.cn/1841bfa4a6cb4c4380024578188536e1.png