Java : comment diviser une ArrayList en plusieurs petites ArrayLists ?

Question

Comment diviser une ArrayList (taille=1000) en plusieurs ArrayLists de même taille (=10) ?

ArrayList<Integer> results;

Answer 1

Vous pouvez utiliser subList(int fromIndex, int toIndex) pour obtenir une vue d'une partie de la liste originale.

De l'API :

Renvoie une vue de la partie de cette liste comprise entre les valeurs spécifiées de l'élément fromIndex inclusivement, et toIndex exclusive. (Si fromIndex et toIndex sont égales, la liste retournée est vide). La liste retournée est soutenue par cette liste, donc les changements non structurels dans la liste retournée sont reflétés dans cette liste, et vice-versa. La liste retournée supporte toutes les opérations optionnelles supportées par cette liste.

Exemple :

    List<Integer> numbers = new ArrayList<Integer>(
        Arrays.asList(5,3,1,2,9,5,0,7)
    );
    List<Integer> head = numbers.subList(0, 4);
    List<Integer> tail = numbers.subList(4, 8);
    System.out.println(head); // prints "[5, 3, 1, 2]"
    System.out.println(tail); // prints "[9, 5, 0, 7]"
    Collections.sort(head);
    System.out.println(numbers); // prints "[1, 2, 3, 5, 9, 5, 0, 7]"
    tail.add(-1);
    System.out.println(numbers); // prints "[1, 2, 3, 5, 9, 5, 0, 7, -1]"

Si vous avez besoin que ces listes découpées ne soient PAS une vue, il suffit de créer une nouvelle vue de type List de la subList . Voici un exemple de mise en commun de certains de ces éléments :

// chops a list into non-view sublists of length L
static <T> List<List<T>> chopped(List<T> list, final int L) {
    List<List<T>> parts = new ArrayList<List<T>>();
    final int N = list.size();
    for (int i = 0; i < N; i += L) {
        parts.add(new ArrayList<T>(
            list.subList(i, Math.min(N, i + L)))
        );
    }
    return parts;
}

List<Integer> numbers = Collections.unmodifiableList(
    Arrays.asList(5,3,1,2,9,5,0,7)
);
List<List<Integer>> parts = chopped(numbers, 3);
System.out.println(parts); // prints "[[5, 3, 1], [2, 9, 5], [0, 7]]"
parts.get(0).add(-1);
System.out.println(parts); // prints "[[5, 3, 1, -1], [2, 9, 5], [0, 7]]"
System.out.println(numbers); // prints "[5, 3, 1, 2, 9, 5, 0, 7]" (unmodified!)

Answer 2

Vous pouvez ajouter le collections google Goyave à votre projet et utilisez la bibliothèque Listes.partition méthode, par exemple

List<Integer> bigList = ...
List<List<Integer>> smallerLists = Lists.partition(bigList, 10);

Answer 3

La réponse fournie par polygenelubricants divise un tableau en fonction de la taille donnée. Je cherchais un code permettant de diviser un tableau en un nombre donné de parties. Voici la modification que j'ai apportée au code :

public static <T>List<List<T>> chopIntoParts( final List<T> ls, final int iParts )
{
    final List<List<T>> lsParts = new ArrayList<List<T>>();
    final int iChunkSize = ls.size() / iParts;
    int iLeftOver = ls.size() % iParts;
    int iTake = iChunkSize;

    for( int i = 0, iT = ls.size(); i < iT; i += iTake )
    {
        if( iLeftOver > 0 )
        {
            iLeftOver--;

            iTake = iChunkSize + 1;
        }
        else
        {
            iTake = iChunkSize;
        }

        lsParts.add( new ArrayList<T>( ls.subList( i, Math.min( iT, i + iTake ) ) ) );
    }

    return lsParts;
}

J'espère que cela aidera quelqu'un.

Answer 4

Une question similaire a été discutée ici, Java : diviser une liste en deux sous-listes ?

Vous pouvez principalement utiliser la sous-liste. Plus de détails ici : sous-liste

Renvoie une vue de la partie de cette liste comprise entre fromIndex, inclusivement, et toIndex, exclusivement. (Si fromIndex et toIndex sont égaux, la liste retournée est vide). La liste retournée est soutenue par cette liste, donc les changements dans la liste retournée sont reflétés dans cette liste, et vice-versa. La liste retournée supporte toutes les opérations de liste optionnelles supportées par cette liste...

Answer 5

Je suppose que le problème que vous rencontrez concerne l'attribution de noms à 100 ArrayLists et leur remplissage. Vous pouvez créer un tableau de ArrayLists et remplir chacune d'entre elles à l'aide d'une boucle.

La façon la plus simple (lire la plus stupide) de procéder est la suivante :

ArrayList results = new ArrayList(1000);
    // populate results here
    for (int i = 0; i < 1000; i++) {
        results.add(i);
    }
    ArrayList[] resultGroups = new ArrayList[100];
    // initialize all your small ArrayList groups
    for (int i = 0; i < 100; i++) {
            resultGroups[i] = new ArrayList();
    }
    // put your results into those arrays
    for (int i = 0; i < 1000; i++) {
       resultGroups[i/10].add(results.get(i));
    }