集合的并发修改异常问题

 1. 迭代器遍历删除

package com.gch.d6_update_delete;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;

/**
   目标:研究集合遍历并删除元素可能出现的:并发修改异常问题。
   并发:既在遍历也在删除元素
 */
public class Test {
    public static void main(String[] args) {
        // 1.准备数据
        // 多态
        List<String> list = new ArrayList<>();
        list.add("黑马");
        list.add("Java");
        list.add("Java");
        list.add("赵敏");
        list.add("赵敏");
        list.add("素素");
        System.out.println(list); // [黑马, Java, Java, 赵敏, 赵敏, 素素]
        // [黑马, Java, Java, 赵敏, 赵敏, 素素]
        // [黑马, Java, 赵敏, 赵敏, 素素]
        //             it

        // 需求:删除全部的Java信息
        System.out.println("--------------迭代器遍历删除---------------");
//         a.迭代器遍历删除
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            // 问一次取一次,交给一个变量
            String ele = it.next();
            if(Objects.equals(ele,"Java")){
                // 删除Java
//                list.remove(ele); // 集合删除会出毛病:ConcurrentModificationException
                it.remove(); // 删除迭代器所在位置的元素值(没毛病)
            }
        }
        System.out.println(list); // [黑马, 赵敏, 赵敏, 素素]
    }
}

2. foreach遍历删除

/**
   目标:研究集合遍历并删除元素可能出现的:并发修改异常问题。
   并发:既在遍历也在删除元素
 */
public class Test {
    public static void main(String[] args) {
        // 1.准备数据
        // 多态
        List<String> list = new ArrayList<>();
        list.add("黑马");
        list.add("Java");
        list.add("Java");
        list.add("赵敏");
        list.add("赵敏");
        list.add("素素");
        System.out.println(list); // [黑马, Java, Java, 赵敏, 赵敏, 素素]
        System.out.println("---------------foreach遍历删除-----------------");
//         b.foreach遍历删除(会出现问题,这种无法解决,foreach不能边遍历边删除,会出bug)
        for (String s : list) { // 运行报错:ConcurrentModificationException
            if("Java".equals(s)){
                list.remove(s);
            }
        }

3. lambda表达式删除

public class Test {
    public static void main(String[] args) {
        // 1.准备数据
        // 多态
        List<String> list = new ArrayList<>();
        list.add("黑马");
        list.add("Java");
        list.add("Java");
        list.add("赵敏");
        list.add("赵敏");
        list.add("素素");
        System.out.println(list); // [黑马, Java, Java, 赵敏, 赵敏, 素素]  
        System.out.println("-----------------lambda表达式遍历删除--------------");
//         c.lambda表达式遍历删除(会出现问题,这种无法解决,lambda不能边遍历边删除,会出bug)
        list.forEach(s ->{  // 运行报错:ConcurrentModificationException
            if("Java".equals(s)){
                list.remove(s);
            }
        });

4. for循环遍历删除

public class Test {
    public static void main(String[] args) {
        // 1.准备数据
        // 多态
        List<String> list = new ArrayList<>();
        list.add("黑马");
        list.add("Java");
        list.add("Java");
        list.add("赵敏");
        list.add("赵敏");
        list.add("素素");
        System.out.println(list); // [黑马, Java, Java, 赵敏, 赵敏, 素素]  
        System.out.println("---------------for循环遍历删除--------------------");
       // d.for循环遍历删除(for循环边遍历边删除集合没毛病,但是必须从后面倒着开始遍历删除才不会漏掉应该删除的元素)
        for(int i = list.size() - 1;i >= 0; i--) {
            String ele = list.get(i);
            if("Java".equals(ele)){
                list.remove(ele);
            }
        }
        System.out.println(list);
    }
}