Créer un tableau de tableaux

Je souhaite créer un tableau d'arraylist comme ci-dessous:

ArrayList<Individual>[] group = new ArrayList<Individual>()[4]

Mais ce n'est pas une compilation. Comment puis-je faire ceci?

Selon la documentation Oracle :

"Vous ne pouvez pas créer de tableaux de types paramétrés"

Au lieu de cela, vous pouvez faire:

ArrayList<ArrayList<Individual>> group = new ArrayList<ArrayList<Individual>>(4);

Comme suggéré par Tom Hawting - Tackline, il est encore mieux de faire:

List<List<Individual>> group = new ArrayList<List<Individual>>(4);

Comme les autres l'ont mentionné, il est probablement préférable d'utiliser une autre liste pour stocker l'ArrayList, mais si vous devez utiliser un tableau:

ArrayList<Individual>[] group = (ArrayList<Individual>[])new ArrayList[4];

Cela marche:

ArrayList<String>[] group = new ArrayList[4];

Vous pouvez créer une classe étendant ArrayList

class IndividualList extends ArrayList<Individual> {

}

puis créez le tableau

IndividualList[] group = new IndividualList[10];

Je ne comprends pas du tout, pourquoi tout le monde suggère le type générique sur le tableau en particulier pour cette question.

Et si mon besoin est d'indexer ndifférents arraylists.

Avec la déclaration, List<List<Integer>>je dois créer des n ArrayList<Integer>objets manuellement ou mettre une boucle for pour créer des nlistes ou d'une autre manière, de quelque manière que ce soit, il sera toujours de mon devoir de créer des nlistes.

Est - il pas grand si nous déclarons par coulée comme List<Integer>[] = (List<Integer>[]) new List<?>[somenumber]. Je le vois comme un bon design où il n'est pas nécessaire de créer tous les objets d'indexation (arraylists) par lui-même

Quelqu'un peut-il m'éclairer pourquoi cette (matrice) sera une mauvaise conception et quels sont ses inconvénients?

Vous pouvez créer un tableau de ArrayList

List<Integer>[] outer = new List[number];
for (int i = 0; i < number; i++) {
    outer[i] = new ArrayList<>();
}

Cela sera utile dans des scénarios comme celui-ci. Vous connaissez la taille de celle extérieure. Mais la taille des intérieurs varie. Ici, vous pouvez créer un tableau de longueur fixe contenant des listes Array de taille variable. J'espère que cela vous sera utile.

En Java 8 et au-dessus, vous pouvez le faire d'une bien meilleure manière.

List<Integer>[] outer = new List[number];
Arrays.setAll(outer, element -> new ArrayList<>());

Encore mieux en utilisant la référence de méthode

List<Integer>[] outer = new List[10];
Arrays.setAll(outer,  ArrayList :: new);

Cela fonctionne, tableau de ArrayList. Essayez-le pour comprendre comment cela fonctionne.

import java.util.*;

public class ArrayOfArrayList {
    public static void main(String[] args) {

        // Put the length of the array you need
        ArrayList<String>[] group = new ArrayList[15];
        for (int x = 0; x < group.length; x++) {
            group[x] = new ArrayList<>();
        }

        //Add some thing to first array
        group[0].add("Some");
        group[0].add("Code");

        //Add some thing to Secondarray
        group[1].add("In here");

        //Try to output 'em
        System.out.println(group[0]);
        System.out.println(group[1]);
    }
}

Crédits à Kelvincer pour certains codes.

Le problème avec cette situation est qu'en utilisant une arraylist, vous obtenez une complexité temporelle de o (n) pour l'ajout à une position spécifique. Si vous utilisez un tableau, vous créez un emplacement mémoire en déclarant votre tableau donc il est constant

Vous ne pouvez pas créer de tableau de type générique. Créer une liste de ArrayLists:

 List<ArrayList<Individual>> group = new ArrayList<ArrayList<Individual>>();

ou si vous avez VRAIMENT besoin d'un tableau (ATTENTION: mauvaise conception!):

 ArrayList[] group = new ArrayList[4];

1. Création et initialisation

   Object[] yourArray = new Object[ARRAY_LENGTH];

2. Accès en écriture

   yourArray[i]= someArrayList;

   pour accéder aux éléments de la ArrayList interne:

   ((ArrayList<YourType>) yourArray[i]).add(elementOfYourType); //or other method

3. Accès en lecture

   pour lire l'élément i du tableau en tant qu'ArrayList, utilisez la conversion de type:

   someElement= (ArrayList<YourType>) yourArray[i];

   pour l'élément de tableau i: pour lire l'élément ArrayList à l'index j

   arrayListElement= ((ArrayList<YourType>) yourArray[i]).get(j);

List [] listArr = new ArrayList [4];

La ligne ci-dessus donne un avertissement, mais cela fonctionne (c'est-à-dire qu'il crée un tableau de ArrayList)

Pour déclarer statiquement un tableau de ArrayLists pour, par exemple, des positions de sprite sous forme de points:

ArrayList<Point>[] positionList = new ArrayList[2];

public Main(---) {
    positionList[0] = new ArrayList<Point>(); // Important, or you will get a NullPointerException at runtime
    positionList[1] = new ArrayList<Point>();
}

dynamiquement:

ArrayList<Point>[] positionList;
int numberOfLists;

public Main(---) {
    numberOfLists = 2;
    positionList = new ArrayList[numberOfLists];
    for(int i = 0; i < numberOfLists; i++) {
        positionList[i] = new ArrayList<Point>();
    }
}

Malgré les mises en garde et quelques suggestions complexes ici, j'ai trouvé qu'un tableau de ArrayLists était une solution élégante pour représenter des ArrayLists liés du même type.

ArrayList<String>[] lists = (ArrayList<String>[])new ArrayList[10]; 

Vous pouvez créer comme ça ArrayList<Individual>[] group = (ArrayList<Individual>[])new ArrayList[4];

Vous devez créer un tableau de type non générique, puis le convertir en un tableau générique.

ArrayList<Integer>[] graph = new ArrayList[numCourses] Ça marche.

Je trouve cela plus facile à utiliser ...

static ArrayList<Individual> group[];
......
void initializeGroup(int size)
{
 group=new ArrayList[size];
 for(int i=0;i<size;i++)
 {
  group[i]=new ArrayList<Individual>();
 }

Tu peux le faire :

// Créer un tableau de type ArrayList

`ArrayList<Integer>[] a = new ArrayList[n];`

// Pour chaque élément du tableau, créez un ArrayList

for(int i=0; i<n; i++){ 
    a[i] = new ArrayList<Integer>();
}

ArrayList<String> al[] = new ArrayList[n+1];
for(int i = 0;i<n;i++){
   al[i] = new ArrayList<String>();
}

vous pouvez créer une liste [] et les initialiser par une boucle for. il compile sans erreur:

List<e>[] l;
for(int i = 0; i < l.length; i++){
    l[i] = new ArrayList<e>();
}

il fonctionne également avec arrayList [] l.