Crear una matriz de listas de matrices

Quiero crear una matriz de arraylist como a continuación:

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

Pero no está compilando. ¿Cómo puedo hacer esto?

Según la documentación de Oracle :

"No puede crear matrices de tipos parametrizados"

En cambio, podrías hacer:

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

Según lo sugerido por Tom Hawting - tackline, es aún mejor hacer:

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

Como los otros han mencionado, probablemente sea mejor usar otra lista para almacenar ArrayList, pero si tiene que usar una matriz:

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

Esto funciona:

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

Puede crear una clase que extienda ArrayList

class IndividualList extends ArrayList<Individual> {

}

y luego crea la matriz

IndividualList[] group = new IndividualList[10];

No lo entiendo totalmente, por qué todo el mundo sugiere el tipo genérico sobre la matriz, especialmente para esta pregunta.

¿Qué pasa si mi necesidad es indexar ndiferentes listas de matrices?

Con la declaración List<List<Integer>>, necesito crear n ArrayList<Integer>objetos manualmente o poner un bucle for para crear nlistas o de alguna otra manera, de cualquier manera siempre será mi deber crear nlistas.

¿No es genial si lo declaramos a través del casting como List<Integer>[] = (List<Integer>[]) new List<?>[somenumber]. Lo veo como un buen diseño donde uno no tiene que crear todos los objetos de indexación (listas de matriz) por sí mismo

¿Alguien puede aclararme por qué esta (forma de matriz) será un mal diseño y cuáles son sus desventajas?

Puedes crear Array of ArrayList

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

Esto será útil en escenarios como este. Sabes el tamaño del exterior. Pero el tamaño de los interiores varía. Aquí puede crear una matriz de longitud fija que contenga listas de matrices de tamaño variable. Espero que esto sea útil para ti.

En Java 8 y superior puedes hacerlo de una manera mucho mejor.

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

Aún mejor usando la referencia del método

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

Esto funciona, matriz de ArrayList. Pruébalo para entender cómo 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 a Kelvincer por algunos de los códigos.

El problema con esta situación es mediante el uso de una lista de matrices que obtiene una complejidad de tiempo de o (n) para agregar en una posición específica. Si usa una matriz, crea una ubicación de memoria declarando su matriz, por lo tanto, es constante

No puede crear una matriz de tipo genérico. Crear lista de listas de matrices:

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

o si REALMENTE necesita una matriz (ADVERTENCIA: ¡mal diseño!):

 ArrayList[] group = new ArrayList[4];

1. Creación e inicialización.

   Object[] yourArray = new Object[ARRAY_LENGTH];

2. Acceso de escritura

   yourArray[i]= someArrayList;

   para acceder a elementos de ArrayList interno:

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

3. Acceso de lectura

   para leer el elemento de matriz i como ArrayList use el tipo de conversión:

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

   para el elemento de matriz i: para leer el elemento ArrayList en el índice j

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

List [] listArr = new ArrayList [4];

La línea anterior da una advertencia, pero funciona (es decir, crea Array of ArrayList)

Para declarar una matriz de ArrayLists estáticamente para, por ejemplo, posiciones de sprites como Puntos:

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

A pesar de las precauciones y algunas sugerencias complejas aquí, he encontrado que un conjunto de ArrayLists es una solución elegante para representar ArrayLists relacionadas del mismo tipo.

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

Puedes crear así ArrayList<Individual>[] group = (ArrayList<Individual>[])new ArrayList[4];

Debe crear una matriz de tipo no genérico y luego convertirlo en uno genérico.

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

Me parece más 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>();
 }

Puedes hacerlo :

// Crear una matriz de tipo ArrayList

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

// Para cada elemento en la matriz, haga una 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>();
}

puede crear una Lista [] e inicializarlos para for loop. se compila sin errores:

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

funciona con arrayList [] l también.