pourquoi les tableaux sont initialisés à des valeurs par défaut, mais pas de liste de tableaux en java?

La mise en œuvre de ArrayList utilise Array sous le capot. Cependant, Arrays sont initialisée avec les valeurs par défaut (0 or null) mais ArrayList sont tout simplement vide. pourquoi est-ce?

       int[] arr = new int[10];
       String[] arr1 = new String[11];
       System.out.println(Arrays.toString(arr));
       System.out.println(Arrays.toString(arr1));
      List<Integer> list = new ArrayList<Integer>(10);
      System.out.println(list);

      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
      [null, null, null, null, null, null, null, null, null, null, null]
      []

Cela signifie que chaque fois que je l'utilise, ArrayList, j'ai besoin de remplir des trucs;
J'ai essayé le ci-dessous une partie de mon code et il jetait des NoSuchElementException et puis j'ai réalisé qu'il n'est pas en défaut, où que Arrays ne

if (list.get(i)==null){
         list.add(i,x);
  else:
        list.add(i,list.get(i)+x)

EDIT:

even List<Integer> list = new ArrayList<Integer>(10);
prints [] although I initialized the size;

Concernant votre edit: Vous n'avez pas défini la taille de 10. Vous définissez la capacité à 10. La taille est de 0 jusqu'à ce que vous ajoutez un élément.
Cela signifie que chaque fois que je l'utilise, ArrayList, j'ai besoin de remplir de choses dans ... Oui, vous ne l'utilisez pas si vous n'avez pas "remplir des trucs".
Vous voyez pas d'éléments lors de l'impression de la liste en raison de son toString() méthode utilise size à déterminer combien d'éléments d'impression, pas de la capacité de la matrice. Lorsque vous créez ArrayList avec une capacité initiale 10 sa taille est encore 0 parce que vous n'avez pas ajouter tous les éléments pour le moment, même si le tableau qui stocke vos objets a été initialisé en tant que nouvel Objet[10] ce qui signifie qu'il est rempli avec 10 valeurs null.
P. S. "qualité" que vous avez initialisé la ArrayList avec juste un soupçon, de toute façon. Si vous spécifiez la capacité de 10, vous pouvez toujours ajouter des 11 éléments. Les résultats de votre programme doit être la même quelle que soit la capacité de vous préciser; seule la performance est affectée.

OriginalL'auteur brain storm | 2014-01-29

4

Lorsque vous créez un tableau, vous spécifiez la taille. Cela est nécessaire parce que la taille des tableaux ne peuvent pas être modifiés une fois qu'ils sont créés. Quelque chose doit aller dans chaque élément de la matrice, et la chose la plus évidente à mettre 0 ou null.

D'autre part, ArrayLists sont conçus pour pouvoir être redimensionnée. Donc, vous ne devriez pas avoir à spécifier la taille lorsque vous les créez. Si la taille est supérieure à zéro, il faut initialiser tous ces éléments, et il est plus facile de ne pas. Donc, à partir de la taille est égale à zéro.

voir mon edit dans le post ci-dessus
Ce que vous avez initialisé est la capacité, pas la taille. La liste de tableau fait de la place pour 10 éléments, mais cela ne veut pas dire qu'il a 10 éléments.

OriginalL'auteur tbodt
12

Lors de la construction d'un tableau, le nombre est le réelle la taille de la matrice (et vous ne pouvez pas le changer plus tard). Le nombre dans la ArrayList constructeur est la première capacité (espace réservé pour les éléments), mais le taille est égale à zéro. La taille d'un ArrayList peut changer après il est construit.

mais il peut encore défaut sa valeur à zéro ou à la valeur null. comment la nature dynamique de la liste de tableaux affectera ce qu'il contient
voir mon edit dans le post ci-dessus
Vous appelez le toString() méthode de la liste de tableaux. Depuis sa taille est de 0, la Chaîne construite par toString est vide (vérifier le code source). C'est pourquoi vous "voir" rien.
Oui. Le 10 n'est que la capacité initiale. Il peut augmenter par la suite.
la spécification de la capacité initiale n'affecte pas son comportement, mais seulement de son rendement

OriginalL'auteur Greg Hewgill
4

La raison de null et 0 est la différence entre le primitif et Object types. Leurs valeurs par défaut sont null et 0(seulement false booléenne) en conséquence.
Voir Le Tutoriel Java

ArrayList n'est pas physiquement vide après la création. Il a des capacités, mais il montre à sa taille 0 même vous avez initialisé c'est exactement ça.Étant donné que la Collecte size() a logique du sens, pas phisique.
```
List<Integer> list = new ArrayList<Integer>(10);
```
Vous pouvez également remplir la nouvelle Collection (Liste) avec la méthode statique suivante
```
Collections.fill(list, 0) //int 0 is auto-boxed to `Integers` 0 
```
REMARQUE: fill() ne fonctionne pas directement après l'initialisation, depuis la taille de la liste = 0. Voir nCopies() réponse pour ce cas.

OriginalL'auteur Ashot Karakhanyan
3

Vous pourriez le faire comme ceci:
```
List<Integer> items = Arrays.asList(new Integer[10]);
```
Et vous obtiendrez une liste avec les 10 éléments null.

De même,
```
Integer[] numbers = new Integer[10];
Arrays.fill(numbers,0);
List<Integer> list = Arrays.asList(numbers);
```
Et vous obtenez une liste avec les 10 éléments initialisés à 0;

OriginalL'auteur Edwin Dalorzo
3

Comme une liste de tableaux ne sont pas d'abord contenir tous les éléments, il ne peut pas par défaut la valeur de ces éléments à la valeur null ou n'importe quelle autre valeur.

OriginalL'auteur user207421
2

Le but de la ArrayList collection est quasiment aussi rapide qu'un tableau, sans déchets (= preallocation) de l'espace. Par conséquent, il est initialisé à size 0 (c'est à dire, vide), plutôt que d'avoir plusieurs null valeurs (bien que, pratiquement parlant, le sous-jacent tableau est construit à la capacité spécifiée).

Cela dit, notez également qu'un ArrayList permettra de stocker des objets et non pas des primitives (par exemple, String des objets et non char ou int primitives).

OriginalL'auteur PNS
2

Je suppose que vous êtes à la recherche pour Collections.nCopies:
```
List<Integer> list = new ArrayList<Integer>(Collections.nCopies(10, 0));
```
OriginalL'auteur Happy
1

C'est parce qu'il n'y a pas de constructeur dans ArrayList qui pourrait créer une instance d'une certaine taille. Collections.nCopies(int n, T o) permet de créer une Liste prédéfinie de la taille et de l'initialiser avec des valeurs. BTW en interne, il utilise CopiesList classe, qui a CopiesList(int n, E e) constructeur

OriginalL'auteur Evgeniy Dorofeev

Vous devez vous connecter pour publier un commentaire.