Tailles des tableaux dynamiques de Java ?

Question

J'ai une classe - xClass, que je veux charger dans un tableau de xClass donc je la déclaration :

xClass mysclass[] = new xClass[10];
myclass[0] = new xClass();
myclass[9] = new xClass();

Cependant, je ne sais pas si j'en aurai besoin de 10. Je peux avoir besoin de 8 ou 12 ou de n'importe quel autre nombre. Je ne le saurai qu'au moment de l'exécution. Puis-je modifier le nombre d'éléments d'un tableau à la volée ? Si oui, comment ?

Answer 1

Non, vous ne pouvez pas modifier la taille d'un tableau une fois créé. Vous devez soit l'allouer plus grand que ce dont vous pensez avoir besoin, soit accepter de devoir le réallouer si sa taille augmente. Lorsque ce sera le cas, vous devrez en allouer un nouveau et copier les données de l'ancien vers le nouveau :

int[] oldItems = new int[10];
for (int i = 0; i < 10; i++) {
    oldItems[i] = i + 10;
}
int[] newItems = new int[20];
System.arraycopy(oldItems, 0, newItems, 0, 10);
oldItems = newItems;

Si vous vous trouvez dans cette situation, je vous recommande vivement d'utiliser plutôt les Collections Java. En particulier ArrayList enveloppe essentiellement un tableau et s'occupe de la logique de croissance du tableau selon les besoins :

List<XClass> myclass = new ArrayList<XClass>();
myclass.add(new XClass());
myclass.add(new XClass());

En général, un ArrayList est de toute façon une solution préférable à un tableau pour plusieurs raisons. Tout d'abord, les tableaux sont mutables. Si vous avez une classe qui fait ceci :

class Myclass {
    private int[] items;

    public int[] getItems() {
        return items;
    }
}

vous avez créé un problème car un appelant peut modifier votre membre de données privé, ce qui conduit à toutes sortes de copies défensives. Comparez cela à la version List :

class Myclass {
    private List<Integer> items;

    public List<Integer> getItems() {
        return Collections.unmodifiableList(items);
    }
}

Answer 2

En Java, la longueur des tableaux est fixe.

Vous pouvez utiliser une liste pour contenir les valeurs et invoquer la fonction toArray si nécessaire Voir l'exemple suivant :

import java.util.List;
import java.util.ArrayList;
import java.util.Random;

public class A  {

    public static void main( String [] args ) {
        // dynamically hold the instances
        List<xClass> list = new ArrayList<xClass>();

        // fill it with a random number between 0 and 100
        int elements = new Random().nextInt(100);  
        for( int i = 0 ; i < elements ; i++ ) {
            list.add( new xClass() );
        }

        // convert it to array
        xClass [] array = list.toArray( new xClass[ list.size() ] );

        System.out.println( "size of array = " + array.length );
    }
}
class xClass {}

Answer 3

Comme d'autres l'ont dit, vous ne pouvez pas modifier la taille d'un tableau Java existant.

ArrayList est ce que Java a de plus proche d'un tableau de taille dynamique. Cependant, certaines caractéristiques de ArrayList (en fait l'interface List) ne sont pas "similaires à celles d'un tableau". Par exemple :

• Vous ne pouvez pas utiliser [ ... ] pour indexer une liste. Vous devez utiliser la fonction get(int) y set(int, E) méthodes.
• Une ArrayList est créée avec zéro élément. Vous ne pouvez pas simplement créer une ArrayList avec 20 éléments et ensuite appeler set(15, foo) .
• Vous ne pouvez pas modifier directement la taille d'une ArrayList. Vous le faites indirectement à l'aide des différentes fonctions add , insert y remove méthodes.

Si vous voulez quelque chose de plus proche des tableaux, vous devrez concevoir votre propre API. (Peut-être que quelqu'un pourrait vous proposer une bibliothèque tierce existante...). Je n'ai pas pu en trouver une avec 2 minutes de "recherche" sur Google :-) )

Si vous avez seulement besoin d'un tableau qui grandit pendant que vous l'initialisez alors la solution est la suivante.

ArrayList<T> tmp = new ArrayList<T>();
while (...) {
    tmp.add(new T(...));
}
// This creates a new array and copies the element of 'tmp' to it.
T[] array = tmp.toArray(new T[tmp.size()]);

Answer 4

Vous définissez le nombre d'éléments comme vous le souhaitez au moment où vous le créez :

xClass[] mysclass = new xClass[n];

Vous pouvez ensuite initialiser les éléments dans une boucle. Je suppose que c'est ce dont vous avez besoin.

Si vous avez besoin d'ajouter ou de supprimer des éléments au tableau après l'avoir créé, vous devez utiliser une méthode d'ajout et de suppression d'éléments. ArrayList .

Answer 5

Vous pouvez utiliser ArrayList :

import java.util.ArrayList;
import java.util.Iterator;

...

ArrayList<String> arr = new ArrayList<String>();
arr.add("neo");
arr.add("morpheus");
arr.add("trinity");
Iterator<String> foreach = arr.iterator();
while (foreach.hasNext()) System.out.println(foreach.next());