devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

List操作的一些常见问题

作者：繁依Fanyi0 | 2024-04-08 11:10:03

赞

踩

List操作的一些常见问题

1. Arrays.asList转换基本类型数组

在实际的业务开发中，我们通常会进行数组转List的操作，通常我们会使用Arrays.asList来进行转换，但是在转换基本类型的数组的时候，却出现转换的结果和我们想象的不一致。

  1. import java.util.Arrays;
  2. import java.util.List;
  3.  
  4. /**
  5.  * Arrays.asList数组常见问题
  6.  * @author 百里
  7.  */
  8. public class BaiLiTestDemo {
  9.     public static void main(String[] args) {
  10.         int[] arr = {1, 2, 3};
  11.         List list = Arrays.asList(arr);
  12.         System.out.println("list.size：" + list.size());
  13.         for (int i = 0; i < list.size(); i++) {
  14.             System.out.println("循环打印：" + list.get(i));
  15.         }
  16.     }
  17. }

观察下asList的实现，可以看到是入参是使用的是泛型，所以会将{1, 2, 3}三个整数放入一个泛型列表中返回。

  1. public static List asList(T... a) {
  2.     return new ArrayList<>(a); 
  3. }


那我们该如何解决呢？只需要在声明数组的时候，声明类型改为包装类型。

  1. import java.util.Arrays;
  2. import java.util.List;
  3.  
  4. /**
  5.  * Arrays.asList数组常见问题
  6.  * @author 百里
  7.  */
  8. public class BaiLiTestDemo {
  9.     public static void main(String[] args) {
  10.         Integer[] arr = {1, 2, 3};
  11.         List list = Arrays.asList(arr);
  12.         System.out.println("list.size：" + list.size());//size = 3
  13.         for (int i = 0; i < list.size(); i++) {
  14.             System.out.println("循环打印：" + list.get(i));
  15.         }
  16.     }
  17. }

这就是第一个坑了，然而Arrays.asList不止这一个需要注意的问题，我们继续往下看：

2. Arrays.asList返回的List不支持增删操作

我们接着上面的demo，增加list加减的逻辑，运行demo会提示UnsupportedOperationException：

  1. import java.util.Arrays;
  2. import java.util.List;
  3.  
  4. /**
  5.  * Arrays.asList数组常见问题
  6.  * @author 百里
  7.  */
  8. public class BaiLiTestDemo {
  9.     public static void main(String[] args) {
  10.         Integer[] arr = {1, 2, 3};
  11.         List list = Arrays.asList(arr);
  12.         System.out.println("list.size：" + list.size());
  13.         list.add(4);
  14.     }
  15. }

为什么会这样？我们看下asList的实现，它返回的ArrayList是Arrays的内部类，而不是我们通常使用的java.util.ArrayList：


可以看到内部类中的ArrayList没有add()与remove()，那我们怎么可以使用增减方法呢，继续往下看：


可以看到ArrayList继承了AbstractList类，我们观察AbstractList类的add()与remove()：


现在是不是就理解Arrays.asList返回的List不支持增删操作了。

3. 对原始数组的修改会影响到我们获得的那个List

基于第一个demo我们继续改造，修改原arr[0]=10，这个时候打印Arrays.asList返回的list值也发生了改变：

  1. import java.util.Arrays;
  2. import java.util.List;
  3.  
  4. /**
  5.  * Arrays.asList数组常见问题
  6.  * @author 百里
  7.  */
  8. public class BaiLiTestDemo {
  9.     public static void main(String[] args) {
  10.         Integer[] arr = {1, 2, 3};
  11.         List list = Arrays.asList(arr);
  12.         System.out.println("list.size：" + list.size());
  13.         arr[0] = 10;//修改原数组
  14.         for (int i = 0; i < list.size(); i++) {
  15.             System.out.println("循环打印：" + list.get(i));
  16.         }
  17.     }
  18. }

为什么呢？观察ArrayList的实现，可以知道asList创建了 ArrayList，但它直接引用原本的数据组对象。所以只要原本的数组对象一发生变化，List也跟着变化。
 


解决方案：new一个新的ArrayList装Arrays.asList返回数据。

  1. import java.util.ArrayList;
  2. import java.util.Arrays;
  3. import java.util.List;
  4.  
  5. /**
  6.  * Arrays.asList数组常见问题
  7.  * @author 百里
  8.  */
  9. public class BaiLiTestDemo {
  10.     public static void main(String[] args) {
  11.         Integer[] arr = {1, 2, 3};
  12.         List list = new ArrayList<>(Arrays.asList(arr));
  13.         arr[0] = 10;
  14.         for (int i = 0; i < list.size(); i++) {
  15.             System.out.println("循环打印：" + list.get(i));
  16.         }
  17.     }
  18. }

4. ArrayList.subList强转ArrayList导致异常

当使用ArrayList.subList的返回list强转ArrayList时，会出现java.lang.ClassCastException，看以下代码：

  1. import java.util.ArrayList;
  2. import java.util.List;
  3.  
  4. /**
  5.  * ArrayList.subList常见问题
  6.  * @author 百里
  7.  */
  8. public class BaiLiArrayListDemo {
  9.     public static void main(String[] args) {
  10.         List<String> names = new ArrayList<String>() {{
  11.             add("one");
  12.             add("two");
  13.             add("three");
  14.         }};
  15.         ArrayList strings = (ArrayList) names.subList(0, 1);
  16.         System.out.println(strings);
  17.     }
  18. }
  1. Exception in thread "main" java.lang.ClassCastException: java.util.ArrayList$SubList cannot be cast to java.util.ArrayList
  2. 	at BaiLiArrayListDemo.main(BaiLiArrayListDemo.java:15)

同样的，我们看下sublist的实现：
 


可以看到SubList()实际上没有创建一个新的List，而是直接引用了原来的List，指定了元素的范围。并且返回的是一个内部类实现的SubList对象，该对象只是原始ArrayList的一个引用，而不是一个全新的ArrayList，因此无法直接将其强制转换为ArrayList类型。
由于是引用的原List，因此也会存在asList的问题，也就是针对subList进行增减数据，会影响原List的值。

  1. import java.util.ArrayList;
  2. import java.util.List;
  3.  
  4. /**
  5.  * ArrayList.subList常见问题
  6.  * @author 百里
  7.  */
  8. public class BaiLiArrayListDemo {
  9.     public static void main(String[] args) {
  10.         List<String> names = new ArrayList<String>() {{
  11.             add("one");
  12.             add("two");
  13.             add("three");
  14.         }};
  15.         List  strings = names.subList(0, 1);
  16.         strings.add(0,"four");
  17.         System.out.println(strings);//[four, one]
  18.         System.out.println(names);//[four, one, two, three]
  19.     }
  20. }

需要注意修改原List-names的值会出导致strings的遍历、增加、删除产生ConcurrentModificationException异常。

  1. import java.util.ArrayList;
  2. import java.util.List;
  3.  
  4. /**
  5.  * ArrayList.subList常见问题
  6.  * @author 百里
  7.  */
  8. public class BaiLiArrayListDemo {
  9.     public static void main(String[] args) {
  10.         List<String> names = new ArrayList<String>() {{
  11.             add("one");
  12.             add("two");
  13.             add("three");
  14.         }};
  15.         List strings = names.subList(0, 1);
  16.         names.add("four");
  17.         System.out.println(strings);
  18.         System.out.println(names);
  19.     }
  20. }
  1. Exception in thread "main" java.util.ConcurrentModificationException
  2. 	at java.util.ArrayList$SubList.checkForComodification(ArrayList.java:1231)
  3. 	at java.util.ArrayList$SubList.listIterator(ArrayList.java:1091)
  4. 	at java.util.AbstractList.listIterator(AbstractList.java:299)
  5. 	at java.util.ArrayList$SubList.iterator(ArrayList.java:1087)
  6. 	at java.util.AbstractCollection.toString(AbstractCollection.java:454)
  7. 	at java.lang.String.valueOf(String.java:2994)
  8. 	at java.io.PrintStream.println(PrintStream.java:821)
  9. 	at BaiLiArrayListDemo.main(BaiLiArrayListDemo.java:17)

上面问题的解决方案跟asList同样，直接new一个新的ArrayList装Arrays.subList返回数据就可以了。

  1. import java.util.ArrayList;
  2. import java.util.List;
  3.  
  4. /**
  5.  * ArrayList.subList常见问题
  6.  * @author 百里
  7.  */
  8. public class BaiLiArrayListDemo {
  9.     public static void main(String[] args) {
  10.         List<String> names = new ArrayList<String>() {{
  11.             add("one");
  12.             add("two");
  13.             add("three");
  14.         }};
  15.         List strings = new ArrayList<>(names.subList(0, 1));
  16.         strings.add("four");
  17.         System.out.println(strings);//[one, four]
  18.         System.out.println(names);//[one, two, three]
  19.     }
  20. }

5. ArrayList中的subList切片造成OOM

subList所产生的List，其实是对原来List对象的引用，这个产生的List只是原来List对象的视图，也就是说虽然值切片获取了一小段数据，但是原来的List对象却得不到回收，如果这个原来的对象很大，就会出现OOM的情况。我们将VM参数调小：-Xms20m -Xmx40m

  1. import java.util.ArrayList;
  2. import java.util.List;
  3. import java.util.stream.Collectors;
  4. import java.util.stream.IntStream;
  5.  
  6. /**
  7.  * ArrayList.subList常见问题
  8.  * @author 百里
  9.  */
  10. public class BaiLiArrayListDemo {
  11.     public static void main(String[] args) {
  12.         List data = new ArrayList<>();
  13.         IntStream.range(0, 1000).forEach(i ->{
  14.             List<Integer> collect = 
  15.                     IntStream.range(0, 100000).boxed().
  16.                             collect(Collectors.toList());
  17.             data.add(collect.subList(0, 1));
  18.         });
  19.     }
  20. }

出现OOM的原因：原数组无法被回收，会一直在内存中。
解决方案：new一个新的ArrayList接收subList返回。

6.Copy-On-Write 是什么？

Copy-On-Write它是一种在计算机科学中常见的优化技术，主要应用于需要频繁读取但很少修改的数据结构上。
简单的说就是在计算机中就是当你想要对一块内存进行修改时，我们不在原有内存块中进行写操作，而是将内存拷贝一份，在新的内存中进行写操作，写完之后呢，就将指向原来内存指针指向新的内存，原来的内存就可以被回收掉了！
既然是一种优化策略，我们看一段代码：

  1. import java.util.ArrayList;
  2. import java.util.Arrays;
  3. import java.util.Iterator;
  4. import java.util.List;
  5.  
  6. /**
  7. * @author 百里
  8. */
  9. public class BaiLiIteratorTest {
  10.     private static List<String> list = new ArrayList<>();
  11.  
  12.     public static void main(String[] args) {
  13.         list.add("1");
  14.         list.add("2");
  15.         list.add("3");
  16.         Iterator<String> iter = list.iterator();
  17.         while (iter.hasNext()) {
  18.             System.err.println(iter.next());
  19.         }
  20.         System.err.println(Arrays.toString(list.toArray()));
  21.     }
  22. }

上面的Demo在单线程下执行时没什么毛病，但是在多线程的环境中，就可能出异常，为什么呢？
因为多线程迭代时如果有其他线程对这个集合list进行增减元素，会抛出java.util.ConcurrentModificationException的异常。
我们以增加元素为例子，运行下面这Demo：

  1. import java.util.ArrayList;
  2. import java.util.Iterator;
  3. import java.util.List;
  4. import java.util.concurrent.ExecutorService;
  5. import java.util.concurrent.Executors;
  6.  
  7. /**
  8.  * 并发迭代器问题示例代码
  9.  * @author 百里
  10.  */
  11. public class BaiLiConcurrentIteratorTest {
  12.     // 创建一个ArrayList对象
  13.     private static List<String> list = new ArrayList<>();
  14.  
  15.     public static void main(String[] args) throws InterruptedException {
  16.         // 给ArrayList添加三个元素："1"、"2"和"3"
  17.         list.add("1");
  18.         list.add("2");
  19.         list.add("3");
  20.  
  21.         // 开启线程池，提交10个线程用于在list尾部添加5个元素"121"
  22.         ExecutorService service = Executors.newFixedThreadPool(10);
  23.         for (int i = 0; i < 10; i++) {
  24.             service.execute(() -> {
  25.                 for (int j = 0; j < 5; j++) {
  26.                     list.add("121");
  27.                 }
  28.             });
  29.         }
  30.  
  31.         // 使用Iterator迭代器遍历list并输出元素值
  32.         Iterator<String> iter = list.iterator();
  33.         for (int i = 0; i < 10; i++) {
  34.             service.execute(() -> {
  35.                 while (iter.hasNext()) {
  36.                     System.err.println(iter.next());
  37.                     try {
  38.                         Thread.sleep(10);
  39.                     } catch (InterruptedException e) {
  40.                         e.printStackTrace();
  41.                     }
  42.                 }
  43.             });
  44.         }
  45.         service.shutdown();
  46.     }
  47. }

这里暴露的问题是什么呢？

  • 多线程场景下迭代器遍历集合的读取操作和其他线程对集合进行写入操作会导致出现并发修改异常

解决方案：

  • CopyOnWriteArrayList避免了多线程操作List线程不安全的问题

7.CopyOnWriteArrayList介绍

从JDK1.5开始Java并发包里提供了两个使用CopyOnWrite机制实现的并发容器，它们是CopyOnWriteArrayList和CopyOnWriteArraySet。CopyOnWrite容器非常有用，可以在非常多的并发场景中使用到。
CopyOnWriteArrayList原理：
在写操作(add、remove等)时，不直接对原数据进行修改，而是先将原数据复制一份，然后在新复制的数据上执行写操作，最后将原数据引用指向新数据。这样做的好处是读操作(get、iterator等)可以不加锁，因为读取的数据始终是不变的。
接下来我们就看下源码怎么实现的。

8.CopyOnWriteArrayList简单源码解读

add()方法源码：

  1. /**
  2. * Appends the specified element to the end of this list.
  3. *
  4. * @param e element to be appended to this list
  5. * @return {@code true} (as specified by {@link Collection#add})
  6. */
  7. public boolean add(E e) {
  8.     final ReentrantLock lock = this.lock;//重入锁
  9. 	lock.lock();//加锁啦
  10.     try {
  11.         Object[] elements = getArray();
  12.         int len = elements.length;
  13.         Object[] newElements = Arrays.copyOf(elements, len + 1);//拷贝新数组
  14.         newElements[len] = e;
  15.         setArray(newElements);//将引用指向新数组  1
  16.         return true;
  17.     } finally {
  18.         lock.unlock();//解锁啦
  19.     }
  20. }

可以看到，CopyOnWriteArrayList中的写操作都需要先获取锁，然后再将当前的元素数组复制一份，并在新复制的元素数组上执行写操作，最后将数组引用指向新数组。

  1. @SuppressWarnings("unchecked")
  2. public E next() {
  3.     if (! hasNext()) //是否存在下一个元素
  4.         throw new NoSuchElementException(); //没有下一个元素，则会抛出NoSuchElementException异常
  5.     //snapshot是一个类成员变量，它是在创建迭代器时通过复制集合内容而获得的一个数组。
  6.     //cursor是另一个类成员变量，初始值为0，并在每次调用next()时自增1，表示当前返回元素的位置。
  7.     return (E) snapshot[cursor++];
  8. }

而读操作不需要加锁，直接返回当前的元素数组即可。
这种写时复制的机制保证了读操作的线程安全性，但是会牺牲一些写操作的性能，因为每次修改都需要复制一份数组。因此，适合读远多于写的场合。
所以我们将多线程Demo中的ArrayList改为CopyOnWriteArrayList，执行就不会报错啦！

  1. import java.util.Iterator;
  2. import java.util.concurrent.CopyOnWriteArrayList;
  3. import java.util.concurrent.ExecutorService;
  4. import java.util.concurrent.Executors;
  5.  
  6. /**
  7. * 并发迭代器问题示例代码
  8. * @author 百里
  9. */
  10. public class BaiLiConcurrentIteratorTest {
  11.     // 创建一个ArrayList对象
  12.     private static CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
  13.  
  14.     public static void main(String[] args) throws InterruptedException {
  15.         // 给ArrayList添加三个元素："1"、"2"和"3"
  16.         list.add("1");
  17.         list.add("2");
  18.         list.add("3");
  19.  
  20.         // 开启线程池，提交10个线程用于在list尾部添加5个元素"121"
  21.         ExecutorService service = Executors.newFixedThreadPool(10);
  22.         for (int i = 0; i < 10; i++) {
  23.             service.execute(() -> {
  24.                 for (int j = 0; j < 5; j++) {
  25.                     list.add("121");
  26.                 }
  27.             });
  28.         }
  29.  
  30.         // 使用Iterator迭代器遍历list并输出元素值
  31.         Iterator<String> iter = list.iterator();
  32.         for (int i = 0; i < 10; i++) {
  33.             service.execute(() -> {
  34.                 while (iter.hasNext()) {
  35.                     System.err.println(iter.next());
  36.                     try {
  37.                         Thread.sleep(10);
  38.                     } catch (InterruptedException e) {
  39.                         e.printStackTrace();
  40.                     }
  41.                 }
  42.             });
  43.         }
  44.         service.shutdown();
  45.     }
  46. }

9.CopyOnWriteArrayList优缺点

优点：

  1. 线程安全。CopyOnWriteArrayList是线程安全的，由于写操作对原数据进行复制，因此写操作不会影响读操作，读操作可以不加锁，降低了并发冲突的概率。
  1. 不会抛出ConcurrentModificationException异常。由于读操作遍历的是不变的数组副本，因此不会抛出ConcurrentModificationException异常。

缺点：

  1. 写操作性能较低。由于每一次写操作都需要将元素复制一份，因此写操作的性能较低。
  1. 内存占用增加。由于每次写操作都需要创建一个新的数组副本，因此内存占用会增加，特别是当集合中有大量数据时，内存占用较高。
  1. 数据一致性问题。由于读操作遍历的是不变的数组副本，因此在对数组执行写操作期间，读操作可能读取到旧的数组数据，这就涉及到数据一致性问题。

10.CopyOnWriteArrayList使用场景

  • 读多写少。为什么？因为写的时候会复制新集合
  • 集合不大。为什么？因为写的时候会复制新集合
  • 实时性要求不高。为什么，因为有可能会读取到旧的集合数据
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/385047
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号