Find unique elements in array Java

In Java, an array is a collection of elements of the same data type. An array doesn't restrict us from entering the same or repeated elements in it. So, many times we need to get the distinct elements from the array. In Java, there is more than one way to find unique elements from an array which are as follows:

By storing all the elements to the hashmap's key.
By using nested loop.
By using sorting.
By using hashing.

By using hashmap's key

In Java, the simplest way to get unique elements from the array is by putting all elements of the array into hashmap's key and then print the keySet(). The hashmap contains only unique keys, so it will automatically remove that duplicate element from the hashmap keySet.

Let's take an example to understand how the hashmap's key is used to get the distinct element.

UniqueElementsExample1.java

//import classes and packages
import java.util.HashMap; 

//create UniqueElementsExample1 class to get distinct element from the array
class UniqueElementsExample1 { 
	//main() method starts
    public static void main(String args[]) 
	{ 
        //create an integer array having some duplicate elements 
		int arrayWithDuplicates[] = { 10, 3, 5, 3, 9, 22, 4, 3, 1, 5, 6 };

		//create a hashmap having integer type of key-value
        HashMap<Integer,Integer> hashmap = new HashMap<Integer,Integer>(); 
		
		//use for loop to pull the elements of array to hashmap's key
        for (int j = 0; j < arrayWithDuplicates.length; j++) { 
            hashmap.put(arrayWithDuplicates[j], j); 
        } 
        // use hashmap.keySet() for printing all keys of hashmap using it's keySet() method 
        System.out.println(hashmap.keySet()); 
  
    } 
}

Output

By using nested loop

Another simple approach to getting distinct elements from the given array is by using the nested loop. The inner and outermost loop plays a very important role in this strategy. The outermost loop takes an element one by one from the leftmost side of the array. The innermost loop compares it with the right-side of this element. If it matches, we skip it else, print or store it into another array that contains the distinct element.

Let's take an example to understand how this strategy works in Java:

UniqueElementsExample2.java

//import classes and packages which are required 
import java.io.*; 

//create UniqueElementsExample1 class to get distinct element from the array  
class UniqueElementsExample2 { 
	//main() method starts
    public static void main (String[] args)  
    { 
        //create an integer array having some duplicate elements 
		int arrayWithDuplicates[] = { 10, 3, 5, 3, 9, 22, 4, 3, 1, 5, 6 };
		
        //calculate length of the arrayWithDuplicates array 
		int len = arrayWithDuplicates.length; 
		
		//create an integer array to store distinct elements 
		int[] distinctArray = new int[20];
		
		//integer variable to increment array index
		int index = 0;
		
		// outermost loop to take element one by one from the leftmost side
        for (int i = 0; i < len; i++) 
        { 
            int flag = 0;
			//innermost loop to make comparision between elemnts and skip duplicate elements
            for (int j = 0; j < i; j++){
				if (arrayWithDuplicates[i] == arrayWithDuplicates[j]){ 
					flag = 1;
					break; 
				}
			}
			//store or print the element if it is not present in the distinctArray
			if (flag == 0){ 
				distinctArray[index] = arrayWithDuplicates[i];
				index++;	//increment index value
			}
		}
		//print distinctArray 
		for(int i = 0; i < index; i++)
			System.out.print( distinctArray[i] + " "); 
	}		
    
} 

Output

By using sorting

The solution we have discussed before has O(n²) time complexity, but we have another solution that has less complexity than the previous one. We can get the distinct elements from the array by performing a sorting algorithm. This solution has O(nLogn) time complexity.

In order to get the distinct element from the array, we will first sort the array in ascending or descending order so that each element's occurrence becomes consecutive. After that, we will traverse that sorted array using the loop and skip all the consecutive repeated elements' index.

Let's take an example to understand how we can get the distinct element from the array by using the sorting algorithm.

UniqueElementsExample3.java

//import classes and packages which are required 
import java.io.*; 
import java .util.*; 

//create UniqueElementsExample1 class to get distinct element from the array  
class UniqueElementsExample3 { 
	//main() method starts
    public static void main (String[] args)  
    { 
        //create an integer array having some duplicate elements 
		int arrayWithDuplicates[] = { 10, 3, 5, 3, 9, 22, 4, 3, 1, 5, 6 };
		
        //perform sorting to sort arrayWithDuplicates
		Arrays.sort(arrayWithDuplicates);
		
		//calculate length of the sorted array
		int len = arrayWithDuplicates.length;
		
		//create an integer array to store distinct elements 
		int[] distinctArray = new int[20];
		
		//integer variable to increment array index
		int index = 0;

		
		//use for loop to traverse the arrayWithDuplicates
		for(int i = 0; i < len; i++){
			//we will skip the index until there are duplicates ahead
			 while (i < len - 1 && arrayWithDuplicates[i] == arrayWithDuplicates[i + 1]) 
                i++;
			
			//store element in the distinctArray
			distinctArray[index] = arrayWithDuplicates[i];
			index++;
		}
		
		//print distinctArray 
		for(int i = 0; i < index; i++)
			System.out.print( distinctArray[i] + " "); 
	}		
    
} 

Output

By using hashing

There is another way to get the distinct element from the array, i.e., hashing. By using the hashing, we can get a distinct element in O(n). We traverse the array from which we want to get the distinct element. We perform traversing from left to right, and in the hash table, we keep the record of the visited element.

Let's implement the code to understand how hashing is used to get the distinct element from the array.

UniqueElementsExample4.java

//import classes and packages which are required
import java.util.*; 

//create UniqueElementsExample1 class to get distinct element from the array 
class UniqueElementsExample4
{ 

    // main() method starts
    public static void main (String[] args) 
    { 
        //create an integer array having some duplicate elements 
		int arrayWithDuplicates[] = { 10, 3, 5, 3, 9, 22, 4, 3, 1, 5, 6 };
			
		//calculate length of the arrayWithDuplicates 
		int len = arrayWithDuplicates.length;

		// Creates an empty hashset to store distinct elements
        HashSet<Integer> hashset = new HashSet<>(); 
  
        // travers the arrayWithDuplicates array to store elements in the hashset
        for (int i = 0; i < len; i++) 
        { 
            // check whether the element is present in the hashset or not. If it is not present in the hashset, add in it. 
            if (!hashset.contains(arrayWithDuplicates[i])) 
            { 
                hashset.add(arrayWithDuplicates[i]); 
            } 
        } 
        //print hash set that contains distinct element
        System.out.print(hashset); 
	} 
}

Output

All the above-discussed methods are used to get the distinct elements from the array. All the methods have different time complexity to get the distinct element. All the methods play an important role in different scenarios.

Next TopicHighest precedence in Java

← prev next →