Skip to content
Related Articles

Related Articles

Improve Article
Multidimensional Collections in Java
  • Last Updated : 20 Jun, 2021

In Java we have Collection framework which provides functionality to store group of objects. 
Syntax : 
 

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

Examples: 
 

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

This is called as single dimensional ArrayList where we can have only one element in a row. 
But what if we want to make multidimensional ArrayList ? For this functionality we have Multidimensional Collections (or Nested Collections) in java.
What is Multidimensional Collections in java? 
Multidimensional Collections (or Nested Collections) is a collection of group of objects where each group can have any number of objects dynamically. Hence, here we can store any number of elements in a group whenever we want.
Need for Multidimensional Collections in java? 
Unlike Arrays we are not bound with the size of any row in Multidimensional collections. 
Therefore, if we want to use a Multidimensional architecture where we can create any number of objects dynamically in a row, then we should go for Multidimensional collections in Java.
 

Multidimensional_Collections_in_Java

Syntax for Multidimensional Collections : 
 



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

Examples: 
 

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

 
Add Method for Multidimensional ArrayList in Java: 
 

boolean add( ArrayList<Object> e) : It is used to insert elements in the specified collection. 
void add( int index, ArrayList<Object> e) : It is used to insert the elements at specified 
position in a Collection. 
 

Below is implementation of Multidimensional ArrayList in Java :
 

Java




/* Java program for Multidimensional ArrayList */
 
import java.util.*;
 
class MultidimensionalArrayList {
 
    /*function for creating and returning 2D ArrayList*/
    static List create2DArrayList()
    {
        /*Declaring 2D ArrayList*/
        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
       (another way for adding values in 2D collections)*/
        x.add(
            new ArrayList<Integer>(Arrays.asList(3, 4, 6)));
 
        /*Add 366 to x(R1, C0)*/
        x.get(1).add(0, 366);
 
        /*Add 576 to x(R1, C4)*/
        x.get(1).add(4, 576);
 
        /*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));
 
        return x;
    }
 
    public static void main(String args[])
    {
        System.out.println("2D ArrayList :");
 
        /*Printing 2D ArrayList*/
        System.out.println(create2DArrayList());
    }
}
Output
2D ArrayList :
[[3], [366, 3, 4, 22, 1000, 6, 576], [3, 84], [83, 6684, 776], [8, 9, 10, 11]]

Example 2: Now let’s see the implementation of Multidimensional LinkedHashSet in Java. Note: LinkedHashSet class contains unique elements & maintains insertion order. Therefore, in Multidimensional LinkedHashSet uniqueness will be maintained inside rows also.
 

Java




/* Java program for Multidimensional LinkedHashSet */
 
import java.util.*;
 
class MultidimensionalLinkedHashSet {
 
    /*function for creating and returning 2D LinkedHashSet*/
    static Set create2DLinkedHashSet()
    {
        /*Declaring 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 (LinkedHashSet
         * inserts only unique items)*/
        x.add(new LinkedHashSet<String>(
            Arrays.asList("Tomato", "Potato", "Onion")));
 
        return x;
    }
 
    public static void main(String[] args)
    {
        System.out.println("2D LinkedHashSet :");
 
        /*Printing 2D LinkedHashSet*/
        System.out.println(create2DLinkedHashSet());
    }
}
Output
2D LinkedHashSet :
[[Apple, Orange], [Tea, Coffee, Milk, Water], [Tomato, Potato, Onion]]

Similarly, we can implement any other Collection as Multidimensional Collection . 
Example : 
 

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

 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes 




My Personal Notes arrow_drop_up
Recommended Articles
Page :