list.clear () vs list = new ArrayList <Integer> ();

Question

Laquelle des 2 options est la meilleure et la plus rapide pour effacer une liste de tableaux, et pourquoi?

 list.clear() 
 

ou

 list = new ArrayList<Integer>();
 

Il arrive que je doive, à des moments aléatoires, effacer toutes les entrées de mon ArrayList et que je n'ai aucun moyen de savoir combien il y aura de nouvelles entrées dans le futur, il pourrait y avoir 0 ou un 1000. Quelle méthode est plus rapide et meilleure, et pourquoi?

Answer 1

Il est difficile de savoir sans repère, mais si vous avez beaucoup d'éléments dans votre ArrayList et que la taille moyenne est inférieure, il sera peut-être plus rapide de créer un nouvel ArrayList.

http://www.docjar.com/html/api/java/util/ArrayList.java.html

   506       public void clear() {
  507           modCount++;
  508   
  509           // Let gc do its work
  510           for (int i = 0; i < size; i++)
  511               elementData[i] = null;
  512   
  513           size = 0;
  514       }
 

Answer 2

List.clear permettrait de supprimer les éléments sans réduction de la capacité de la liste.

groovy:000> mylist = [1,2,3,4,5,6,7,8,9,10,11,12]
===> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
groovy:000> mylist.elementData.length
===> 12
groovy:000> mylist.elementData
===> [Ljava.lang.Object;@19d6af
groovy:000> mylist.clear()
===> null
groovy:000> mylist.elementData.length
===> 12
groovy:000> mylist.elementData
===> [Ljava.lang.Object;@19d6af
groovy:000> mylist = new ArrayList();
===> []
groovy:000> mylist.elementData
===> [Ljava.lang.Object;@2bfdff
groovy:000> mylist.elementData.length
===> 10

Ici maliste ai effacé, les références aux éléments détenus par elle a obtenu entaché de nullité, mais il garde le même support de tableau. Puis maliste a été réinitialisé et a obtenu une nouvelle sauvegarde de la baie, le vieux se leva et GCed. Ainsi, il détient sur la mémoire, l'autre jette sa mémoire et obtient réaffectées à partir de zéro (avec la valeur par défaut de la capacité). Ce qui est mieux dépend de si vous voulez réduire les déchets-collecte de désabonnement ou de minimiser la quantité de mémoire inutilisée. Si la liste de colle autour assez longtemps pour être déplacé hors de l'Eden pourrait être un facteur dans la décision, qui est plus rapide (car cela pourrait rendre les déchets-collecte, il est plus coûteux).

Answer 3

Je pense que la réponse est que cela dépend d'un ensemble de facteurs tels que:

• si la liste de taille peut être prédit à l'avance (c'est à dire que vous pouvez définir la capacité de précision),
• si les listes de taille est variable,
• combien de temps la durée de vie de la liste dans les deux versions, et
• votre tas / GC paramètres et de la CPU.

Comme cela, il est difficile de prédire qui sera mieux. Mais mon intuition est que la différence ne sera pas énorme.

Deux morceaux de conseils:

• Ne perdez pas de temps à essayer d'optimiser ce ... sauf si la demande est objectivement trop lent >>ET<< le profiler vous dit c'est une performance hotspot. (Les chances sont que l'un ou l'autre de ces conditions ne sera pas vrai.)

• Si vous décidez d'optimiser cette, le faire scientifiquement. Essayer les deux (tous) les solutions de rechange et de décider qui est le mieux par la mesure de la performance de votre application sur un réaliste du problème / de la charge de travail / d'entrée de jeu. (Artificielle de référence est peu probable pour vous donner les réponses que vous pouvez utiliser, en raison de facteurs tels que ceux énumérés ci-dessus.)

Answer 4

Le premier .clear(); gardera la même liste simplement effacer la liste.

Le second new ArrayList<Integer>(); crée un nouveau ArrayList en mémoire.

Suggestion: d'abord parce que c'est ce qui est conçu pour le faire.

Answer 5

Essayé le programme ci-dessous , Avec à la fois l'approche. 1. Avec compensation de la liste de tableaux obj dans la boucle for 2. la création de nouveaux New Arraylist dans la boucle for.

List al= new ArrayList();
        for(int i=0;i<100;i++)
        {
            //List al= new ArrayList();

            for(int j=0;j<10;j++)
            {
                al.add(Integer.parseInt("" +j+i));
                //System.out.println("Obj val " +al.get(j));
            }
            //System.out.println("Hashcode : " + al.hashCode());
            al.clear();

        }

et à ma grande surprise. l'allocation de mémoire n'a pas beaucoup changé.

Avec New Arraylist approche.

Avant de boucle totale de mémoire libre: 64,909 ::

Après la boucle totale de mémoire libre: 64,775 ::

avec une approche Claire,

Avant de boucle totale de mémoire libre: 64,909 :: Après la boucle totale de mémoire libre: 64,765 ::

Donc, cela dit il n'y a pas beaucoup de différence dans l'utilisation de arraylist.effacer de la mémoire utilisation de la perspective.