Criar uma matriz de listas de matrizes

Eu estou querendo criar uma matriz de arraylist como abaixo:

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

Mas não está compilando. Como posso fazer isso?

Conforme a documentação da Oracle :

"Você não pode criar matrizes de tipos parametrizados"

Em vez disso, você pode fazer:

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

Como sugerido por Tom Hawting - tackline, é ainda melhor fazer:

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

Como os outros mencionaram, provavelmente é melhor usar outra lista para armazenar o ArrayList, mas se você precisar usar um array:

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

Isso funciona:

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

Você pode criar uma classe estendendo ArrayList

class IndividualList extends ArrayList<Individual> {

}

e depois crie a matriz

IndividualList[] group = new IndividualList[10];

Eu não entendo totalmente, por que todo mundo está sugerindo o tipo genérico sobre a matriz, particularmente para esta pergunta.

E se minha necessidade for indexar ndiferentes listas de matrizes.

Com a declaração List<List<Integer>>, preciso criar n ArrayList<Integer>objetos manualmente ou colocar um loop for para criar nlistas ou de alguma outra maneira, de qualquer forma, sempre será meu dever criar nlistas.

Não é ótimo se a declararmos através do casting como List<Integer>[] = (List<Integer>[]) new List<?>[somenumber]. Eu vejo isso como um bom design, onde não é necessário criar todo o objeto de indexação (listas de matriz) sozinho

Alguém pode me esclarecer por que esse (arrayform) será um design ruim e quais são suas desvantagens?

Você pode criar Array of ArrayList

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

Isso será útil em cenários como este. Você sabe o tamanho do exterior. Mas o tamanho dos interiores varia. Aqui você pode criar uma matriz de comprimento fixo que contém listas de Matrizes que variam de tamanho. Espero que isso seja útil para você.

No Java 8 e acima, você pode fazer isso de uma maneira muito melhor.

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

Ainda melhor usando a referência de método

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

Isso funciona, matriz de ArrayList. Tente entender como funciona.

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éditos ao Kelvincer por alguns códigos.

O problema com esta situação é que, usando uma lista de matrizes, você obtém uma complexidade temporal de o (n) para adicionar em uma posição específica. Se você usa uma matriz, cria um local de memória declarando sua matriz, portanto é constante

Você não pode criar uma matriz do tipo genérico. Crie uma lista de ArrayLists:

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

ou se você REALMENTE precisar de matriz (AVISO: design incorreto!):

 ArrayList[] group = new ArrayList[4];

1. Criação e inicialização

   Object[] yourArray = new Object[ARRAY_LENGTH];

2. Acesso de gravação

   yourArray[i]= someArrayList;

   para acessar elementos de ArrayList interno:

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

3. Acesso de leitura

   para ler o elemento da matriz i como um ArrayList, use a conversão de tipo:

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

   para o elemento da matriz i: ler o elemento ArrayList no índice j

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

List [] listArr = new ArrayList [4];

A linha acima dá aviso, mas funciona (ou seja, cria Array of ArrayList)

Para declarar estaticamente uma matriz de ArrayLists para, digamos, posições de sprite como Pontos:

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

dinamicamente:

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

Apesar dos cuidados e de algumas sugestões complexas aqui, achei uma matriz de ArrayLists uma solução elegante para representar ArrayLists relacionadas do mesmo tipo.

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

Você pode criar assim ArrayList<Individual>[] group = (ArrayList<Individual>[])new ArrayList[4];

Você precisa criar uma matriz de tipo não genérico e depois convertê-la em uma genérica.

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

Acho isso mais fácil de usar ...

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

Você consegue fazer isso :

// Crie uma matriz do tipo ArrayList

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

// Para cada elemento da matriz, crie um 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>();
}

você pode criar uma lista [] e inicializá-los pelo loop for. compila sem erros:

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

ele funciona com arrayList [] l também.