• Java的ArrayList应用(查增改删)

    记录：294

    场景：Java的ArrayList理解与应用。把对ArrayList操作，从查、增、改、删的角度去理解和应用ArrayList的API。

    版本：

    1. JDK 1.8
    2. Spring Boot 2.6.3

    名词：

    API，应用程序接口(Application Programming Interface)。API是一些预定的函数，提供给应用程序访问。调用方无需关注API内部源码和内部工作机制等细节，只需根据API提供方发布的调用方式调用API就行。

    一、基础

    1.基础知识

    1.1 ArrayList基础知识

    (1)ArrayList底层是一个可变数组，使用transient关键字修饰的Object[]数组。

    (2)ArrayList实现List、Collection等接口，实现了List的全部操作。

    (3)ArrayList支持动态扩容，在做add操作时，容量不足时，会自动扩容。扩容时会使用Arrays.copyOf函数进行拷贝操作。扩容规则：(oldCapacity >> 1)，即扩展原有容量一半。

    (4)ArrayList是线程不安全集合。在多线程操作时，需使用者自行加锁处理。

    (5)ArrayList允许写入null。

    1.2 ArrayList继承类和实现的接口

    ArrayList在jdk中全路径：java.util.ArrayList。

    ArrayList继承的抽象类：

    1. java.util.AbstractList
    2. java.util.AbstractCollection

    ArrayList实现的接口：

    1. java.util.List
    2. java.util.RandomAccess
    3. java.lang.Cloneable
    4. java.io.Serializable
    5. java.util.Collection
    6. java.lang.Iterable

    1.3 ArrayList内部类

    ArrayList内部类，包括如下：

    1. java.util.ArrayList.Itr
    2. java.util.ArrayList.ListItr
    3. java.util.ArrayList.SubList
    4. java.util.ArrayList.ArrayListSpliterator

    2.应用场景

    ArrayList，只要使用集合的场景都可以使用。

    二、应用

    1.创建

    创建，就是创建ArrayList操作，就能得到一个实际Java对象。

    1.1操作场景

    操作场景，函数功能说明。

    (1)使用new创建长度为0的List对象。

    (2)使用new创建长度为100的List对象。

    (3)使用实现Collection接口的类创建对象。

    1.2操作实例

    操作实例，函数应用实例。

    1. /**
    2.  * 1.使用new关键字创建ArrayList对象实例
    3.  */
    4. public static void f_new() {
    5.  
    6.   // 1.使用new创建长度为0的List对象
    7.   List list01 = new ArrayList<>();
    8.   // 2.使用new创建长度为100的List对象
    9.   List list02 = new ArrayList<>(100);
    10.   // 3.使用实现Collection接口的类创建对象
    11.   HashSet hs = new HashSet<>();
    12.   hs.add("杭州");
    13.   hs.add("苏州");
    14.   hs.add("厦门");
    15.   List list03 = new ArrayList<>(hs);
    16.   list03.forEach(str -> {
    17.       System.out.println("城市名称: " + str);
    18.   });
    19. }

    2.查

    查，就是查询操作。

    2.1操作场景

    操作场景，函数功能说明。

    (1)使用forEach遍历ArrayList集合。

    (2)使用for循环,搭配get(intindex),遍历ArrayList集合。

    (3)使用增强for循环,遍历ArrayList集合。

    (4)使用ListIteratorlistIterator(),遍历ArrayList集合。

    (5)使用ListIteratorlistIterator(intindex),按照指定位置开始,遍历ArrayList集合。

    (6)使用iterator(),遍历ArrayList集合。

    (7)使用spliterator(),遍历ArrayList集合。

    (8)使用stream(),把ArrayList转换为Stream,遍历ArrayList集合。

    (9)使用sort(Comparatorc)排序,遍历ArrayList集合。

    (10)使用get(intindex),获取ArrayList指定位置的元素。

    (11)使用size(),获取ArrayList的size。

    (12)使用isEmpty(),判断ArrayList是否为空。

    (13)使用contains(),判断ArrayList是否包含指定对象。

    (14)使用indexOf(),获取ArrayList索引位置。

    (15)使用lastIndexOf()获取ArrayList最后一个索引位置。

    (16)使用clone(),复制ArrayList的元素。

    2.2操作实例

    操作实例，函数应用实例。

    1. /**
    2.  * 1.1 使用forEach遍历ArrayList集合
    3.  */
    4. public static void f1_1() {
    5.   // 1.获取数据
    6.   List list = getList();
    7.   // 2.遍历数据
    8.   list.forEach(girl -> {
    9.       System.out.println("girl信息: " + girl.toString());
    10.   });
    11. }
    12.  
    13. /**
    14.  * 1.2 使用for循环,搭配get(int index),遍历ArrayList集合
    15.  */
    16. public static void f1_2() {
    17.   // 1.获取数据
    18.   List list = getList();
    19.   // 2.遍历数据
    20.   for (int i = 0; i < list.size(); i++) {
    21.       System.out.println("girl信息: " + list.get(i));
    22.   }
    23. }
    24.  
    25. /**
    26.  * 1.3 使用增强for循环,遍历ArrayList集合
    27.  */
    28. public static void f1_3() {
    29.   // 1.获取数据
    30.   List list = getList();
    31.   // 2.遍历数据
    32.   for (GirlVo girlVo : list) {
    33.       System.out.println("girl信息: " + girlVo);
    34.   }
    35. }
    36.  
    37. /**
    38.  * 1.4 使用ListIterator listIterator(),遍历ArrayList集合
    39.  */
    40. public static void f1_4() {
    41.   // 1.获取数据
    42.   List list = getList();
    43.   // 2.使用listIterator
    44.   ListIterator iterator = list.listIterator();
    45.   // 3.使用Iterator遍历
    46.   while (iterator.hasNext()) {
    47.       System.out.println("遍历Iterator: " + iterator.next());
    48.   }
    49. }
    50.  
    51. /**
    52.  * 1.5 使用ListIterator listIterator(int index),按照指定位置开始,
    53.  * 遍历ArrayList集合
    54.  */
    55. public static void f1_5() {
    56.   // 1.获取数据
    57.   List list = getList();
    58.   // 2.使用listIterator
    59.   ListIterator iterator = list.listIterator(2);
    60.   // 3.使用Iterator遍历
    61.   while (iterator.hasNext()) {
    62.       System.out.println("遍历Iterator: " + iterator.next());
    63.   }
    64. }
    65.  
    66. /**
    67.  * 1.6 使用iterator(),遍历ArrayList集合
    68.  */
    69. public static void f1_6() {
    70.   // 1.获取数据
    71.   List list = getList();
    72.   // 2.使用iterator
    73.   Iterator iterator = list.iterator();
    74.   // 3.使用iterator遍历
    75.   while (iterator.hasNext()) {
    76.       System.out.println("遍历Iterator: " + iterator.next());
    77.   }
    78. }
    79.  
    80. /**
    81.  * 1.7 使用spliterator(),遍历ArrayList集合
    82.  * JDK 1.8
    83.  */
    84. public static void f1_7() {
    85.   // 1.获取数据
    86.   List list = getList();
    87.   // 2.使用Spliterator
    88.   Spliterator iterator = list.spliterator();
    89.   // 3.使用Spliterator遍历
    90.   iterator.forEachRemaining(girlVo -> {
    91.       System.out.println("使用分流器遍历: " + girlVo);
    92.   });
    93. }
    94.  
    95. /**
    96.  * 1.8 使用stream(),把ArrayList转换为Stream,遍历ArrayList集合
    97.  */
    98. public static void f1_8() {
    99.   // 1.获取数据
    100.   List list = getList();
    101.   // 2.ArrayList转换为
    102.   Stream  stream = list.stream();
    103.   // 3.遍历数据
    104.   stream.forEach(girlVo -> {
    105.       System.out.println("girl信息: " + girlVo);
    106.   });
    107. }
    108.  
    109. /**
    110.  * 1.9 使用sort(Comparator c)排序,遍历ArrayList集合
    111.  * 需自定义Comparator比较器,本例按照GirlVo的年龄排序.
    112.  */
    113. public static void f1_9() {
    114.   // 1.获取数据
    115.   List list = getList();
    116.   System.out.println("操作前遍历信息:");
    117.   list.forEach(girlVo -> {
    118.       System.out.println("girl信息: " + girlVo);
    119.   });
    120.   // 2.比较器确定排序规则
    121.   list.sort((c1, c2) -> {
    122.       return (int) (c1.getAge() - c2.getAge());
    123.   });
    124.   System.out.println("操作后遍历信息:");
    125.   list.forEach(girlVo -> {
    126.       System.out.println("girl信息: " + girlVo);
    127.   });
    128. }
    129.  
    130. /**
    131.  * 1.10 使用get(int index),获取ArrayList指定位置的元素
    132.  */
    133. public static void f1_10() {
    134.   // 1.获取数据
    135.   List list = getList();
    136.   // 2.使用get获取元素
    137.   GirlVo girlVo = list.get(2);
    138.   System.out.println("girl信息: " + girlVo);
    139. }
    140.  
    141. /**
    142.  * 1.11 使用size(),获取ArrayList的size
    143.  */
    144. public static void f1_11() {
    145.   // 1.获取数据
    146.   List list = getList();
    147.   // 2.使用size
    148.   int size = list.size();
    149.   System.out.println("List的size: " + size);
    150. }
    151.  
    152. /**
    153.  * 1.12 使用isEmpty(),判断ArrayList是否为空
    154.  */
    155. public static void f1_12() {
    156.   // 1.获取数据
    157.   List list = getList();
    158.   // 2.使用isEmpty
    159.   boolean bl = list.isEmpty();
    160.   System.out.println("List是否为空: " + bl);
    161. }
    162.  
    163. /**
    164.  * 1.13使用contains(),判断ArrayList是否包含指定对象
    165.  */
    166. public static void f1_13() {
    167.   // 1.获取数据
    168.   List list = getList();
    169.   // 2.使用contains
    170.   GirlVo girl01 = GirlVo.builder().girlId("1001").girlName("张一").age(27).height(169).cupSize("F").build();
    171.   boolean bl = list.contains(girl01);
    172.   System.out.println("List是包含指定对象: " + bl);
    173. }
    174.  
    175. /**
    176.  * 1.14 使用indexOf(),获取ArrayList索引位置
    177.  */
    178. public static void f1_14() {
    179.   // 1.获取数据
    180.   List list = getList();
    181.   // 2.使用indexOf
    182.   GirlVo girl01 = GirlVo.builder().girlId("1001").girlName("张一").age(27).height(169).cupSize("F").build();
    183.   int index = list.indexOf(girl01);
    184.   System.out.println("girl01的索引位置: " + index);
    185. }
    186.  
    187. /**
    188.  * 1.15 使用lastIndexOf()获取ArrayList最后一个索引位置
    189.  */
    190. public static void f1_15() {
    191.   // 1.获取数据
    192.   List list = getList();
    193.   // 2.使用lastIndexOf
    194.   GirlVo girl01 = GirlVo.builder().girlId("1001").girlName("张一").age(27).height(169).cupSize("F").build();
    195.   list.add(girl01);
    196.   int index = list.lastIndexOf(girl01);
    197.   System.out.println("girl01的最后索引位置: " + index);
    198. }
    199.  
    200. /**
    201.  * 1.16 使用clone(),复制ArrayList的元素
    202.  */
    203. public static void f1_16() {
    204.   // 1.获取数据
    205.   ArrayList arrayList = new ArrayList<>();
    206.   arrayList.add("杭州");
    207.   arrayList.add("苏州");
    208.   arrayList.add("厦门");
    209.   // 2.使用clone
    210.   Object obj = arrayList.clone();
    211.   System.out.println("ArrayList的clone: " + obj);
    212. }

    3.增

    增，就是增加操作。

    3.1操作场景

    操作场景，函数功能说明。

    (1)使用add,在ArrayList尾部添加元素。

    (2)使用add(intindex,Eelement),在指定位置添加元素。

    (3)使用addAll(Collectionc),把Collection添加到ArrayList。

    (4)使用addAll(intindex,Collectionc),从指定index位置开始添加Collection集合,插入前在index位置及其后面的元素,会存放在插入的Collection后面。

    3.2操作实例

    操作实例，函数应用实例。

    1. /**
    2.  * 2.1 使用add,在ArrayList尾部添加元素
    3.  */
    4. public static void f2_1() {
    5.   // 1.创建对象和创建元素
    6.   List list = new ArrayList<>();
    7.   GirlVo girl01 = GirlVo.builder().girlId("1001").girlName("张一").age(27).height(169).cupSize("F").build();
    8.   GirlVo girl02 = GirlVo.builder().girlId("1002").girlName("王二").age(29).height(175).cupSize("B").build();
    9.   GirlVo girl03 = GirlVo.builder().girlId("1003").girlName("刘五").age(24).height(160).cupSize("B").build();
    10.   GirlVo girl04 = GirlVo.builder().girlId("1004").girlName("陈六").age(21).height(168).cupSize("C").build();
    11.   GirlVo girl05 = GirlVo.builder().girlId("1005").girlName("赵七").age(25).height(169).cupSize("C").build();
    12.   GirlVo girl06 = GirlVo.builder().girlId("1006").girlName("张八").age(26).height(165).cupSize("A").build();
    13.   // 2.把元素添加到ArrayList中
    14.   list.add(girl01);
    15.   list.add(girl02);
    16.   list.add(girl03);
    17.   list.add(girl04);
    18.   list.add(girl05);
    19.   list.add(girl06);
    20.   // 3.遍历ArrayList
    21.   for (GirlVo girlVo : list) {
    22.       System.out.println("girlVo信息: " + girlVo);
    23.   }
    24. }
    25.  
    26. /**
    27.  * 2.2 使用add(int index, E element),在指定位置添加元素.
    28.  * 如果index位置在list中有元素,则新元素占用这个位置.
    29.  * 把原来的元素放到index+1位置
    30.  */
    31. public static void f2_2() {
    32.   // 1.创建对象
    33.   List list = new ArrayList<>();
    34.   // 2.添加数据
    35.   list.add("北京");
    36.   list.add("杭州");
    37.   list.add("厦门");
    38.   System.out.println("调用前遍历: ");
    39.   list.forEach(girl -> {
    40.       System.out.println("girlVo信息: " + girl);
    41.   });
    42.   // 3.指定索引添加数据
    43.   list.add(2, "福州");
    44.   System.out.println("调用后遍历: ");
    45.   list.forEach(girl -> {
    46.       System.out.println("girlVo信息: " + girl);
    47.   });
    48. }
    49.  
    50. /**
    51.  * 2.3 使用addAll(Collection c),把Collection添加到ArrayList
    52.  */
    53. public static void f2_3() {
    54.   // 1.创建对象
    55.   List list = new ArrayList<>();
    56.   List list01 = new ArrayList<>();
    57.   List list02 = new ArrayList<>();
    58.   // 2.添加数据
    59.   list01.add("北京");
    60.   list01.add("杭州");
    61.   list01.add("厦门");
    62.   list02.add("苏州");
    63.   list02.add("南京");
    64.   list02.add("天津");
    65.   // 3.使用addAll
    66.   list.addAll(list01);
    67.   list.addAll(list02);
    68.   list.forEach(girl -> {
    69.       System.out.println("girlVo信息: " + girl);
    70.   });
    71. }
    72.  
    73. /**
    74.  * 2.4 使用addAll(int index, Collection c),
    75.  * 从指定index位置开始添加Collection集合,
    76.  * 插入前在index位置及其后面的元素,会存放在插入的Collection后面
    77.  */
    78. public static void f2_4() {
    79.   // 1.创建对象
    80.   List list01 = new ArrayList<>();
    81.   List list02 = new ArrayList<>();
    82.   // 2.添加数据
    83.   list01.add("北京");
    84.   list01.add("杭州");
    85.   list01.add("厦门");
    86.   list02.add("苏州");
    87.   list02.add("南京");
    88.   list02.add("天津");
    89.   // 3.使用addAll
    90.   list01.addAll(1, list02);
    91.   list01.forEach(girl -> {
    92.       System.out.println("girlVo信息: " + girl);
    93.   });
    94. }

    4.改

    改，就是修改操作。

    4.1操作场景

    操作场景，函数功能说明。

    (1)使用set(intindex,Eelement),修改指定索引的元素如果index位置在list中有元素,则把新元素占用这个位置.原来的元素就没有了。

    (2)使用subList(intfromIndex,inttoIndex),截取指定索引范围内的ArrayList。

    (3)使用replaceAll(UnaryOperatoroperator),修改ArrayList内部元素。

    (4)使用Object[]toArray(),转换ArrayList为数组。

    (5)使用T[]toArray(T[]a),转换ArrayList为数组。

    (6)使用for循环,修改ArrayList内部元素。

    4.2操作实例

    操作实例，函数应用实例。

    1. /**
    2.  * 3.1 使用set(int index, E element),修改指定索引的元素
    3.  * 如果index位置在list中有元素,则把新元素占用这个位置.原来的元素就没有了.
    4.  */
    5. public static void f3_1() {
    6.   // 1.创建对象
    7.   List list = new ArrayList<>();
    8.   // 2.添加数据
    9.   list.add("北京");
    10.   list.add("杭州");
    11.   list.add("厦门");
    12.   System.out.println("调用前遍历: ");
    13.   list.forEach(girl -> {
    14.       System.out.println("girlVo信息: " + girl);
    15.   });
    16.   // 3.修改指定索引元素
    17.   list.set(2, "福州");
    18.   System.out.println("调用后遍历: ");
    19.   list.forEach(girl -> {
    20.       System.out.println("girlVo信息: " + girl);
    21.   });
    22. }
    23.  
    24. /**
    25.  * 3.2 使用subList(int fromIndex, int toIndex),截取指定索引范围内的ArrayList
    26.  */
    27. public static void f3_2() {
    28.   // 1.创建对象
    29.   List list = new ArrayList<>();
    30.   // 2.添加数据
    31.   list.add("北京");
    32.   list.add("杭州");
    33.   list.add("厦门");
    34.   list.add("苏州");
    35.   list.add("南京");
    36.   System.out.println("调用前遍历: ");
    37.   list.forEach(girl -> {
    38.       System.out.println("girlVo信息: " + girl);
    39.   });
    40.   // 3.截取指定索引范围内元素
    41.   List list01 = list.subList(1, 3);
    42.   System.out.println("调用后遍历: ");
    43.   list01.forEach(girl -> {
    44.       System.out.println("girlVo信息: " + girl);
    45.   });
    46. }
    47.  
    48. /**
    49.  * 3.3 使用replaceAll(UnaryOperator operator),修改ArrayList内部元素
    50.  * JDK 1.8
    51.  */
    52. public static void f3_3() {
    53.   // 1.获取数据
    54.   List list = getList();
    55.   System.out.println("操作前遍历信息:");
    56.   list.forEach(girlVo -> {
    57.       System.out.println("girl信息: " + girlVo);
    58.   });
    59.   // 2.修改元素
    60.   list.replaceAll(girlVo -> {
    61.       if (Objects.equals(girlVo.getCupSize(), "B")) {
    62.           girlVo.setCupSize("B+");
    63.       }
    64.       return girlVo;
    65.   });
    66.   System.out.println("操作后遍历信息:");
    67.   list.forEach(girlVo -> {
    68.       System.out.println("girl信息: " + girlVo);
    69.   });
    70. }
    71.  
    72. /**
    73.  * 3.4 使用Object[] toArray(),转换ArrayList为数组
    74.  */
    75. public static void f3_4() {
    76.   // 1.获取数据
    77.   List list = getList();
    78.   // 2.使用toArray
    79.   Object[] obj = list.toArray();
    80.   // 3.遍历数据数组
    81.   for (int i = 0; i < obj.length; i++) {
    82.       System.out.println("girl信息: " + obj[i]);
    83.   }
    84. }
    85.  
    86. /**
    87.  * 3.5 使用 T[] toArray(T[] a),转换ArrayList为数组
    88.  */
    89. public static void f3_5() {
    90.   // 1.获取数据
    91.   List list = getList();
    92.   // 2.使用toArray
    93.   Object[] obj = list.toArray();
    94.   // 3.使用toArray(T[] a)
    95.   Object[] obj02 = list.toArray(obj);
    96.   System.out.println("obj02数组长度: " + obj02.length);
    97. }
    98.  
    99. /**
    100.  * 3.6 使用for循环,修改ArrayList内部元素
    101.  */
    102. public static void f3_6() {
    103.   // 1.获取数据
    104.   List list = getList();
    105.   System.out.println("操作前遍历信息:");
    106.   list.forEach(girlVo -> {
    107.       System.out.println("girl信息: " + girlVo);
    108.   });
    109.   // 2.修改元素
    110.   for (GirlVo girlVo : list) {
    111.       if (Objects.equals(girlVo.getCupSize(), "C")) {
    112.           girlVo.setCupSize("C+");
    113.       }
    114.   }
    115.   System.out.println("操作后遍历信息:");
    116.   list.forEach(girlVo -> {
    117.       System.out.println("girl信息: " + girlVo);
    118.   });
    119. }

    5.删

    删，就是删除操作。

    5.1操作场景

    操作场景，函数功能说明。

    (1)使用remove(intindex),删除指定位置元素。

    (2)使用remove(Objecto),删除指定元素。

    (3)使用Collectionc,删除ArrayList内指定集合内元素。

    (4)使用retainAll(Collectionc),保留ArrayList内指定集合的数据,其它删除。

    (5)使用removeIf(Predicatefilter),删除符合条件的元素。

    (6)使用clear清空ArrayList。

    5.2操作实例

    操作实例，函数应用实例。

    1. /**
    2.  * 4.1 使用remove(int index),删除指定位置元素
    3.  */
    4. public static void f4_1() {
    5.   // 1.创建对象
    6.   List list = new ArrayList<>();
    7.   // 2.添加数据
    8.   list.add("北京");
    9.   list.add("杭州");
    10.   list.add("厦门");
    11.   System.out.println("调用前遍历: ");
    12.   list.forEach(city -> {
    13.       System.out.println("城市信息: " + city);
    14.   });
    15.   // 3.删除指定索引
    16.   list.remove(1);
    17.   System.out.println("调用后遍历: ");
    18.   list.forEach(city -> {
    19.       System.out.println("城市信息: " + city);
    20.   });
    21. }
    22.  
    23. /**
    24.  * 4.2 使用remove(Object o),删除指定元素
    25.  */
    26. public static void f4_2() {
    27.   // 1.创建对象
    28.   List list = new ArrayList<>();
    29.   // 2.添加数据
    30.   list.add("北京");
    31.   list.add("杭州");
    32.   list.add("厦门");
    33.   System.out.println("调用前遍历: ");
    34.   list.forEach(girl -> {
    35.       System.out.println("城市信息: " + girl);
    36.   });
    37.   // 3.删除指定元素
    38.   list.remove("杭州");
    39.   System.out.println("调用后遍历: ");
    40.   list.forEach(girl -> {
    41.       System.out.println("城市信息: " + girl);
    42.   });
    43. }
    44.  
    45. /**
    46.  * 4.3 使用Collection c,删除ArrayList内指定集合内元素
    47.  */
    48. public static void f4_3() {
    49.   // 1.创建对象
    50.   List list = new ArrayList<>();
    51.   List list01 = new ArrayList<>();
    52.   // 2.添加数据
    53.   list.add("北京");
    54.   list.add("杭州");
    55.   list.add("苏州");
    56.   list.add("南京");
    57.   list.add("天津");
    58.   list.add("厦门");
    59.   list01.add("苏州");
    60.   list01.add("南京");
    61.   list01.add("天津");
    62.   System.out.println("调用前遍历: ");
    63.   list.forEach(girl -> {
    64.       System.out.println("城市信息: " + girl);
    65.   });
    66.   // 3.删除指定集合内元素
    67.   list.removeAll(list01);
    68.   System.out.println("调用后遍历: ");
    69.   list.forEach(girl -> {
    70.       System.out.println("城市信息: " + girl);
    71.   });
    72. }
    73.  
    74. /**
    75.  * 4.4 使用retainAll(Collection c),保留ArrayList内指定集合的数据,其它删除
    76.  */
    77. public static void f4_4() {
    78.   // 1.创建对象
    79.   List list = new ArrayList<>();
    80.   List list01 = new ArrayList<>();
    81.   // 2.添加数据
    82.   list.add("北京");
    83.   list.add("杭州");
    84.   list.add("苏州");
    85.   list.add("南京");
    86.   list.add("天津");
    87.   list.add("厦门");
    88.   list01.add("苏州");
    89.   list01.add("南京");
    90.   list01.add("天津");
    91.   System.out.println("调用前遍历: ");
    92.   list.forEach(girl -> {
    93.       System.out.println("城市信息: " + girl);
    94.   });
    95.   // 3.删除指定集合之外数据
    96.   list.retainAll(list01);
    97.   System.out.println("调用后遍历: ");
    98.   list.forEach(girl -> {
    99.       System.out.println("城市信息: " + girl);
    100.   });
    101. }
    102.  
    103. /**
    104.  * 4.5 使用removeIf(Predicate filter),删除符合条件的元素
    105.  * JDK 1.8
    106.  */
    107. public static void f4_5() {
    108.   // 1.获取数据
    109.   List list = getList();
    110.   System.out.println("操作前遍历信息:");
    111.   list.forEach(girlVo -> {
    112.       System.out.println("girl信息: " + girlVo);
    113.   });
    114.   // 2.删除符合条件元素
    115.   list.removeIf(girlVo -> {
    116.       return Objects.equals(girlVo.getCupSize(), "B");
    117.   });
    118.   System.out.println("操作后遍历信息:");
    119.   list.forEach(girlVo -> {
    120.       System.out.println("girl信息: " + girlVo);
    121.   });
    122. }
    123.  
    124. /**
    125.  * 4.6 使用clear清空ArrayList
    126.  */
    127. public static void f4_6() {
    128.   // 1.创建对象
    129.   List list = new ArrayList<>();
    130.   // 2.添加数据
    131.   list.add("北京");
    132.   list.add("杭州");
    133.   list.add("厦门");
    134.   System.out.println("调用前遍历: ");
    135.   list.forEach(city -> {
    136.       System.out.println("城市信息: " + city);
    137.   });
    138.   // 3.清空ArrayList
    139.   list.clear();
    140.   System.out.println("调用后遍历: ");
    141.   list.forEach(city -> {
    142.       System.out.println("城市信息: " + city);
    143.   });
    144. }

    6.共用代码

    (1)获取List集合。

    1. /**
    2.  * 获取List集合
    3.  * */
    4. public static List getList() {
    5.   List list = new ArrayList<>();
    6.   GirlVo girl01 = GirlVo.builder().girlId("1001").girlName("张一").age(27).height(169).cupSize("F").build();
    7.   GirlVo girl02 = GirlVo.builder().girlId("1002").girlName("王二").age(29).height(175).cupSize("B").build();
    8.   GirlVo girl03 = GirlVo.builder().girlId("1003").girlName("刘五").age(24).height(160).cupSize("B").build();
    9.   GirlVo girl04 = GirlVo.builder().girlId("1004").girlName("陈六").age(21).height(168).cupSize("C").build();
    10.   GirlVo girl05 = GirlVo.builder().girlId("1005").girlName("赵七").age(25).height(169).cupSize("C").build();
    11.   GirlVo girl06 = GirlVo.builder().girlId("1006").girlName("张八").age(26).height(165).cupSize("A").build();
    12.   list.add(girl01);
    13.   list.add(girl02);
    14.   list.add(girl03);
    15.   list.add(girl04);
    16.   list.add(girl05);
    17.   list.add(girl06);
    18.   return list;
    19. }

    (2)GirlVo对象。

    1. @Data
    2. @NoArgsConstructor
    3. @AllArgsConstructor
    4. @Builder
    5. public class GirlVo {
    6.   /**ID号*/
    7.   String girlId;
    8.   /**姓名*/
    9.   String girlName;
    10.   /**年龄*/
    11.   long age;
    12.   /**身高*/
    13.   double height;
    14.   /**罩杯*/
    15.   String cupSize;
    16. }

    以上，感谢。

    2022年8月31日

  • 相关阅读:
    java基础——集合
    【创建型】生成器模式(Builder)
    linux之curl命令
    统信UOS Linux操作系统下怎么删除某个程序在开始菜单或桌面的快捷方式
    使用模板引擎时，Uncaught TemplateError报错原因小结
    并查集（UnionFind）总结
    【FRP】群晖docker中部署Frp
    【Unity编辑器扩展】| 自定义窗口和面板
    关键字查询方法
    LC-6245. 找出中枢整数（前缀和、二分法、数学）【周赛321】
  • 原文地址：https://blog.csdn.net/zhangbeizhen18/article/details/126632981