Existe-t-il une collection Java dans laquelle plusieurs sous-listes sans chevauchement peuvent modifier les listes de sauvegarde et rester utilisables?

Question

Le code suivant est confronté au même problème rencontré par G.D in this post. Fondamentalement, plusieurs sous-listes ne peuvent pas modifier une liste de sauvegarde.

Par exemple:

import java.util.Arrays; 
import java.util.List; 

public class TestClass{ 
    public static void main(String[] args){ 
    SOtest(); 
    } 

     /*a test for stack overflow. Trying to find the right data structure*/ 
    public static void SOtest(){ 
     int[] gers = {1,3,2,4}; 
     ArrayList<Integer> name = new ArrayList<>(); 
     for(int i:gers)name.add(i); 

     List firstSL = name.subList(0,2); 
     List secondSL = name.subList(2,name.size()); 

     firstSL.remove(0); 
     secondSL.remove(0); 

     System.out.println(Arrays.toString(firstSL.toArray())); 
     System.out.println(Arrays.toString(secondSL.toArray())); 

    } 
} 

  Ce code provoquera une ConcurrentModificationException parce firstSL et secondSL tant .remove d'utilisation.

Exception in thread "main" java.util.ConcurrentModificationException 
    at java.util.ArrayList$SubList.checkForComodification(ArrayList.java:1231) 
    at java.util.ArrayList$SubList.remove(ArrayList.java:1054) 
    at TestClass.SOtest(TestClass.java:26) 
    at TestClass.main(TestClass.java:13) 

Une solution à ce recopie les sous-listes dans de nouveaux tableaux comme ceci:

... 
ArrayList<Integer> firstSL = new ArrayList<Integer>(name.subList(0,2)); 
ArrayList<Integer> secondSL = new ArrayList<Integer>(name.sublist(2,name.size()); 

Cependant, je voudrais éviter cette solution parce que je dois faire cette opération beaucoup et la copie prend trop de temps.

Les sous-listes que je crée ne chevaucheront jamais donc je ne vois pas pourquoi c'est un problème.
  par exemple, je n'aurai jamais

name = [1,2,3,4] 
firstSL = [1,2] 
secondSL = [2,3,4] 

Y at-il une collection qui a ce comportement?

Edit:

Comme suggéré dans les commentaires, je vais essayer d'élaborer. Tout le comportement dont j'ai besoin est: une collection ordonnée qui a la capacité ci-dessus d'être sous-listée, accédée par un index, donner sa taille et être supprimée par un index.

Je doute que cela soit utile, mais il sera utilisé dans les sous-classes MergeSort de cet algorithme de tri github.com/user-name-is-taken/Merge_sort.

Answer 1

n ° List#subList appelle explicitement ce genre de chose comme being "undefined" if the backing list is disturbed in anyway:

La sémantique de la liste renvoyée par cette méthode devenir non définie si la liste de soutien (par exemple, cette liste) est modifié structurellement en de toute autre manière que via la liste renvoyée. (Modifications structurelles sont celles qui changent la taille de cette liste, ou perturbez autrement dans une telle façon que les itérations en cours peuvent donner des résultats incorrects.)

Si vous voulez quelque chose comme cela, vous devrez ingénieur votre propre solution. Ce que vous avez est un début décent, mais vous pouvez vouloir l'encapsuler dans un objet approprié par vous-même.