Taille initiale pour ArrayList

Vous pouvez définir la taille initiale d'une liste de tableaux en faisant

ArrayList<Integer> arr=new ArrayList<Integer>(10);

Cependant, vous ne pouvez pas faire

arr.add(5, 10);

car il provoque une exception hors limites.

À quoi sert de définir une taille initiale si vous ne pouvez pas accéder à l'espace que vous avez alloué?

La fonction d'ajout est définie comme add(int index, Object element)si je n'ajoute pas à l'index 10.

Vous confondez la taille de la liste de baies avec sa capacité:

• la taille est le nombre d'éléments dans la liste;
• la capacité est le nombre d'éléments que la liste peut potentiellement contenir sans réaffecter ses structures internes.

Lorsque vous appelez new ArrayList<Integer>(10), vous définissez la capacité initiale de la liste , pas sa taille. En d'autres termes, lorsqu'elle est construite de cette manière, la liste de tableaux commence sa vie vide.

Une façon d'ajouter dix éléments à la liste de tableaux consiste à utiliser une boucle:

for (int i = 0; i < 10; i++) {
  arr.add(0);
}

Cela fait, vous pouvez maintenant modifier les éléments aux indices 0..9.

Si vous voulez une liste avec une taille prédéfinie, vous pouvez également utiliser:

List<Integer> arr = Arrays.asList(new Integer[10]);

si vous souhaitez utiliser Collections.fill (list, obj); afin de remplir la liste avec un objet répété, vous pouvez également utiliser

ArrayList<Integer> arr=new ArrayList<Integer>(Collections.nCopies(10, 0));

la ligne copie 10 fois 0 dans votre ArrayList

La capacité d'un ArrayListn'est pas la même que sa taille . La taille est égale au nombre d'éléments contenus dans ArrayList(et toute autre Listimplémentation).

La capacité est juste la longueur du tableau sous-jacent qui est utilisé pour stocker en interne les éléments de la ArrayList, et est toujours supérieure ou égale à la taille de la liste.

Lors de l'appel set(index, element)sur la liste, le se indexrapporte au nombre réel des éléments de la liste (= taille) (qui est zéro dans votre code, donc le AIOOBEest levé), pas à la longueur du tableau (= capacité) (qui est un détail d'implémentation spécifique au ArrayList).

La setméthode est commune à toutes les Listimplémentations, telles que LinkedList, qui n'est pas réellement implémentée par un tableau, mais comme une chaîne d'entrées liée.

Edit : Vous utilisez en fait la add(index, element)méthode, non set(index, element), mais le principe est le même ici.

Si vous souhaitez ajouter les éléments avec index, vous pouvez utiliser à la place un tableau.

    String [] test = new String[length];
    test[0] = "add";

10 est la capacité initiale de l'AL, pas la taille (qui est 0). Vous devez mentionner la capacité initiale à une valeur élevée lorsque vous allez avoir beaucoup d'éléments, car cela évite le surcoût d'augmenter la capacité lorsque vous continuez à ajouter des éléments.

Je suppose qu'une réponse exacte à votre question serait:

La définition d'une taille initiale sur une liste de tableaux réduit le nombre. de fois la réallocation de mémoire interne doit se produire. La liste est soutenue par un tableau. Si vous spécifiez par exemple la capacité initiale 0, dès la première insertion d'un élément, le tableau interne devra être redimensionné. Si vous avez une idée approximative du nombre d'éléments que votre liste contiendrait, la définition de la capacité initiale réduirait le nombre. des réallocations de mémoire se produisent pendant que vous utilisez la liste.

Cela pourrait aider quelqu'un -

ArrayList<Integer> integerArrayList = new ArrayList<>(Arrays.asList(new Integer[10]));

Étant en retard à cela, mais après Java 8 , je trouve personnellement cette approche suivante avec l' StreamAPI plus concise et peut être une alternative à la réponse acceptée .

Par exemple,

Arrays.stream(new int[size]).boxed().collect(Collectors.toList())

où sizeest la Listtaille souhaitée et sans l'inconvénient mentionné ici , tous les éléments du Listsont initialisés comme 0.

(J'ai fait une recherche rapide et je n'ai vu streamaucune réponse publiée - n'hésitez pas à me faire savoir si cette réponse est redondante et je peux la supprimer)

À l'heure actuelle, il n'y a aucun élément dans votre liste, vous ne pouvez donc pas l'ajouter à l'index 5 de la liste lorsqu'elle n'existe pas. Vous confondez la capacité de la liste avec sa taille actuelle.

Il suffit d'appeler:

arr.add(10)

ajouter l'entier à votre ArrayList

Bien que votre arraylist ait une capacité de 10, la vraie liste ne contient aucun élément ici. La méthode add est utilisée pour insérer un élément dans la liste réelle. Comme il ne contient aucun élément, vous ne pouvez pas insérer d'élément dans l'index de 5.

Si vous souhaitez ajouter 10 éléments à votre, ArrayListvous pouvez essayer cela:

for (int i = 0; i < 10; i++)
    arr.add(i);

Si vous avez déjà déclaré une variable de taille de tableau, vous utiliseriez la variable sizeau lieu du nombre «10»

J'ai fait face à un problème similaire, et sachant simplement que arrayList est une implémentation de tableau redimensionnable de l'interface List, je m'attends également à ce que vous puissiez ajouter un élément à n'importe quel point, mais au moins avoir la possibilité de définir la taille initiale. Quoi qu'il en soit, vous pouvez d'abord créer un tableau et le convertir en une liste comme:

  int index = 5;
  int size = 10;

  Integer[] array = new Integer[size];
  array[index] = value;
  ...
  List<Integer> list = Arrays.asList(array);

ou

  List<Integer> list = Arrays.asList(new Integer[size]);
  list.set(index, value);

ArrayList myList = nouveau ArrayList (10);

//  myList.add(3, "DDD");
//  myList.add(9, "III");
    myList.add(0, "AAA");
    myList.add(1, "BBB");

    for(String item:myList){
        System.out.println("inside list : "+item);
    }

/ * Déclarer la capacité initiale de l'arrayliste n'est rien d'autre que gagner du temps de changement en interne; lorsque nous ajoutons l'élément en interne, il vérifie la capacité pour augmenter la capacité, vous pouvez ajouter l'élément à l'indice 0 initialement, puis 1 et ainsi de suite. * /

Mes deux cents dessus Stream. Je pense qu'il vaut mieux utiliser

IntStream.generate(i -> MyClass.contruct())
         .limit(INT_SIZE)
         .collect(Collectors.toList());

avec la flexibilité de mettre toutes les valeurs initiales.