Colecciones multidimensionales en Java

En Java, tenemos un marco de colección que proporciona funcionalidad para almacenar un grupo de objetos. Esto se llama ArrayList unidimensional donde solo podemos tener un elemento en una fila. Geek, pero qué pasa si queremos hacer un ArrayList multidimensional, para esta funcionalidad tenemos colecciones multidimensionales (o colecciones anidadas) en Java. 

Colecciones multidimensionales (o colecciones anidadas) es una colección de grupos de objetos donde cada grupo puede tener cualquier número de objetos dinámicamente. Por lo tanto, aquí podemos almacenar cualquier número de elementos en un grupo cuando queramos.

Ilustración:

Single dimensional ArrayList :
  [121, 432, 12, 56, 456, 3, 1023]
  [Apple, Orange, Pear, Mango]

Sintaxis:  

ArrayList <Object> x = new ArrayList <Object>();

Necesidad de colecciones multidimensionales

A diferencia de los arreglos, no estamos sujetos al tamaño de ninguna fila en las colecciones multidimensionales. Por lo tanto, si queremos usar una arquitectura multidimensional en la que podamos crear cualquier cantidad de objetos dinámicamente en una fila, entonces debemos optar por colecciones multidimensionales en Java.

Sintaxis : Colecciones multidimensionales

ArrayList<ArrayList<Object>> a = new ArrayList<ArrayList<Object>>();

Ilustración: 

Multidimensional ArrayList: [[3, 4], [12, 13, 14, 15], [22, 23, 24], [33]]

 Veamos rápidamente el método add() para ArrayList multidimensional, que es el siguiente:

• boolean add( ArrayList<Object> e) : Se utiliza para insertar elementos en la colección especificada.
• void add( int index, ArrayList<Object> e) : Se utiliza para insertar los elementos en la posición especificada en una Colección.

Ejemplo 1:

// Java Program to Illustrate Multidimensional ArrayList
 
// Importing required classes
import java.util.*;
 
// Main class
// MultidimensionalArrayList
class GFG {
 
    // Method 1
    // To create and return 2D ArrayList
    static List create2DArrayList()
    {
 
        // Creating a 2D ArrayList of Integer type
        ArrayList<ArrayList<Integer> > x
            = new ArrayList<ArrayList<Integer> >();
 
        // One space allocated for R0
        x.add(new ArrayList<Integer>());
 
        // Adding 3 to R0 created above x(R0, C0)
        x.get(0).add(0, 3);
 
        // Creating R1 and adding values
        // Note: Another way for adding values in 2D
        // collections
        x.add(
            new ArrayList<Integer>(Arrays.asList(3, 4, 6)));
 
        // Adding 366 to x(R1, C0)
        x.get(1).add(0, 366);
 
        // Adding 576 to x(R1, C4)
        x.get(1).add(4, 576);
 
        // Now, adding values to R2
        x.add(2, new ArrayList<>(Arrays.asList(3, 84)));
 
        // Adding values to R3
        x.add(new ArrayList<Integer>(
            Arrays.asList(83, 6684, 776)));
 
        // Adding values to R4
        x.add(new ArrayList<>(Arrays.asList(8)));
 
        // Appending values to R4
        x.get(4).addAll(Arrays.asList(9, 10, 11));
 
        // Appending values to R1, but start appending from
        // C3
        x.get(1).addAll(3, Arrays.asList(22, 1000));
 
        // This method will return 2D array
        return x;
    }
 
    // Method 2
    // Main driver method
    public static void main(String args[])
    {
        // Display message prior for better readability
        System.out.println("2D ArrayList :");
 
        // Printing 2D ArrayList by calling Method 1
        System.out.println(create2DArrayList());
    }
}

2D ArrayList :
[[3], [366, 3, 4, 22, 1000, 6, 576], [3, 84], [83, 6684, 776], [8, 9, 10, 11]]

 Ahora veamos la misma implementación de LinkedHashSet multidimensional y para mostrar cómo se comporta de manera diferente. De manera similar, podemos implementar cualquier otra Colección como Colección Multidimensional como se muestra a continuación: 

Sintaxis: 

HashSet< HashSet<Object> > a = new HashSet< HashSet<Object> >(); 

Nota: la clase LinkedHashSet contiene elementos únicos y mantiene el orden de inserción. Por lo tanto, en Multidimensional LinkedHashSet, la singularidad también se mantendrá dentro de las filas.

Ejemplo 2:

// Java Program to Illustrate Multidimensional LinkedHashSet
 
// Importing required classes
import java.util.*;
 
// Main class
// Multidimensional LinkedHashSet
class GFG {
 
    // Method 1
    // To create and return 2D LinkedHashSet
    static Set create2DLinkedHashSet()
    {
        // Creating an empty 2D LinkedHashSet
        LinkedHashSet<LinkedHashSet<String> > x
            = new LinkedHashSet<LinkedHashSet<String> >();
 
        // Creating R0
        x.add(new LinkedHashSet<String>(
            Arrays.asList("Apple", "Orange")));
 
        // Creating R1, here "Coffee" will be considered as
        // only one object to maintain uniqueness
        x.add(new LinkedHashSet<String>(Arrays.asList(
            "Tea", "Coffee", "Milk", "Coffee", "Water")));
 
        // Creating R2
        x.add(new LinkedHashSet<String>(
            Arrays.asList("Tomato", "Potato", "Onion")));
 
        // Creating R3 but it will not be added as it
        // contains the same items as R2
 
        // Note: LinkedHashSet inserts only unique items
 
        x.add(new LinkedHashSet<String>(
            Arrays.asList("Tomato", "Potato", "Onion")));
 
        // Returning multidimensional LinkedHashSet
        return x;
    }
 
    // Method 2
    // Main driver method
    public static void main(String[] args)
    {
        // Display message for better readability
        System.out.println("2D LinkedHashSet :");
 
        // Printing 2D LinkedHashSet by
        // calling method 1
        System.out.println(create2DLinkedHashSet());
    }
}

2D LinkedHashSet :
[[Apple, Orange], [Tea, Coffee, Milk, Water], [Tomato, Potato, Onion]]