openclassroom - parcourir une liste java




En Java 8, pourquoi la capacité par défaut de ArrayList est-elle maintenant nulle? (4)

Si je me souviens bien, avant Java 8, la capacité par défaut d’ ArrayList était de 10.

De manière surprenante, le commentaire sur le constructeur par défaut (void) dit toujours: Constructs an empty list with an initial capacity of ten.

De ArrayList.java :

/**
 * Shared empty array instance used for default sized empty instances. We
 * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
 * first element is added.
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

...

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

Après la question ci-dessus, je suis passé par ArrayList Document of Java 8. J'ai trouvé que la taille par défaut est toujours 10 seulement.


En java 8, la capacité par défaut de ArrayList est 0 jusqu'à ce que nous ajoutions au moins un objet dans l'objet ArrayList (vous pouvez l'appeler initialisation différée).

Maintenant, la question est pourquoi ce changement a été fait dans JAVA 8?

La réponse consiste à économiser la consommation de mémoire. Des millions d'objets de liste de tableaux sont créés dans des applications Java en temps réel. La taille par défaut de 10 objets signifie que nous allouons 10 pointeurs (40 ou 80 octets) pour le tableau sous-jacent à la création et les remplissons avec des valeurs NULL. Un tableau vide (rempli de NULL) occupe beaucoup de mémoire.

Une initialisation lente retarde cette consommation de mémoire jusqu'au moment où vous utiliserez réellement la liste de tableaux.

Veuillez consulter le code ci-dessous pour obtenir de l'aide.

ArrayList al = new ArrayList();          //Size:  0, Capacity:  0
ArrayList al = new ArrayList(5);         //Size:  0, Capacity:  5
ArrayList al = new ArrayList(new ArrayList(5)); //Size:  0, Capacity:  0
al.add( "shailesh" );                    //Size:  1, Capacity: 10

public static void main( String[] args )
        throws Exception
    {
        ArrayList al = new ArrayList();
        getCapacity( al );
        al.add( "shailesh" );
        getCapacity( al );
    }

    static void getCapacity( ArrayList<?> l )
        throws Exception
    {
        Field dataField = ArrayList.class.getDeclaredField( "elementData" );
        dataField.setAccessible( true );
        System.out.format( "Size: %2d, Capacity: %2d%n", l.size(), ( (Object[]) dataField.get( l ) ).length );
}

Response: - 
Size:  0, Capacity:  0
Size:  1, Capacity: 10

Article La capacité par défaut d'ArrayList en Java 8 l' explique en détail.


La taille par défaut d'ArrayList dans JAVA 8 est de 10. La seule modification apportée dans JAVA 8 est que, si un codeur ajoute des éléments inférieurs à 10, les espaces vides arraylist restants ne sont pas définis comme nuls. Dire cela parce que j’ai moi-même traversé cette situation et qu’éclipse m’a amené à examiner ce changement de JAVA 8.

Vous pouvez justifier ce changement en regardant la capture d'écran ci-dessous. Vous pouvez y voir que la taille d’ArrayList est définie à 10 dans Object [10], mais que le nombre d’éléments affichés n’est que de 7. Les éléments de valeur null restants ne sont pas affichés ici. Dans JAVA 7, la capture d'écran ci-dessous est identique à une seule modification, à savoir que les éléments de valeur NULL sont également affichés pour lesquels le codeur doit écrire du code pour la gestion des valeurs NULL s'il itère une liste complète de tableaux alors que dans JAVA 8, cette charge est supprimée le chef du codeur / développeur.

Lien de capture d'écran.


Si la toute première opération effectuée avec ArrayList consiste à transmettre à addAll une collection comportant plus de dix éléments, toute tentative visant à créer un premier tableau de dix éléments contenant le contenu de ArrayList serait rejetée hors de la fenêtre. Chaque fois que quelque chose est ajouté à une liste de tableaux, il est nécessaire de vérifier si la taille de la liste résultante sera supérieure à la taille du magasin de sauvegarde. Si la taille du magasin de support initial est de zéro au lieu de dix, le test échouera une fois de plus dans la durée de vie d'une liste dont la première opération est un "add", ce qui nécessiterait la création du tableau de dix éléments initial, mais ce coût est moins que le coût de la création d'un tableau de dix éléments qui ne finit jamais par être utilisé.

Cela dit, il aurait peut-être été possible d'améliorer encore les performances dans certains contextes s'il y avait eu une surcharge de "addAll" qui spécifiait le nombre d'éléments (le cas échéant) susceptibles d'être ajoutés à la liste après celui-ci, et qui pourraient l'utiliser pour influencer son comportement d'allocation. Dans certains cas, le code qui ajoute les derniers éléments à une liste aura une bonne idée que la liste n’aura jamais besoin d’espace supplémentaire. Il existe de nombreuses situations dans lesquelles une liste sera remplie une fois et ne sera jamais modifiée par la suite. Si le code de point sait que la taille ultime d’une liste sera de 170 éléments, elle comporte 150 éléments et un magasin de support de taille 160, augmenter le magasin de support à la taille 320 sera inutile et le laisser à la taille 320 ou le réduire au minimum. 170 sera moins efficace que le simple fait de passer à la prochaine allocation.





java-8