并发修改子列表引发的异常

list java

2022-09-02 01:33:14

我有非常简单的代码：

    List<String> list = new ArrayList<String>();
    String a = "a";
    String b = "b";
    String c = "c";
    String d = "d";

    list.add(a);
    list.add(b);
    list.add(c);

    List<String> backedList = list.subList(0, 2);
    list.add(0, d); 
    System.out.println("2b: " + backedList);

我通过list.add（0， d）得到了 ConcurrentModificationException 异常。所以一般来说，这是因为sublist（）。我非常困惑，因为在sublist（）的情况下，文档说：

返回的列表由此列表支持，因此返回列表中的非结构更改将反映在此列表中，反之亦然。

你能解释一下渔获在哪里吗？

答案 1

这是原始列表的简单视图（请参阅此处）。您可以更改其中的元素，但不能更改列表的结构。subList

根据文档，如果您尝试进行结构更改，则行为未定义。我猜在这个特定的实现中，被确定为未定义的行为。subListConcurrentModificationException

如果支持列表（即此列表）以除返回的列表以外的任何方式进行结构修改，则此方法返回的列表的语义将变得未定义。（结构修改是那些更改此列表的大小，或以其他方式扰乱它的方式，以便正在进行的迭代可能会产生不正确的结果。

答案 2

返回的列表由此列表支持，因此返回列表中的非结构更改将反映在此列表中，反之亦然。参考链接

上述说法是绝对正确的，但我们必须牢记非结构性变化。我想举两个例子来证明上述说法的合理性。
示例 1：在列表中执行非结构化更改。

public static void main(String[] args) {
        List<String> listArr = new ArrayList<>();
        listArr.add("Delhi");
        listArr.add("Bangalore");
        listArr.add("New York");
        listArr.add("London");

        List<String> listArrSub = listArr.subList(1, 3);

        System.out.println("List-: " + listArr);
        System.out.println("Sub List-: " + listArrSub);

        //Performing Non-Structural Change in list.
        Collections.swap(listArr, 0, 1);

        System.out.println("\nAfter Non-Structural Change...\n");

        System.out.println("List-: " + listArr);
        System.out.println("Sub List-: " + listArrSub);
    }

输出-：

List-: [Delhi, Bangalore, New York, London]
Sub List-: [Bangalore, New York]

After Non-Structural Change...

List-: [Bangalore, Delhi, New York, London]
Sub List-: [Delhi, New York]

说明-：根据前面提到的Oracle的文档声明，交换操作反映在两个列表中。

示例 2：在子列表中执行非结构性更改。

public static void main(String[] args) {
        List<String> listArr = new ArrayList<>();
        listArr.add("Delhi");
        listArr.add("Bangalore");
        listArr.add("New York");
        listArr.add("London");

        List<String> listArrSub = listArr.subList(1, 3);

        System.out.println("List-: " + listArr);
        System.out.println("Sub List-: " + listArrSub);

        //Performing Non-Structural Change in sub list.
        Collections.swap(listArrSub, 0, 1);

        System.out.println("\nAfter Non-Structural Change...\n");

        System.out.println("List-: " + listArr);
        System.out.println("Sub List-: " + listArrSub);
    }

输出-：

List-: [Delhi, Bangalore, New York, London]
Sub List-: [Bangalore, New York]

After Non-Structural Change...

List-: [Delhi, New York, Bangalore, London]
Sub List-: [New York, Bangalore]

说明-：根据前面提到的Oracle的文档声明，交换操作反映在两个列表中，但是它已经在子列表中执行了。

正如我们在上述两个例子中看到的非结构性变化。现在，让我们按照 Oracle 文档中给出的以下语句查看结构更改。

如果支持列表（即此列表）以除返回的列表以外的任何方式进行结构修改，则此方法返回的列表的语义将变得未定义。（结构修改是那些更改此列表的大小，或以其他方式扰乱它的方式，以便正在进行的迭代可能会产生不正确的结果。

示例 3：在列表中执行结构更改。

 public static void main(String[] args) {
        List<String> listArr = new ArrayList<>();
        listArr.add("Delhi");
        listArr.add("Bangalore");
        listArr.add("New York");
        listArr.add("London");

        List<String> listArrSub = listArr.subList(1, 3);

        System.out.println("List-: " + listArr);
        System.out.println("Sub List-: " + listArrSub);

        //Performing Structural Change in list.
        listArr.add("Mumbai");

        System.out.println("\nAfter Structural Change...\n");

        System.out.println("List-: " + listArr);
        System.out.println("Sub List-: " + listArrSub);
    }

输出-：

List-: [Delhi, Bangalore, New York, London]
Sub List-: [Bangalore, New York]

After Structural Change...

List-: [Delhi, Bangalore, New York, London, Mumbai]
Exception in thread "main" java.util.ConcurrentModificationException
    at java.util.ArrayList$SubList.checkForComodification(ArrayList.java:1231)
    at java.util.ArrayList$SubList.listIterator(ArrayList.java:1091)
    at java.util.AbstractList.listIterator(AbstractList.java:299)
    at java.util.ArrayList$SubList.iterator(ArrayList.java:1087)
    at java.util.AbstractCollection.toString(AbstractCollection.java:454)
    at java.lang.String.valueOf(String.java:2982)
    at java.lang.StringBuilder.append(StringBuilder.java:131)
    at infosys.Research.main(Research.java:26)

说明-：根据前面提到的Oracle的文档语句，每当此方法返回的列表的语义变得未定义时，如果支持列表（即此列表）在结构上进行了修改，则结构修改操作将引发异常，而不是通过返回的列表。java.util.ConcurrentModificationException

示例 4：在子列表中执行结构更改。

public static void main(String[] args) {
        List<String> listArr = new ArrayList<>();
        listArr.add("Delhi");
        listArr.add("Bangalore");
        listArr.add("New York");
        listArr.add("London");

        List<String> listArrSub = listArr.subList(1, 3);

        System.out.println("List-: " + listArr);
        System.out.println("Sub List-: " + listArrSub);

        //Performing Structural Change in sub list.
        listArrSub.add("Mumbai");

        System.out.println("\nAfter Structural Change...\n");

        System.out.println("List-: " + listArr);
        System.out.println("Sub List-: " + listArrSub);
    }

输出-：

List-: [Delhi, Bangalore, New York, London]
Sub List-: [Bangalore, New York]

After Structural Change...

List-: [Delhi, Bangalore, New York, Mumbai, London]
Sub List-: [Bangalore, New York, Mumbai]

说明-：对返回列表的结构修改运行良好，并完全反映在列表中。