【集合】集合和数组的不同点， Collection，集合的遍历，利用数组遍历，迭代器遍历，list接口（继承自Collection接口），List相关集合特有的功能

心盲i1

已于 2022-02-14 13:56:07 修改

阅读量274

点赞数

分类专栏： Java基础文章标签： list 数据结构链表集合

于 2022-02-13 22:23:28 首次发布

本文链接：https://blog.csdn.net/qq_46563096/article/details/122913808

版权

本文详细探讨了集合与数组之间的不同点，包括长度的可变性、元素类型以及内存占用。介绍了Collection接口作为集合的顶层接口及其子类ArrayList的功能，如添加、删除、获取元素等操作。讲解了集合的遍历方式，如数组遍历、迭代器遍历，强调了在遍历过程中避免并发修改异常的方法。此外，文章还深入讨论了List接口的特点，如有序性、索引概念和元素重复性，并展示了List特有的遍历方式以及处理集合中元素去重的策略。

摘要由CSDN通过智能技术生成

集合

一.集合和数组的不同点：

1、数组的长度是不可变的，集合的长度是可变的
2、数组可以存放同一种基本数据类型或者引用数据类型的元素
而集合只能存放引用数据类型，并且集合中可以存放法不同数据类型的元素
（注意：这里我虽然说了集合可以存放不同的数据类型，实际确实也可以这么做，但是呢，
在实际开发中，一个集合存放一种引用数据类型的元素）

集合可以存放各种各样的数据，每种数据的长度，大小以及自身的特点都不一样。
所以，java提供的集合也不应该是单一的，我们要针对不同的需求，使用java提供的不同的集合。
这么多不同的集合，它们底层的数据结构也是不同的，占用的内存空间也是不一样的。不同不重要，我们只需要知道集合是可以用来
存放数据的，不光可以存放，而且可以使用这些数据，比如：查找数据，获取数据，判断数据，删除数据等等。

既然可以进行上面的操作，这些不同集合类，应该有着某种共
性，所以我们根据集合的共性内容不断地向上提取，最终形成一
个继承体系。

集合的总体结构图：

二. Collection:是集合中的顶层接口，它存在由它展开而来的继承体系。

至于为什么要有这么多不同的集合，根据元素是否唯一，是否有序来这么多集合（后面的课程中我们会一一学习）

Collection:
由于Collection是一个接口，所以无法被实例化，我们要找它一个子类来进行接口多态的方式实例化，这里我们就暂时用ArrayList
来举例。
1、添加功能
boolean add(Object e)确保此集合包含指定的元素（可选操作）
boolean addAll(Collection c) 将指定集合中的所有元素添加到此集合（可选操作）
2、删除功能
boolean remove(Object o) 从该集合中删除指定元素的单个实例（如果存在）（可选操作）。
boolean removeAll(Collection c) 删除指定集合中包含的所有此集合的元素（可选操作）。
void clear() 从此集合中删除所有元素（可选操作）。
3、获取功能
Iterator iterator() 返回此集合中的元素的迭代器。
4、判断功能
boolean contains(Object o) 如果此集合包含指定的元素，则返回 true 。
boolean containsAll(Collection c) 如果此集合包含指定集合中的所有元素，则返回true。
boolean isEmpty() 如果此集合不包含元素，则返回 true 。
5、获取长度方法：
int size() 返回此集合中的元素数
6、求交集功能
boolean retainAll(Collection c) 仅保留此集合中包含在指定集合中的元素（可选操作）。
7、将集合转成数组
Object[] toArray() 返回一个包含此集合中所有元素的数组。

1.boolean add(Object e)确保此集合包含指定的元素（可选操作）
2.boolean remove(Object o) 从该集合中删除指定元素的单个实（如果存在）（可选操作）。删除指定的元素只移除一个符合条件的元素
3.boolean contains(Object o) 如果此集合包含指定的元素，则返回 true 。判断该集合中是否包含某个元素，如果包含，返回true
4.boolean isEmpty() 如果此集合不包含元素，则返回 true 。
5.void clear() 从此集合中删除所有元素（可选操作）。
6.int size() 返回此集合中的元素数,集合集合的长度


```java
 import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo1 {
   
    public static void main(String[] args) {
   
        Collection c=new ArrayList();
        //1.boolean add(Object e)确保此集合包含指定的元素
        //（可选操作）
        c.add("helloworld");
        c.add("java");
        c.add("dashuju");
        c.add(90);
        c.add(2.89);
        System.out.println(c);//结果：[helloworld, java,
        // dashuju, 90, 2.89]


  //2.boolean remove(Object o) 从该集合中删除指定元素的单个
  //实例（如果存在）（可选操作）。
        //删除指定的元素
        //只移除一个符合条件的元素
 System.out.println("从集合中删除指定元素："+c.remove("java"));
 //结果：从集合中删除指定元素：true
 System.out.println("删除后的的集合为："+c);
 //结果：删除后的的集合为：[helloworld, dashuju, 90, 2.89]


 //3.boolean contains(Object o) 如果此集合包含指定的元素，则返
 //回 true 。
  //判断该集合中是否包含某个元素，如果包含，返回true
  System.out.println("该集合中是否包含此元素："+c.contains("dashuju"));
  //该集合中是否包含此元素：true



   //4.boolean isEmpty() 如果此集合不包含元素，则返回 true 。
     System.out.println("该集合是否为空："+c.isEmpty());
     //该集合是否为空：false

   //5.void clear() 从此集合中删除所有元素（可选操作）。
   //c.clear();
   //  System.out.println(c);//[]

   //6.int size() 返回此集合中的元素数
   //集合集合的长度
    System.out.println(c.size());//4


        /**
         * java.lang.Object
         *      java.util.AbstractCollection<E>
         *              java.util.AbstractList<E>
         *                      java.util.ArrayList<E>
         */
        System.out.println(c);
     //这里调用的是AbstractCollection类中的toString()方
     //法,重写的toString方法。




    }
}

结果：在这里插入图片描述

boolean addAll(Collection c) 将指定集合中的所有元素添加到此集合（可选操作）
boolean removeAll(Collection c) 删除指定集合中包含的所有此集合的元素（可选操作）。
9.boolean containsAll(Collection c) 如果此集合包含指定集合中的所有元素，则返回true。
boolean retainAll(Collection c) 仅保留此集合中包含在指定集合中的元素（可选操作）。

public class CollecctionDemo2 {
   
    public static void main(String[] args) {
   
        Collection c1=new ArrayList();
        Collection c2=new ArrayList();
        c1.add("java");
        c1.add("hadoop");
        c1.add("hive");
        c1.add("mysql");
        c1.add("c语言");
        c2.add("java");
        c2.add("hive");
        c2.add("mysql");
        c2.add("web");
        System.out.println("c1:"+c1);//c1:[java, hadoop, hive, mysql, c语言]
        System.out.println("c2:"+c2);//c2:[java, hive, mysql, web]
  //1. boolean addAll(Collection c) 将指定集合中的所有元素
  //添加到此集合（可选操作），
 //注意这类可以重复添加，即使集合已经有了该集合就重复添加到该集合
 //中去。
   // System.out.println(c1.addAll(c2));//true
  //System.out.println("c1:"+c1);
  //c1:[java, hadoop, hive, mysql, c语言, java, hive, mysql, web]
  //System.out.println("c2:"+c2);
  //c2:[java, hive, mysql, web]


        //2.boolean removeAll(Collection c) 删除指定集合
        //中包含的所有此集合的元素（可选操作）。
    //注意：这里的集合删除即使有重复的该集合，只要有就全部删除。
       // System.out.println(c1.removeAll(c2));//true
   //System.out.println("c1:"+c1);//c1:[hadoop, c语言]
 //System.out.println("c2:"+c2);
 //c2:[java, hive, mysql, web]


       //3. boolean containsAll(Collection c) 如果此集合
       //包含指定 集合中的所有元素，则返回true。
        System.out.println(c1.containsAll(c2));//true
        System.out.println(c2.containsAll(c1));//false
        System.out.println("c1:"+c1);
//c1:[java, hadoop, hive, mysql, c语言, java, hive, mysql, web]
        System.out.println("c2:"+c2);
        //c2:[java, hive, mysql, web]

  //4. boolean retainAll(Collection c) 仅保留此集合中包含
  //在指定集合中的元素（可选操作）。
        /**
         *  假设现在有两个集合c1,c2
         *  c1对c2交集，最终交集的结果保存在c1中，c2不变
         *  并且c1删除与c2不是共同的元素。
         */
      //  System.out.println(c1.retainAll(c2));//true
      
        System.out.println("c1:"+c1);
        //c1:[java, hive, mysql] c1只保留交集
        
        System.out.println("c2:"+c2);
        //c2:[java, hive, mysql, web] c2保持不变


        System.out.println(c2.retainAll(c1));//true

        System.out.println("c1:"+c1);
     //c1:[java, hadoop, hive, mysql, c语言] c1保持不变
     System.out.println("c2:"+c2);
     //c2:[java, hive, mysql] c2只保留两者的交集


    }
}

结果：

二.集合的遍历

1.利用数组遍历

集合的遍历：目的就是将集合中的元素依次取出来
Object[] toArray() 返回一个包含此集合中所有元素的数组。
将集合转化成数组，然后再遍历

public class CollctionDemo3 {
   
    public static void main(String[] args) {
   
        Collection c=new ArrayList();
        c.add("姓名");
        c.add("年龄");
        c.add("性别");
        c.add("学历");
        c.add("政治面貌");
        //Object[] toArray() 返回一个包含此集合中所有元素的数组。
        Object[] objects = c.toArray();


        for (int i=0;i< objects.length;i++){
   
         //   System.out.println(objects[i]); 
   // Object o = objects[i](String类型的);实际上是一个多态
    //因为获取到的元素是由Object类型接收的，实际是String类型
            //这样就形成了多态
            //而多态调用成员方法，编译看左，运行看右
            //Object类中没有length()方法，所以报错
            //要想使用子类中特有的方法，就要向下转型
            String s=(String) objects[i];
            //需求：想要获取每一个字符串元素的长度？
//            System.out.println(objects[i].length());
          System.out.println(s+"--------"+s.length());
        }
    }