Java——List删除相关操作

谁践踏了优雅 2024-03-24 11:00 38阅读 0赞

**目录**

1.List循环删除元素

2.List删除重复元素

--------------------

### 1.List循环删除元素 ###

日常业务中，有时候需要我们遍历List列表，并对其中的元素进行判断并进行删除。

（1）List列表中，如果我们要循环删除元素，那么我们是不能直接遍历然后进行remove的：

public class test {
        public static List<String> list = Arrays.asList("check 01","test 01","test 02","check 02","test 03");
    
        public static void main(String[] args) {
            List<String> nameList = new ArrayList<>(list);
            for (int i=0;i<nameList.size();i++){
                String str = nameList.get(i);
                if (str.startsWith("test")){
                    nameList.remove(i);
                }
            }
            System.out.println(nameList);
        }
    }

![67075bf79f0249e68af3f70133c50be9.png][]

如上，当我们循环遍历删除时，List中remove了一个元素，list的坐标也会发送改变。即当我们匹配了test01这个字符串，并删除后，test02的坐标则向前移动了一步，变成了1而不是2.而随着坐标往后走，test02将永远不会被删除。

针对以上问题，如果我们想要使用普通for循环遍历删除元素，那么我们则需要**倒序删除**：

public class test {
        public static List<String> list = Arrays.asList("check 01","test 01","test 02","check 02","test 03");
    
        public static void main(String[] args) {
            List<String> nameList = new ArrayList<>(list);
            for (int i=nameList.size()-1;i>0;i--){
                String str = nameList.get(i);
                if (str.startsWith("test")){
                    nameList.remove(i);
                }
            }
            System.out.println(nameList);
        }
    }

如上，成功删除List中的所有带test开头的字符按。

（2）那么，如果普通的for循环正常遍历不行，那么使用增强for循环又是否可以呢：

public class test {
        public static List<String> list = Arrays.asList("check 01","test 01","test 02","check 02","test 03");
    
        public static void main(String[] args) {
            List<String> nameList = new ArrayList<>(list);
            for (String name:nameList){
                if (name.startsWith("test")){
                    nameList.remove(name);
                }
            }
            System.out.println(nameList);
        }
    }

上述代码会报并发修改错误：

![aee47d6c4ede43a7b33d39d6ecd9983b.png][]

这是因为list.remove方法中，对元素进行删除主要基于fastremove方法：

![cb2393d0fe514a1f97ba10ff7847f8ba.png][]

上述方法中对modCount值进行了修改（该值指对list操作的次数）

而arrayList源码中，初始化时会进行进行把modCount的值赋值到expectedModCount中，进行同步：

![0999948675a84dd19fa684a548375f25.png][]

在进行增强for循环遍历时，会调用next方法，其中会判断是否存在下一个元素，其中包含以下方法：

![844acaf3a9a4492595e14a411c6a2901.png][]

该方法会对 expectedModCount和modCount进行判断。而remove方法中仅对modCount进行了增加，而没对expectedModCount进行处理，expectedModCount仅仅是ArrayList初始化时的值（即0），所以两值在进行了一次删除后，会不相等，从而抛出异常。

**而由于list.forEach()底层也是基于增强for循环实现的，所以也会存在同样的问题。**

（3）增强for循环不行，但是我们可以通过迭代器的方式对其进行操作：

public class test {
        public static List<String> list = Arrays.asList("check 01","test 01","test 02","check 02","test 03");
    
        public static void main(String[] args) {
            List<String> nameList = new ArrayList<>(list);
            for (Iterator<String> iterator = nameList.iterator(); iterator.hasNext();){
                String name = iterator.next();
                if (name.startsWith("test")){
                    iterator.remove();
                }
            }
            System.out.println(nameList);
        }
    }

这是因为迭代器的remove方法中对expectedModCount和modCount进行了同步，所以next方法中不会抛出异常：

![8e46a18acd3146dca3d7f6182602ef3a.png][]

### 2.List删除重复元素 ###

（1）日常业务中，有时候需要我们遍历List列表，删除其中的重复元素，最常用的方法则是双循环判断去重：

public class test {
        public static List<String> list = Arrays.asList("check 01","check 01","test 01","check 01","test 02");
    
        public static void main(String[] args) {
            List<String> nameList = new ArrayList<>(list);
            for (int i=0; i<nameList.size()-1; i++){
                for (int j=nameList.size()-1; j>i; j--){
                    if (nameList.get(j).equals(list.get(i))){
                        nameList.remove(j);
                    }
                }
            }
            System.out.println(nameList);
        }
    }

（2）而更简单的方法则是利用Set集合的特性（不包含重复元素）对其进行去重：

public class test {
        public static List<String> list = Arrays.asList("check 01","check 01","test 01","check 01","test 01");
    
        public static void main(String[] args) {
            List<String> nameList = new ArrayList<>(list);
            List<String> resultList = new ArrayList<>(new LinkedHashSet<>(nameList));
            System.out.println(resultList);
        }
    }

之所以选用LinkedHashSet而没使用HashSet则是为了保持列表的顺序性。

（3）又或者，我们可以java8之后的新特性stream进行去重：

public class test {
        public static List<String> list = Arrays.asList("check 01","check 01","test 01","check 01","test 01");
    
        public static void main(String[] args) {
            List<String> nameList = new ArrayList<>(list);
            nameList = nameList.stream().distinct().collect(Collectors.toList());
            System.out.println(nameList);
        }
    }

[67075bf79f0249e68af3f70133c50be9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/5802279927e14a49a8c8bf925a5721be.png
[aee47d6c4ede43a7b33d39d6ecd9983b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/45a0e5b0964d40bd9c8fc978557ae939.png
[cb2393d0fe514a1f97ba10ff7847f8ba.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/18fe84b8d8ca494785c550c299507db0.png
[0999948675a84dd19fa684a548375f25.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/2c30cb724cb340b19b21b2ecdb9e5740.png
[844acaf3a9a4492595e14a411c6a2901.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/e044be7826fd4fc781901cc5a139a0a2.png
[8e46a18acd3146dca3d7f6182602ef3a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/5d32f44051df45d4a94a79849e67a473.png