Erstellen Sie ein Array von Arraylisten

Ich möchte eine Reihe von Arraylisten wie folgt erstellen:

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

Aber es wird nicht kompiliert. Wie kann ich das machen?

Gemäß Oracle-Dokumentation :

"Sie können keine Arrays parametrisierter Typen erstellen"

Stattdessen könnten Sie Folgendes tun:

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

Wie von Tom Hawting - Tackline vorgeschlagen, ist es noch besser:

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

Wie die anderen bereits erwähnt haben, ist es wahrscheinlich besser, eine andere Liste zum Speichern der ArrayList zu verwenden, aber wenn Sie ein Array verwenden müssen:

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

Das funktioniert:

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

Sie können eine Klasse erstellen, die ArrayList erweitert

class IndividualList extends ArrayList<Individual> {

}

und erstellen Sie dann das Array

IndividualList[] group = new IndividualList[10];

Ich verstehe es überhaupt nicht, warum jeder speziell für diese Frage den Genric-Typ über dem Array vorschlägt.

Was ist, wenn ich nverschiedene Arraylisten indizieren muss ?

Wenn List<List<Integer>>ich deklariere, dass ich n ArrayList<Integer>Objekte manuell erstellen oder eine for-Schleife einfügen muss, um nListen oder auf andere Weise zu erstellen , ist es immer meine Pflicht, nListen zu erstellen .

Ist es nicht toll, wenn wir es durch Casting als deklarieren? List<Integer>[] = (List<Integer>[]) new List<?>[somenumber] . Ich sehe es als ein gutes Design, bei dem man nicht alle Indizierungsobjekte (Arraylisten) selbst erstellen muss

Kann mich jemand aufklären, warum dies (Arrayform) ein schlechtes Design sein wird und was seine Nachteile sind?

Sie können ein Array von ArrayList erstellen

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

Dies ist in solchen Szenarien hilfreich. Sie kennen die Größe des äußeren. Aber die Größe der inneren variiert. Hier können Sie ein Array mit fester Länge erstellen, das größenvariable Array-Listen enthält. Hoffe das wird hilfreich für dich sein.

In Java 8 und höher können Sie dies viel besser tun.

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

Noch besser mit Methodenreferenz

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

Dies funktioniert, Array von ArrayList. Versuchen Sie es zu verstehen, wie es funktioniert.

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

Dank an Kelvincer für einige Codes.

Das Problem in dieser Situation besteht darin, dass Sie bei Verwendung einer Arrayliste eine Zeitkomplexität von o (n) für das Hinzufügen an einer bestimmten Position erhalten. Wenn Sie ein Array verwenden, erstellen Sie einen Speicherort, indem Sie Ihr Array deklarieren. Daher ist es konstant

Sie können kein Array vom generischen Typ erstellen. Liste der ArrayLists erstellen:

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

oder wenn Sie WIRKLICH ein Array benötigen (WARNUNG: schlechtes Design!):

 ArrayList[] group = new ArrayList[4];

1. Erstellung und Initialisierung

   Object[] yourArray = new Object[ARRAY_LENGTH];

2. Schreibzugriff

   yourArray[i]= someArrayList;

   So greifen Sie auf Elemente der internen ArrayList zu:

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

3. Lesezugriff

   Um das Array-Element i als ArrayList zu lesen, verwenden Sie den Typ Casting:

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

   für Array-Element i: Lesen des ArrayList-Elements am Index j

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

List [] listArr = new ArrayList [4];

Die obige Zeile gibt eine Warnung aus, funktioniert aber (dh es wird ein Array von ArrayList erstellt).

So deklarieren Sie ein Array von ArrayLists statisch für beispielsweise Sprite-Positionen als Punkte:

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

dynamisch:

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

Trotz der Vorsichtsmaßnahmen und einiger komplexer Vorschläge habe ich festgestellt, dass ein Array von ArrayLists eine elegante Lösung für die Darstellung verwandter ArrayLists desselben Typs darstellt.

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

Sie können so erstellen ArrayList<Individual>[] group = (ArrayList<Individual>[])new ArrayList[4];

Sie müssen ein Array vom nicht generischen Typ erstellen und es dann in ein generisches umwandeln.

ArrayList<Integer>[] graph = new ArrayList[numCourses] Es klappt.

Ich finde das einfacher zu bedienen ...

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

Du kannst das :

// Ein Array vom Typ ArrayList erstellen

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

// Für jedes Element im Array eine ArrayList erstellen

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

Sie können eine Liste [] erstellen und mit der for-Schleife initialisieren. es kompiliert ohne Fehler:

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

es funktioniert auch mit arrayList [] l.