Crea una matrice di arrailisti

Voglio creare una matrice di arraylist come di seguito:

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

Ma non si sta compilando. Come posso fare questo?

Secondo la documentazione Oracle :

"Non è possibile creare matrici di tipi con parametri"

Invece, potresti fare:

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

Come suggerito da Tom Hawting - tackline, è ancora meglio fare:

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

Come altri hanno già detto, è probabilmente meglio usare un altro elenco per archiviare ArrayList, ma se è necessario utilizzare un array:

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

Questo funziona:

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

È possibile creare una classe che estende ArrayList

class IndividualList extends ArrayList<Individual> {

}

e quindi creare l'array

IndividualList[] group = new IndividualList[10];

Non capisco, perché tutti suggeriscono il tipo genico sull'array in particolare per questa domanda.

E se il mio bisogno fosse di indicizzare ndiversi arraylist.

Con la dichiarazione List<List<Integer>>devo creare n ArrayList<Integer>oggetti manualmente o inserire un ciclo for per creare nelenchi o in qualche altro modo, in ogni modo sarà sempre mio dovere creare nelenchi.

Non è fantastico se lo dichiariamo attraverso il casting come List<Integer>[] = (List<Integer>[]) new List<?>[somenumber]. Lo vedo come un buon design in cui non è necessario creare da solo tutti gli oggetti di indicizzazione (array)

Qualcuno può illuminarmi perché questo (arrayform) sarà un cattivo design e quali sono i suoi svantaggi?

È possibile creare Array of ArrayList

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

Questo sarà utile in scenari come questo. Conosci le dimensioni di quello esterno. Ma le dimensioni di quelle interne variano. Qui è possibile creare un array di lunghezza fissa che contiene elenchi di array di dimensioni variabili. Spero che questo possa esserti utile.

In Java 8 e versioni successive puoi farlo in un modo molto migliore.

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

Ancora meglio usando il metodo di riferimento

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

Questo funziona, array di ArrayList. Provalo per capire come funziona.

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]);
    }
}

Crediti a Kelvincer per alcuni dei codici.

Il problema con questa situazione è che usando un arraylist si ottiene una complessità temporale di o (n) per l'aggiunta in una posizione specifica. Se si utilizza un array, si crea un percorso di memoria dichiarando l'array, quindi è costante

Non è possibile creare array di tipo generico. Crea un elenco di array:

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

o se hai davvero bisogno dell'array (ATTENZIONE: cattiva progettazione!):

 ArrayList[] group = new ArrayList[4];

1. Creazione e inizializzazione

   Object[] yourArray = new Object[ARRAY_LENGTH];

2. Accesso in scrittura

   yourArray[i]= someArrayList;

   per accedere agli elementi dell'arrayList interno:

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

3. Accesso in lettura

   per leggere l'elemento array i come ArrayList usa il tipo casting:

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

   per elemento array i: per leggere l'elemento ArrayList all'indice j

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

List [] listArr = new ArrayList [4];

La riga sopra avvisa, ma funziona (ovvero crea Array of ArrayList)

Per dichiarare staticamente un array di ArrayList per, diciamo, scrivere posizioni come Punti:

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>();
}

in modo dinamico:

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>();
    }
}

Nonostante le precauzioni e alcuni suggerimenti complessi qui, ho trovato una serie di ArrayList come una soluzione elegante per rappresentare ArrayList correlate dello stesso tipo.

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

Puoi creare così ArrayList<Individual>[] group = (ArrayList<Individual>[])new ArrayList[4];

Devi creare un array di tipo non generico e quindi inserirlo in uno generico.

ArrayList<Integer>[] graph = new ArrayList[numCourses] Funziona.

Lo trovo più facile da usare ...

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

Puoi farlo :

// Crea una matrice di tipo ArrayList

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

// Per ogni elemento dell'array crea 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>();
}

puoi creare un Elenco [] e inizializzarlo con il ciclo. si compila senza errori:

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

funziona anche con arrayList [] l.