Crea una matrice di arraylists

Sto volendo creare una matrice di arraylist come di seguito:

ArrayList[] group = new ArrayList()[4] 

Ma non sta compilando. Come posso fare questo?

Come da documentazione Oracle :

“Non puoi creare matrici di tipi parametrizzati”

Invece, potresti fare:

 ArrayList> group = new ArrayList>(4); 

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

 List> group = new ArrayList>(4); 

Come hanno già detto gli altri è probabilmente meglio usare un altro elenco per memorizzare ArrayList ma se si deve usare un array:

 ArrayList[] group = (ArrayList[])new ArrayList[4]; 

Questo funziona:

 ArrayList[] group = new ArrayList[4]; 

È ansible creare una class estendendo ArrayList

 class IndividualList extends ArrayList { } 

e quindi creare la matrice

 IndividualList[] group = new IndividualList[10]; 

Non riesco assolutamente a capirlo, perché tutti suggeriscono il tipo genrico sull’array in particolare per questa domanda.

Cosa succede se il mio bisogno è indicizzare n diversi arraylists.

Con la dichiarazione List> ho bisogno di creare n oggetti ArrayList manualmente o mettere un ciclo for per creare n liste o qualche altro modo, in qualsiasi modo sarà sempre mio dovere creare n liste.

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

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

È ansible creare Array of ArrayList

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

Questo sarà utile in scenari come questo. Conosci la dimensione di quella esterna. Ma la dimensione di quelle interne varia. Qui è ansible creare una serie di lunghezza fissa che contiene elenchi di array di dimensioni variabili. Spero che questo ti sia d’aiuto.

Il problema con questa situazione è utilizzando un arraylist si ottiene una complessità temporale di o (n) per l’aggiunta in una posizione specifica. Se si utilizza una matrice, si crea una posizione di memoria dichiarando la matrice in modo che sia costante

Non puoi creare array di tipo generico. Crea un elenco di liste di array:

  List> group = new ArrayList>(); 

o se hai VERAMENTE bisogno di matrice (ATTENZIONE: ctriggers progettazione!):

  ArrayList[] group = new ArrayList[4]; 

Funziona, array di ArrayList. Fai un tentativo 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[] 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.

  1. Creazione e inizializzazione

     Object[] yourArray = new Object[ARRAY_LENGTH]; 
  2. Accesso in scrittura

     yourArray[i]= someArrayList; 

    per accedere agli elementi di ArrayList interno:

     ((ArrayList) yourArray[i]).add(elementOfYourType); //or other method 
  3. Leggi l’accesso

    per leggere l’elemento dell’array i come ArrayList utilizzare cast di tipo:

     someElement= (ArrayList) yourArray[i]; 

    per l’elemento di matrice i: per leggere l’elemento ArrayList all’indice j

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

Per dichiarare staticamente una matrice di liste array per, diciamo, posizioni sprite come punti:

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

in modo dinamico:

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

Nonostante le precauzioni e alcuni suggerimenti complessi qui, ho trovato una matrice di ArrayList per essere una soluzione elegante per rappresentare ArrayList correlati dello stesso tipo.

Puoi creare come questo ArrayList[] group = (ArrayList[])new ArrayList[4];

Devi creare una matrice di tipo non generico e quindi lanciarla in una generica.

Trovo che sia più facile da usare …

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

Puoi farlo :

// Crea una matrice di tipo ArrayList

 `ArrayList[] a = new ArrayList[n];` 

// Per ciascun elemento nella matrice, crea una lista array

 for(int i=0; i(); } 
 ArrayList[] lists = (ArrayList[])new ArrayList[10]; 

List [] listArr = new ArrayList [4];

La linea sopra avvisa, ma funziona (cioè crea Array of ArrayList)

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

è ansible creare un elenco [] e inizializzarli per ciclo. compila senza errori:

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

funziona anche con arrayList [].