java arraylist ensureCapacity ne fonctionne pas

Soit je le fais de mal ou je ne comprends pas comment cette méthode fonctionne.

ArrayList<String> a = new ArrayList<String>();
a.ensureCapacity(200);
a.add(190,"test");
System.out.println(a.get(190).toString());

J'aurais pensé que ensureCapacity me laisser insérer un enregistrement avec un index jusqu'à cette valeur. Est-il un autre moyen pour ce faire?

- Je obtenir une IndexOutOfBounds erreur sur la troisième ligne.

OriginalL'auteur kralco626 | 2011-10-07

arraylist java

34

Non, ensureCapacity ne change pas le taille logique d'un ArrayList - il des changements de la capacité, qui est la taille de la liste peut atteindre avant la prochaine besoins de copier les valeurs.

Vous devez être très conscient de la différence entre une logique de taille (c'est à dire toutes les valeurs dans la plage de [0, size) sont accessibles, et en ajoutant un nouvel élément à ajouter à l'index size) et de la capacité qui est plus d'un détail d'implémentation vraiment - c'est la taille de la sauvegarde de tableau utilisé pour le stockage.

Appel ensureCapacity ne devrait jamais faire aucune différence en termes de performance (en évitant les excès de copie) - il n'a pas d'incidence sur le modèle logique de ce qui est dans la liste, si vous voyez ce que je veux dire.

EDIT: Il semble que vous voulez une sorte de ensureSize() méthode, qui pourrait ressembler à quelque chose comme ceci:
```
public static void ensureSize(ArrayList<?> list, int size) {
    //Prevent excessive copying while we're adding
    list.ensureCapacity(size);
    while (list.size() < size) {
        list.add(null);
    }
}
```
Donc, c'est ce que je pensais basé sur les résultats que j'ai vu... Mais est-il un moyen de faire ce que je dois faire?
l'utilisation de tableau, si vous voulez vraiment avoir un seul point sur la position de 190
Peut-être à l'aide d'une autre classe, plutôt que de ArrayList?
l'utilisation d'un tableau suppose que je sais que la taille du tableau...
Ma parade est terminée. Merci Jon. Maintenant, je vais devoir trouver comment dire à mes enfants 😉

OriginalL'auteur Jon Skeet
2

En assurant la capacité n'est pas d'ajouter des éléments à la liste. Vous ne pouvez obtenir l'élément 190 ou d'ajouter à l'élément 190 si vous avez ajouté 191 éléments déjà. La "capacité" est simplement le nombre d'objets de la liste de tableaux peut tenir avant d'avoir besoin de redimensionner sa structure de données interne (un tableau). Si ArrayList avait un getCapacity(), puis faire ceci:
```
ArrayList<String> a = new ArrayList<String>();
a.ensureCapacity(200);
System.out.println(a.size());
System.out.println(a.getCapacity());
```
affichera 0 et un nombre supérieur ou égal à 200, respectivement

OriginalL'auteur Ryan Stewart
2

Alors que d'autres ont mentionné ensureCapacity n'est-ce pas pour cela.
Il semble que vous voulez commencer avec un ArrayList de 200 à null? Alors ce serait la façon la plus simple de le faire:
```
ArrayList<String> a = new ArrayList<String>(Arrays.asList( new String[200] ));
```
Alors si vous voulez remplacer élément 190 avec "test" n':
```
a.set(190, "test");
```
Ce qui est différent de
```
a.add(190, "test");
```
qui permettra d'ajouter "test" dans l'indice 190 et maj les 9 autres éléments, résultant dans une liste de taille 201.

Si vous savez que vous allez toujours avoir de 200 éléments, il pourrait être préférable d'utiliser un tableau.

+1, mais je viens de sortir un exemple simple qui a provoqué la même erreur pour la même raison que ma situation réelle. Merci.

OriginalL'auteur trutheality
1

ArrayList maintient sa capacité (la taille du tableau interne) séparément de sa taille (le nombre d'éléments ajoutés), et l'ensemble de la méthode dépend de l'indice ayant déjà été attribué à un élément. Il n'y a pas un moyen pour définir la taille. Si vous avez besoin de cela, vous pouvez ajouter mannequin éléments avec une boucle:
```
for (int i = 200; --i >= 0;) a.add(null);
```
OriginalL'auteur Boann
0

Une fois de plus JavaDoc pour clarifier la situation:
```
Throws: IndexOutOfBoundsException 
    - if index is out of range (index < 0 || index > size()).
```
Noter que size() renvoie le nombre d'éléments actuellement en possession de la Liste.

OriginalL'auteur Jan Zyka
0

ensureCapacity juste fait en sorte que le sous-jacent de la matrice de capacité est supérieure ou égale à l'argument. On ne change pas la taille de la ArrayList. Il ne pas faire de changements visibles par le biais de l'API, de sorte que vous ne remarquerez pas la différence, sauf qu'il sera probablement de plus avant que le ArrayList redimensionne le tableau interne.

OriginalL'auteur jgon
0

L'ajout de 190 entrées null à une liste de tableaux présage d'une mauvaise utilisation de la structure de données.
1. Penser à l'aide d'une primitive standard tableau.
2. Si vous avez besoin d'un génériques ou souhaitez une utilisation plus efficace de l'espace, puis envisager d' SparseArray ou même un Map comme un HashMap peut être approprié pour vos besoins.
OriginalL'auteur Andrew Gallasch

  public static void fillArrayList(ArrayList<String> arrayList, long size) {
    for (int i = 0; i < size + 1; i++) {
      arrayList.add(i,"-1");
    }
  }

public static void main(String[] args) throws Exception {
  ArrayList<String> a = new ArrayList<String>(10);
  fillArrayList(a, 190);
  a.add(190,"test");
  System.out.println(a.get(190).toString());
}

Je pense que de cette façon, vous pouvez le faire fonctionner... @kralco626

OriginalL'auteur sreenath sirimala

Vous devez vous connecter pour publier un commentaire.