• Java-单列集合Collection详解

    一、单列集合

    单列集合一次只能添加一个元素

    Collection是顶层父类接口

    List系列集合：

    添加的元素是有序、可重复、有索引的，其中有序指的是存和取得顺序一致（e.g:我存进去的是1，2，3，取出来的是1，2，3），重复指的是集合中存储的元素是可以重复的，有索引指的是我们可以通过索引获取每一个元素。

    Set系列集合：

    添加的元素是无序、不重复、无索引的，其中无序指的是存和取得顺序可能不一致（e.g:我存进去的是1，2，3，取出来的可能是3，1，2），不重复指的是集合中存储的元素是不可以重复的，无索引指的是我们不可以通过索引获取每一个元素。

    二、单列集合之Collection的概念

    Collection是单列集合的祖宗接口（顶层父接口），它的功能是全部单列集合都可以使用的。

    三、单列集合之Collection创建集合

    Collection是接口 不能直接创建集合对象，但是可以通过该接口的具体类来创建集合对象，在Java中，一个对象变量可以引用任何实现了特定接口的类的实例（比如下面例子中的coll），这是java中多态的作用，你可以通过接口来引用任何实现了该接口的类的实例，从而增加了代码的灵活性和可维护性。因为你可以轻松地改变 coll 背后使用的实现类，而不需要修改所有使用 coll 的代码。例如，你可以将 new ArrayList<>() 替换为 new LinkedList<>() 或其他任何实现了 Collection 接口的类的实例，而无需修改其他代码。

    e.g:  Collection coll=new ArrayList<>()；

    通过ArrayList实现类创建集合

    四、单列集合之Collection的常用方法

    注意：Collection是接口，在使用它的方法时，不能创建它的对象，要创建它的实现类，通过它的实现类来使用接口的方法

    1、添加元素

    语法：集合名称.add(元素)；

    当往List系列添加元素时，返回值永远是true，因为List可以添加重复元素

    当往Set系列添加元素时，当该元素已经在集合中存在时，那么返回值是false，当该元素集合中没有存在时，那么返回值是true，因为Set不可以添加重复元素

    1. import java.util.ArrayList;
    2. import java.util.Collection;
    3.  
    4. public class test1 {
    5.     public static void main(String[] args) {
    6.         // 生成一个coll变量 它的类型是Collection 表示一组元素 其元素类型必须是String
    7.         Collection coll=new ArrayList<>();
    8.         // 1.添加
    9.         // 返回值为布尔类型
    10.         boolean r1= coll.add("abc");
    11.         System.out.println(r1);// true
    12.         System.out.println(coll);// [abc]
    13.         boolean r2= coll.add("efg");
    14.         System.out.println(r2);// true
    15.         System.out.println(coll);// [abc, efg]
    16.     }
    17. }

    2、清空集合

    语法：集合名称.clear()；

    当往List系列添加元素时，返回值永远是true，因为List可以添加重复元素

    当往Set系列添加元素时，当该元素已经在集合中存在时，那么返回值是false，当该元素集合中没有存在时，那么返回值是true，因为Set不可以添加重复元素

    1. import java.util.ArrayList;
    2. import java.util.Collection;
    3.  
    4. public class test1 {
    5.     public static void main(String[] args) {
    6.         // 生成一个coll变量 它的类型是Collection 表示一组元素 其元素类型必须是String
    7.         Collection coll=new ArrayList<>();
    8.         // 1.添加
    9.         // 返回值为布尔类型
    10.         boolean r1= coll.add("abc");
    11.         System.out.println(r1);// true
    12.         System.out.println(coll);// [abc]
    13.         boolean r2= coll.add("efg");
    14.         System.out.println(r2);// true
    15.         System.out.println(coll);// [abc, efg]
    16.  
    17.         //2.清空
    18.         //清空集合所有的元素
    19.         coll.clear();
    20.         System.out.println(coll);// []
    21.     }
    22. }

    3、删除元素

    语法：集合名称.remove(元素)；

    当要删除的元素在集合中存在时，那么返回值是true，当该元素集合中没有存在时，那么返回值是false

    Collection 接口没有提供按索引删除元素的方法。Collection 接口定义的方法都是基于元素的，而不是基于索引的。

    1. import java.util.ArrayList;
    2. import java.util.Collection;
    3.  
    4. public class test1 {
    5.     public static void main(String[] args) {
    6.         // 生成一个coll变量 它的类型是Collection 表示一组元素 其元素类型必须是String
    7.         Collection coll=new ArrayList<>();
    8.         // 1.添加
    9.         // 返回值为布尔类型
    10.         boolean r1= coll.add("abc");
    11.         System.out.println(r1);// true
    12.         System.out.println(coll);// [abc]
    13.         boolean r2= coll.add("efg");
    14.         System.out.println(r2);// true
    15.         System.out.println(coll);// [abc, efg]
    16.  
    17.         // 2.删除
    18.         // 删除成功返回true 删除失败返沪false
    19.         boolean r3=coll.remove("abc");
    20.         System.out.println(r3);// true
    21.         System.out.println(coll);// [efg]
    22.         boolean r4=coll.remove("aaa");
    23.         System.out.println(r4);// false
    24.         System.out.println(coll);// [efg]
    25.     }
    26. }

    4、判断集合是否包含该元素

    语法：集合名称.contains(元素)；

    当要元素在集合中存在时，那么返回值是true，当该元素集合中没有存在时，那么返回值是false

    细节：它的底层逻辑是通过equals方法进判断的，因此当集合存储的元素是对象时，也想通过

    contains判断该对象是否存在时，需要重写JavaBean的contains方法

    1. import java.util.ArrayList;
    2. import java.util.Collection;
    3.  
    4. public class test1 {
    5.     public static void main(String[] args) {
    6.         // 生成一个coll变量 它的类型是Collection 表示一组元素 其元素类型必须是String
    7.         Collection coll=new ArrayList<>();
    8.         // 1.添加
    9.         // 返回值为布尔类型
    10.         boolean r1= coll.add("abc");
    11.         System.out.println(r1);// true
    12.         System.out.println(coll);// [abc]
    13.         boolean r2= coll.add("efg");
    14.         System.out.println(r2);// true
    15.         System.out.println(coll);// [abc, efg]
    16.  
    17.         // 2.判断元素是否包含
    18.         boolean r3=coll.contains("aaa");
    19.         System.out.println(r3);// false
    20.         boolean r4=coll.contains("abc");
    21.         System.out.println(r4);// true
    22.     }
    23. }

    5、判断集合是否为空

    语法：集合名称.isEmpty()；

    1. import java.util.ArrayList;
    2. import java.util.Collection;
    3.  
    4. public class test1 {
    5.     public static void main(String[] args) {
    6.         // 生成一个coll变量 它的类型是Collection 表示一组元素 其元素类型必须是String
    7.         Collection coll=new ArrayList<>();
    8.         // 1.添加
    9.         // 返回值为布尔类型
    10.         boolean r1= coll.add("abc");
    11.         System.out.println(r1);// true
    12.         System.out.println(coll);// [abc]
    13.         boolean r2= coll.add("efg");
    14.         System.out.println(r2);// true
    15.         System.out.println(coll);// [abc, efg]
    16.  
    17.         // 2.判断元素是否为空
    18.         boolean r3=coll.isEmpty();
    19.         System.out.println(r3);// false
    20.     }
    21. }

    6、获取集合的长度

    语法：集合名称.size()；

    1. public class test1 {
    2.     public static void main(String[] args) {
    3.         // 生成一个coll变量 它的类型是Collection 表示一组元素 其元素类型必须是String
    4.         Collection coll=new ArrayList<>();
    5.         // 1.添加
    6.         // 返回值为布尔类型
    7.         boolean r1= coll.add("abc");
    8.         System.out.println(r1);// true
    9.         System.out.println(coll);// [abc]
    10.         boolean r2= coll.add("efg");
    11.         System.out.println(r2);// true
    12.         System.out.println(coll);// [abc, efg]
    13.  
    14.         // 2.判断元素是否为空
    15.         int r3=coll.size();
    16.         System.out.println(r3);// 2
    17.     }
    18. }

    五、单列集合之Collection的遍历方式

    Collection的遍历方式有三种，迭代器遍历、增强for遍历、lamda表达式遍历，没有普通的for循环遍历，因为普通的for循环遍历需要通过索引遍历，而set没有索引，因此没有普通的for循环遍历

    1、迭代器遍历

    迭代器在java中的类是Iterator，迭代器是集合专用的遍历方式

    step1：Collection获取迭代器的方式是Iterator<集合元素类型>迭代器名称=集合名称.Iterator()；

    （

    • Iterator 是Java集合框架中的一个接口，它提供了一种遍历集合元素的方式。
    •  是一个泛型参数，它指定了这个迭代器将用于遍历包含String类型元素的集合。

    ）

    它返回迭代器对象（指针），默认指向当前集合的0索引

    step2：迭代器对象名称.hasnext()；用来判断当前位置是否存在元素，如果存在则返回true，如果不存在则返回false

    step3：迭代器对象名称.next()；用来获取当前位置的元素，并将迭代器指向下一个位置

    通过这三种方法 我们就可以遍历集合

    语法：

    Iterator<集合元素类型>迭代器名称=集合名称.Iterator()；

    while(迭代器对象名称.hasnext()){

            System.out.println(迭代器对象名称.next())；

    }

    1. import java.util.ArrayList;
    2. import java.util.Collection;
    3. import java.util.Iterator;
    4.  
    5. public class 迭代器遍历 {
    6.     public static void main(String[] args) {
    7.         // 1.创建集合并添加元素
    8.         Collection coll=new ArrayList<>();
    9.         coll.add("文韬");
    10.         coll.add("黄子弘凡");
    11.         coll.add("何运晨");
    12.  
    13.         // 2.创建迭代器对象
    14.         Iterator it=coll.iterator();
    15.  
    16.         // 3.迭代器遍历集合
    17.         while (it.hasNext()){
    18.             System.out.println(it.next());
    19.         }
    20.         // 文韬
    21.         // 黄子弘凡
    22.         // 何运晨
    23.     }
    24. }

    注意点：

    ①迭代器遍历完毕，指针不会复位

    如果想要遍历第二次 就要生成新的迭代器对象

    1. import java.util.ArrayList;
    2. import java.util.Collection;
    3. import java.util.Iterator;
    4.  
    5. public class 迭代器遍历 {
    6.     public static void main(String[] args) {
    7.         // 1.创建集合并添加元素
    8.         Collection coll=new ArrayList<>();
    9.         coll.add("文韬");
    10.         coll.add("黄子弘凡");
    11.         coll.add("何运晨");
    12.  
    13.         // 2.创建迭代器对象
    14.         Iterator it=coll.iterator();
    15.  
    16.         // 3.迭代器遍历集合
    17.         while (it.hasNext()){
    18.             System.out.println(it.next());
    19.         }
    20.         // 文韬
    21.         // 黄子弘凡
    22.         // 何运晨
    23.  
    24.         // 迭代器遍历完毕，指针不会复位
    25.         // 以下结果都是false 因为遍历完集合 指针指向没有元素的位置 而且不会复原
    26.         System.out.println(it.hasNext());// false
    27.         System.out.println(it.hasNext());// false
    28.         System.out.println(it.hasNext());// false
    29.         System.out.println(it.hasNext());// false
    30.         System.out.println(it.hasNext());// false
    31.  
    32.         // 遍历第二次
    33.         // 需要生成新的迭代器对象
    34.         Iterator it2=coll.iterator();
    35.         while (it2.hasNext()){
    36.             System.out.println(it2.next());
    37.         }
    38.         // 文韬
    39.         // 黄子弘凡
    40.         // 何运晨
    41.     }
    42.     }
    43. }

    ②循环中只能使用一次next方法

    如果在循环中使用多次next方法就可能出现该位置没有元素的情况

    1. import java.util.ArrayList;
    2. import java.util.Collection;
    3. import java.util.Iterator;
    4.  
    5. public class 迭代器遍历 {
    6.     public static void main(String[] args) {
    7.         // 1.创建集合并添加元素
    8.         Collection coll=new ArrayList<>();
    9.         coll.add("文韬");
    10.         coll.add("黄子弘凡");
    11.         coll.add("何运晨");
    12.  
    13.         // 2.创建迭代器对象
    14.         Iterator it=coll.iterator();
    15.  
    16.         // 3.迭代器遍历集合
    17.         while (it.hasNext()){
    18.             System.out.println(it.next());
    19.             System.out.println(it.next());
    20.         }
    21.         // 文韬
    22.         // 黄子弘凡
    23.         // 何运晨
    24.         // 报错：NoSuchElementException
    25.     }
    26. }

    ③迭代器遍历时，不能用集合的方式进行增加或删除，必须用迭代器的方法进行删除

    1. import java.util.ArrayList;
    2. import java.util.Collection;
    3. import java.util.Iterator;
    4.  
    5. public class 迭代器遍历 {
    6.     public static void main(String[] args) {
    7.         // 1.创建集合并添加元素
    8.         Collection coll=new ArrayList<>();
    9.         coll.add("文韬");
    10.         coll.add("黄子弘凡");
    11.         coll.add("何运晨");
    12.  
    13.         // 2.创建迭代器对象
    14.         Iterator it=coll.iterator();
    15.  
    16.         // 3.迭代器遍历集合
    17.         while (it.hasNext()){
    18.             System.out.println(it.next());
    19.             // 通过迭代器的remove方法删除元素
    20.             it.remove();
    21.             // 如果不输出当前元素的值 而是直接删除当前元素的值并将指针下移 就会报错
    22.         }
    23.  
    24.         // 4.输出集合中的元素
    25.         System.out.println(coll);
    26.     }
    27. }

    ④当迭代器遍历完之后再次使用 迭代器对象名称.next()就会报错

    1. import java.util.ArrayList;
    2. import java.util.Collection;
    3. import java.util.Iterator;
    4.  
    5. public class 迭代器遍历 {
    6.     public static void main(String[] args) {
    7.         // 1.创建集合并添加元素
    8.         Collection coll=new ArrayList<>();
    9.         coll.add("文韬");
    10.         coll.add("黄子弘凡");
    11.         coll.add("何运晨");
    12.  
    13.         // 2.创建迭代器对象
    14.         Iterator it=coll.iterator();
    15.  
    16.         // 3.迭代器遍历集合
    17.         while (it.hasNext()){
    18.             System.out.println(it.next());
    19.         }
    20.         // 文韬
    21.         // 黄子弘凡
    22.         // 何运晨
    23.  
    24.         // 当迭代器遍历完之后再次使用 迭代器对象名称.next()就会报错
    25.         System.out.println(it.next());// NoSuchElementException 表示不存在这个元素
    26.     }
    27. }

    迭代器总结：

    1、迭代器遍历不需要依赖索引，它是通过创建指针并移动指针来遍历集合中的元素

    2、迭代器需要掌握的三种方法

    Iterator<集合元素类型>迭代器名称=集合名称.Iterator()；

    迭代器对象名称.hasnext()；

    迭代器对象名称.next()；

    2、增强for遍历

    增强for的底层就是迭代器，是为了简化迭代器的代码书写的

    所有的单列集合和数组才能用增强for进行遍历

    语法：

    for(元素的数据类型 变量名：数组或者单列集合){

    }

    其中变量名存储的内容就是遍历过程中的每一个元素

    1. import java.util.ArrayList;
    2. import java.util.Collection;
    3.  
    4. public class 增强for遍历 {
    5.     public static void main(String[] args) {
    6.         // 1.创建集合并添加元素
    7.         Collection coll=new ArrayList<>();
    8.         coll.add("文韬");
    9.         coll.add("黄子弘凡");
    10.         coll.add("何运晨");
    11.  
    12.         // 2.增强for循环遍历
    13.         // String表示遍历元素的类型 s用来存储遍历的每一个元素 coll表示遍历的集合名称
    14.         for(String s:coll){
    15.             System.out.println(s);// 遍历过程中的每一个元素
    16.         }
    17.         // 文韬
    18.         // 黄子弘凡
    19.         // 何运晨
    20.     }
    21. }

    注意：当修改变量名存放的内容时，并不会修改集合的内容

    1. import java.util.ArrayList;
    2. import java.util.Collection;
    3.  
    4. public class 增强for遍历 {
    5.     public static void main(String[] args) {
    6.         // 1.创建集合并添加元素
    7.         Collection coll=new ArrayList<>();
    8.         coll.add("文韬");
    9.         coll.add("黄子弘凡");
    10.         coll.add("何运晨");
    11.  
    12.         // 2.增强for循环遍历
    13.         // String表示遍历元素的类型 s用来存储遍历的每一个元素 coll表示遍历的集合名称
    14.         // 修改变量s的内容并不会改变集合的内容
    15.         for (String s : coll) {
    16.             s="aaa";
    17.         }
    18.         System.out.println(coll);
    19.         // 文韬
    20.         // 黄子弘凡
    21.         // 何运晨
    22.         // 输出结果不会变成：
    23.         // aaa
    24.         // aaa
    25.         // aaa
    26.     }
    27. }

    生成增强for语句的快捷方式：

    遍历的集合名称.for并回车即可生成

    for(元素的数据类型 变量名：数组或者单列集合){

    }

    3、lamdba表达式遍历

    语法：

    Collection<遍历元素的数据类型> 集合对象名称=new ArrayList<>();

    集合对象名称.forEach(s->System.out.println(s));

    step1：生成集合对象     e.g: Collection coll=new ArrayList<>();

    step2：通过集合对象使用forEach方法 ，方法中写变量加上->输出元素的语句

      e.g:coll.forEach(s-> System.out.println(s))；

    1. import java.util.ArrayList;
    2. import java.util.Collection;
    3. import java.util.function.Consumer;
    4.  
    5. public class lamdba遍历 {
    6.     public static void main(String[] args) {
    7.         Collection coll=new ArrayList<>();
    8.         coll.add("文韬");
    9.         coll.add("黄子弘凡");
    10.         coll.add("曹恩齐");
    11.         // forEach是Iterable接口的默认方法 用于遍历集合中的每个元素 并对每个元素执行一个给定的操作
    12.         // Collection接口拓展了Iterable接口，因此所有实现Collection接口的类也实现了Iterable接口
    13.         // 因此实现Collection接口的对象coll也可以使用Iterable接口的方法forEach
    14.         // forEach需要传入Consumer接口 当方法的参数是接口时 在调用方法时需要传递接口的实现类
    15.         // 生成Consumer实现类的对象
    16.         // 由于Consumer接口只有一个抽象方法 其实现类是函数式接口的匿名内部类 可以使用lamdba表达式简化
    17.         // 简化lamdba表达式
    18.         // 1.简化前
    19.         coll.forEach(new Consumer(){
    20.             @Override
    21.             public void accept(String s){
    22.                 System.out.println(s);
    23.             }
    24.         });
    25.         /*文韬
    26.           黄子弘凡
    27.           曹恩齐*/
    28.  
    29.         // 2.简化后
    30.         coll.forEach( s-> System.out.println(s));
    31.         /* 文韬
    32.            黄子弘凡
    33.            曹恩齐*/
    34.     }
    35. }

    六、补充知识：lambda表达式简化接口的匿名形式

    函数式编程：忽略面向对象的复杂语法，强调做什么而不是谁去做，做什么强调的是重写方法的形参类型、方法体、return返回值

    语法：

    ()->{

    }

    其中（）对应着重写方法的形参   ->是固定格式   {}对应着方法的方法体

    简化规则：

    1、参数类型可以省略不写

    简化前：

    简化后：

    2、当只有一个参数时，参数类型可以省略不写，同时（）也可以省略不写

    3、如果lamdba表达式的方法体只有一行，那么大括号、分号、return可以省略不写，要省略需同时省略，不能只省略大括号、分号、return中的一部分

    简化前：

    简化后：

    注意：

    1、lambda表达式可以用来简化匿名内部类的书写

    2、lambda表达式只能简化函数式接口的匿名内部类，其中函数式接口指的是有且仅有一个抽象方法的接口（只能是接口不能是抽象类），接口上方可以加@FuctionInterface注解来检验

    e.g1:

    e.g2:

    简化前：

    简化后：

    七、单列集合之Collection的知识总结

  • 相关阅读:
    如何恢复电脑里的被删除的视频文件?最近教程
    电子管晶体管示波器电路图
    layui实现动态图片/视频轮播：
    新手开抖店之前，这三个核心点，一定要提前了解！
    system函数实践1：system函数进程的爸爸是谁？
    object常用的方法
    EasyExcel格式化映射注解和样式注解详解
    【 2023华为杯C题】大规模创新类竞赛评审方案研究（思路、代码......）
    【蓝桥杯单片机入门记录】动态数码管
    【C++】STL容器——vector类的使用指南(含代码演示)（11）
  • 原文地址：https://blog.csdn.net/weixin_74886498/article/details/138002644