Pourquoi démarrer une ArrayList avec une capacité initiale?

Le constructeur habituel de ArrayListest:

ArrayList<?> list = new ArrayList<>();

Mais il existe aussi un constructeur surchargé avec un paramètre pour sa capacité initiale:

ArrayList<?> list = new ArrayList<>(20);

Pourquoi est-il utile de créer un ArrayListavec une capacité initiale alors que nous pouvons y ajouter à notre guise?

Si vous savez à l'avance quelle sera la taille de la ArrayList, il est plus efficace de spécifier la capacité initiale. Si vous ne le faites pas, le tableau interne devra être réalloué à plusieurs reprises au fur et à mesure que la liste s'allonge.

Plus la liste finale est longue, plus vous gagnez de temps en évitant les réallocations.

Cela dit, même sans pré-allocation, l'insertion d' néléments à l'arrière d'un ArrayListest garanti pour prendre un O(n)temps total . En d'autres termes, l'ajout d'un élément est une opération à temps constant amorti. Pour ce faire, chaque réallocation augmente la taille du tableau de façon exponentielle, généralement d'un facteur de 1.5. Avec cette approche, le nombre total d'opérations peut être démontréO(n) .

Parce qu'il ArrayLists'agit d'une structure de données de tableau de redimensionnement dynamique , ce qui signifie qu'elle est implémentée en tant que tableau avec une taille fixe initiale (par défaut). Lorsque celui-ci est rempli, la matrice sera étendue à une double taille. Cette opération est coûteuse, vous en voulez donc le moins possible.

Donc, si vous savez que votre limite supérieure est de 20 éléments, il est préférable de créer le tableau avec une longueur initiale de 20 que d'utiliser une valeur par défaut de, disons, 15, puis de le redimensionner 15*2 = 30et de n'utiliser que 20 tout en gaspillant les cycles d'expansion.

PS - Comme le dit AmitG, le facteur d'expansion est spécifique à l'implémentation (dans ce cas (oldCapacity * 3)/2 + 1)

La taille par défaut de Arraylist est de 10 .

    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
    this(10);
    } 

Ainsi, si vous comptez ajouter 100 enregistrements ou plus, vous pouvez voir la surcharge de la réallocation de mémoire.

ArrayList<?> list = new ArrayList<>();    
// same as  new ArrayList<>(10);      

Donc, si vous avez une idée du nombre d'éléments qui seront stockés dans Arraylist, il est préférable de créer Arraylist avec cette taille au lieu de commencer par 10, puis de l'augmenter.

J'ai en fait écrit un article de blog sur le sujet il y a 2 mois. L'article est pour C # List<T>mais Java ArrayLista une implémentation très similaire. Comme il ArrayListest implémenté à l'aide d'un tableau dynamique, sa taille augmente à la demande. Donc, la raison du constructeur de capacité est à des fins d'optimisation.

Lorsqu'une de ces opérations de redimensionnement se produit, ArrayList copie le contenu du tableau dans un nouveau tableau qui est deux fois la capacité de l'ancien. Cette opération s'exécute en temps O (n) .

Exemple

Voici un exemple de la façon dont la ArrayListtaille augmenterait:

10
16
25
38
58
... 17 resizes ...
198578
297868
446803
670205
1005308

Ainsi, la liste commence avec une capacité de 10, lorsque le 11e élément est ajouté, il est augmenté de 50% + 1à 16. Sur le 17e élément, le ArrayListest à nouveau augmenté 25et ainsi de suite. Prenons maintenant l'exemple où nous créons une liste dans laquelle la capacité souhaitée est déjà connue sous le nom de 1000000. La création du ArrayListconstructeur sans la taille appellera des ArrayList.add 1000000temps qui prennent O (1) normalement ou O (n) lors du redimensionnement.

1000000 + 16 + 25 + ... + 670205 + 1005308 = 4015851 opérations

Comparez cela en utilisant le constructeur, puis en appelant ArrayList.addce qui est garanti pour s'exécuter dans O (1) .

1000000 + 1000000 = 2000000 opérations

Java contre C #

Java est comme ci-dessus, commençant à 10et augmentant chaque redimensionnement à 50% + 1. C # commence à 4et augmente beaucoup plus agressivement, doublant à chaque redimensionnement. L' 1000000exemple ajoute ci-dessus pour C # utilise des 3097084opérations.

Références

• Mon article de blog sur la liste C # <T>
• Code source de Java ArrayList

La définition de la taille initiale d'une ArrayList, par exemple à ArrayList<>(100), réduit le nombre de fois que la réallocation de la mémoire interne doit se produire.

Exemple:

ArrayList example = new ArrayList<Integer>(3);
example.add(1); // size() == 1
example.add(2); // size() == 2, 
example.add(2); // size() == 3, example has been 'filled'
example.add(3); // size() == 4, example has been 'expanded' so that the fourth element can be added. 

Comme vous le voyez dans l'exemple ci-dessus, un ArrayListpeut être développé si nécessaire. Ce que cela ne vous montre pas, c'est que la taille de la liste Arraylist double généralement (mais notez que la nouvelle taille dépend de votre implémentation). Ce qui suit est cité par Oracle :

«Chaque instance ArrayList a une capacité. La capacité est la taille du tableau utilisé pour stocker les éléments dans la liste. Elle est toujours au moins aussi grande que la taille de la liste. Au fur et à mesure que les éléments sont ajoutés à une ArrayList, sa capacité augmente automatiquement. Les détails de la politique de croissance ne sont pas précisés au-delà du fait que l'ajout d'un élément a un coût en temps amorti constant. "

Évidemment, si vous n'avez aucune idée du type de plage que vous tiendrez, définir la taille ne sera probablement pas une bonne idée - cependant, si vous avez une plage spécifique en tête, la définition d'une capacité initiale augmentera l'efficacité de la mémoire. .

ArrayList peut contenir de nombreuses valeurs et lorsque vous effectuez des insertions initiales importantes, vous pouvez indiquer à ArrayList d'allouer un stockage plus important pour commencer afin de ne pas gaspiller de cycles de processeur lorsqu'il tente d'allouer plus d'espace pour l'élément suivant. Ainsi, allouer de l'espace au début est plus efficace.

Ceci afin d'éviter d'éventuels efforts de réallocation pour chaque objet.

int newCapacity = (oldCapacity * 3)/2 + 1;

new Object[]est créé en interne .
La JVM a besoin d'efforts pour créer new Object[]lorsque vous ajoutez un élément dans l'arraylist. Si vous n'avez pas de code ci-dessus (n'importe quel algo que vous pensez) pour la réallocation, alors chaque fois que vous appelez, arraylist.add()il new Object[]faut créer ce qui est inutile et nous perdons du temps pour augmenter la taille de 1 pour chaque objet à ajouter. Il est donc préférable d'augmenter la taille de Object[]avec la formule suivante.
(JSL a utilisé la formule de prévision donnée ci-dessous pour une arraylist en croissance dynamique au lieu d'augmenter de 1 à chaque fois. Parce que la croissance nécessite des efforts de la part de JVM)

int newCapacity = (oldCapacity * 3)/2 + 1;

Je pense que chaque ArrayList est créé avec une valeur de capacité d'initialisation de "10". Donc de toute façon, si vous créez une ArrayList sans définir de capacité dans le constructeur, elle sera créée avec une valeur par défaut.

Je dirais que c'est une optimisation. ArrayList sans capacité initiale aura ~ 10 lignes vides et se développera lorsque vous effectuez un ajout.

Pour avoir une liste avec exactement le nombre d'éléments dont vous avez besoin d'appeler trimToSize ()

D'après mon expérience avec ArrayList, donner une capacité initiale est un bon moyen d'éviter les coûts de réaffectation. Mais cela mérite une mise en garde. Toutes les suggestions mentionnées ci-dessus indiquent qu'il ne faut fournir la capacité initiale que si une estimation approximative du nombre d'éléments est connue. Mais lorsque nous essayons de donner une capacité initiale sans aucune idée, la quantité de mémoire réservée et inutilisée sera un gaspillage car elle ne sera peut-être jamais nécessaire une fois que la liste est remplie jusqu'au nombre requis d'éléments. Ce que je dis, c'est que nous pouvons être pragmatiques au début lors de l'allocation de capacité, puis trouver un moyen intelligent de connaître la capacité minimale requise au moment de l'exécution. ArrayList fournit une méthode appelée ensureCapacity(int minCapacity). Mais alors, il faut trouver un moyen intelligent ...

J'ai testé ArrayList avec et sans initialCapacity et j'ai obtenu un résultat surprenant.
Quand je règle LOOP_NUMBER à 100 000 ou moins, le résultat est que le réglage initialCapacity est efficace.

list1Sttop-list1Start = 14
list2Sttop-list2Start = 10

Mais lorsque je règle LOOP_NUMBER sur 1 000 000, le résultat devient:

list1Stop-list1Start = 40
list2Stop-list2Start = 66

Enfin, je n'ai pas compris comment ça marche?!
Exemple de code:

 public static final int LOOP_NUMBER = 100000;

public static void main(String[] args) {

    long list1Start = System.currentTimeMillis();
    List<Integer> list1 = new ArrayList();
    for (int i = 0; i < LOOP_NUMBER; i++) {
        list1.add(i);
    }
    long list1Stop = System.currentTimeMillis();
    System.out.println("list1Stop-list1Start = " + String.valueOf(list1Stop - list1Start));

    long list2Start = System.currentTimeMillis();
    List<Integer> list2 = new ArrayList(LOOP_NUMBER);
    for (int i = 0; i < LOOP_NUMBER; i++) {
        list2.add(i);
    }
    long list2Stop = System.currentTimeMillis();
    System.out.println("list2Stop-list2Start = " + String.valueOf(list2Stop - list2Start));
}

J'ai testé sur windows8.1 et jdk1.7.0_80