Utwórz tablicę tablic

Chcę utworzyć tablicę arraylist, jak poniżej:

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

Ale to się nie kompiluje. W jaki sposób mogę to zrobić?

Zgodnie z dokumentacją Oracle :

„Nie można tworzyć tablic typów sparametryzowanych”

Zamiast tego możesz zrobić:

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

Zgodnie z sugestią Toma Hawtinga - tackline jeszcze lepiej:

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

Jak wspomnieli inni, prawdopodobnie lepiej jest użyć innej listy do przechowywania tablicy ArrayList, ale jeśli musisz użyć tablicy:

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

To działa:

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

Możesz utworzyć klasę rozszerzającą ArrayList

class IndividualList extends ArrayList<Individual> {

}

a następnie utwórz tablicę

IndividualList[] group = new IndividualList[10];

Całkowicie tego nie rozumiem, dlaczego wszyscy sugerują typ genetyki w tablicy, szczególnie w tym pytaniu.

A jeśli potrzebuję indeksowania nróżnych arraylistów.

Deklarując List<List<Integer>>, muszę tworzyć n ArrayList<Integer>obiekty ręcznie lub ustawiać pętlę for do tworzenia nlist lub w inny sposób, w jakikolwiek sposób zawsze moim obowiązkiem będzie tworzenie nlist.

Czy to nie wspaniałe, jeśli zadeklarujemy to przez odlewanie jako List<Integer>[] = (List<Integer>[]) new List<?>[somenumber]. Uważam to za dobry projekt, w którym nie trzeba samodzielnie tworzyć wszystkich obiektów indeksujących (arraylistów)

Czy ktoś może mnie oświecić, dlaczego ten (arrayform) będzie złym projektem i jakie są jego wady?

Możesz utworzyć Array of ArrayList

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

Będzie to pomocne w takich sytuacjach. Znasz rozmiar zewnętrznej. Ale rozmiar wewnętrznych jest różny. Tutaj możesz utworzyć tablicę o stałej długości, która zawiera listy tablic o różnych rozmiarach. Mam nadzieję, że będzie to pomocne.

W Javie 8 i nowszych możesz to zrobić o wiele lepiej.

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

Jeszcze lepiej przy użyciu odniesienia do metody

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

To działa, tablica ArrayList. Spróbuj zrozumieć, jak to działa.

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

Kredyty dla Kelvincera za niektóre kody.

Problem z tą sytuacją polega na tym, że używając tablicy arraylist, uzyskujesz złożoność czasową o (n) dla dodawania w określonej pozycji. Jeśli używasz tablicy, tworzysz lokalizację pamięci, deklarując swoją tablicę, dlatego jest stała

Nie możesz utworzyć tablicy typu ogólnego. Utwórz listę ArrayLists:

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

lub jeśli NAPRAWDĘ potrzebujesz tablicy (UWAGA: zły projekt!):

 ArrayList[] group = new ArrayList[4];

1. Tworzenie i inicjalizacja

   Object[] yourArray = new Object[ARRAY_LENGTH];

2. Dostęp do zapisu

   yourArray[i]= someArrayList;

   aby uzyskać dostęp do elementów wewnętrznej ArrayList:

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

3. Dostęp do odczytu

   aby odczytać element tablicy i jako ArrayList użyj rzutowania typu:

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

   dla elementu tablicy i: do odczytu elementu ArrayList pod indeksem j

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

List [] listArr = new ArrayList [4];

Powyższa linia ostrzega, ale działa (tj. Tworzy Array of ArrayList)

Aby zadeklarować tablicę ArrayLists statycznie dla, powiedzmy, pozycji duszków jako punktów:

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

dynamicznie:

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

Pomimo ostrzeżeń i pewnych złożonych sugestii, stwierdziłem, że tablica ArrayLists jest eleganckim rozwiązaniem do reprezentowania powiązanych ArrayLists tego samego typu.

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

Możesz tworzyć w ten sposób ArrayList<Individual>[] group = (ArrayList<Individual>[])new ArrayList[4];

Musisz utworzyć tablicę typu nieogólnego, a następnie przerzucić ją na typową.

ArrayList<Integer>[] graph = new ArrayList[numCourses] To działa.

Uważam, że jest to łatwiejsze w użyciu ...

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

Możesz to zrobić :

// Utwórz tablicę typu ArrayList

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

// Dla każdego elementu tablicy stwórz 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>();
}

możesz utworzyć List [] i zainicjować je pętlą for. kompiluje się bez błędów:

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

działa również z arrayList [] l.