Java program to remove duplicate characters from a string

Many times we need to remove the duplicate characters from a string in Java. We can remove the duplicate characters from a string by using the simple for loop, sorting, hashing, and IndexOf() method. So, there can be more than one way for removing duplicates.

By using the simple for loop.
By using the sorting algorithm.
By using the hashing.
By using the indexOf() method.

Java program to remove duplicate characters from a string

Let's understand each method of removing duplicate characters from a string.

1) By using for loop

It is the simplest way of removing duplicates characters from a string. We should have to use the following steps for removing duplicates.

In the first step, we have to convert the string into a character array.
Calculate the size of the array.
Call removeDuplicates() method by passing the character array and the length.
Traverse all the characters present in the character array.
Check whether the str[i] is present before or not. If it is not present before, add it to the result.

Let's implement the above theory's code to understand how this method works to remove duplicates from a string.

RemoveDuplicatesExample1.java

//Import packages 
import java.util.*; 

//Creating RemoveDuplicatesExample1 class
class RemoveDuplicatesExample1  
{ 
	//Creating removeDuplicates() method to remove duplicates from array
    static void removeDuplicate(char str[], int length) 
    { 
        //Creating index variable to use it as index in the modified string 
        int index = 0; 
  
        // Traversing character array
        for (int i = 0; i < length; i++) 
        { 
			
            // Check whether str[i] is present before or not 
            int j; 
            for (j = 0; j < i; j++)  
            { 
                if (str[i] == str[j]) 
                { 
                    break; 
                } 
            } 
  
            // If the character is not present before, add it to resulting string 
            if (j == i)  
            { 
                str[index++] = str[i]; 
            } 
        } 
        System.out.println(String.valueOf(Arrays.copyOf(str, index))); 
    } 
  
    // main() method starts
    public static void main(String[] args) 
    { 
		String info = "javaTpoint is the best learning website";
        //Converting string to character array
		char str[] = info.toCharArray();
		//Calculating length of the character array
        int len = str.length; 
		//Calling removeDuplicates() method to remove duplicate characters
        removeDuplicate(str, len); 
    } 
}

Output

2) By using sorting

Another way of removing duplicate characters is by using the sorting algorithm. It is faster than the first method. In order to remove the duplicate characters from the string, we have to follow the following steps:

First, we need to sort the elements.
After that, we remove duplicates by comparing the current character with the previous character in a loop.
In the end, we need to remove the extra characters at the end of the resultant string.

The method doesn't maintain the original order of the input string. After removing the duplicates, the order can be changed from the original order.

Let's implemet the above steps in a Java program.

RemoveDuplicatesExample2.java

//Import packages 
import java.util.Arrays; 
//Create RemoveDuplicatesExample2 class 
public class RemoveDuplicatesExample2  
{ 
    //Create removeDuplicates() method to remove duplicate characters from sorted array
    static void removeDuplicates(String str) 
    { 
		//index to track the location of next character(Input string)
		int index1 = 1;        
		
		// index to track the location of next character(Resultant string)
        int index2 = 1;
          
        // Convert string to character array for further manipulation
        char arr[] = str.toCharArray(); 
          
        //Check whether the character is present before it or not. If it is not present before, add it to the result string
        while (index1 != arr.length) 
        { 
            if(arr[index1] != arr[index1-1]) 
            { 
                arr[index2] = arr[index1]; 
                index2++; 
            } 
            index1++; 
            
        } 
      
        str = new String(arr);
        System.out.println(str.substring(0, index2)); 
    } 
       
    //Create sortString() method to sort string
    static String sortString(String str) 
    { 
       // Convert string to character array to sort it 
       char temp[] = str.toCharArray(); 
	   
	   //sort array using array's sort () method
       Arrays.sort(temp); 
	   
	   //Generate a new string from character array 
       str = new String(temp); 
         
       // Return the sorted string
       return str; 
    } 
       
    // main() method start
    public static void main(String[] args) 
    { 
		//create string variable with a default string 
        String str = "javaTpoint is the best learning site"; 
        
		//Call sortString() method to sort the strign characters
		String newString = sortString(str);
		System.out.println(newString);
		
		//Call removeDuplicates() method to remove duplicates from the sorted string
		removeDuplicates(newString);
    } 
}

Output

3) By using hashing

Another way of removing duplicate characters from a string is hashing. By using hashing, we can do that easily. We will use the following steps to remove duplicates by using hashing:

In the main() method, we will create a string from which we have to remove duplicate characters.
We will call the removeDuplicates() method and passed the string from which we want to remove duplicates.
In the removeDuplicates() method, we will create the LinkedHashSet of character type. LinkedHashSet contains a distinct element. So, if we add each character of a string into LinkedHashSet, all duplicate characters are removed.
In the end, we print all the characters of the LinkedHashSet.

Note: It maintains the insertion order of the characters in the string.

Let's implement the above theory's code to understand how actually hashing is used to remove duplicate characters in a string.

RemoveDuplicatesExample3.java

//Import classes and packages
import Java.util.*; 

//Create RemoveDuplicatesExample3 for removing duplicate characters
class RemoveDuplicatesExample3 
{ 
    //Create removeDuplicates() method for removing duplicates using LinkedHashSet
    static void removeDuplicates(String str) 
    {	
		//Create LinkedHashSet of type character 
        LinkedHashSet<Character> set = new LinkedHashSet<>(); 
        //Add each character of the string into LinkedHashSet 
		for(int i=0;i<str.length();i++) 
            set.add(str.charAt(i)); 
          
        // print the string after removing duplicate characters 
        for(Character ch : set) 
            System.out.print(ch); 
    } 
      
    //main() method start
    public static void main(String args[]) 
    { 
		//Create string variable with default value
        String str = "javaTpoint is the best learning website"; 
        //removeDuplicates() method by passing the string as an argument 
		removeDuplicates(str); 
    } 
}

Output

4) By using indexOf() method

The last way of removing duplicate characters from a string is by using the indexOf() method. In this method, we will work on the index position of the character. In order to remove the duplicate character from the string, we will use the following steps:

In the main() method, we will create a string from which we have to remove duplicate characters.
We will call the removeDuplicates() method and passed the string from which we need to remove duplicate characters.
In the removeDuplicates() method, we will create a new empty string and calculate the original string's length.
We will traverse the string using the loop and check for repeating characters using the indexOf() method.
The indexOf() method returns -1 when the element is not present. So, when the string doesn't contain that character, we will add it to the empty string.

Note: It maintains the insertion order of the characters in which they are added in the string.

Let's implement the above steps in a Java program.

RemoveDuplicatesExample4.java

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

//Create RemoveDuplicatesExample4 class to remove duplicates from the string 
class RemoveDuplicatesExample4 { 
      
    // Create removeDuplicates() method to remove duplicates using indexOf() method
    public static void removeDuplicates(String str) 
    { 
		//Create an empty string 
        String newstr = new String(); 
        
		//calculate length of the original string
		int length = str.length(); 
          
        // Traverse the string and check for the repeated characters 
        for (int i = 0; i < length; i++)  
        { 
            // store the character available at ith index in the string
            char charAtPosition = str.charAt(i); 
              
            // check the index of the charAtPosition. If the indexOf() method returns true add it to the resuting string
            if (newstr.indexOf(charAtPosition) < 0) 
            { 
                newstr += charAtPosition; 
            } 
        } 
        //Print string after removing duplicate characters 
        System.out.println(newstr);
    } 
  
    // main() method start
    public static void main(String[] args) 
    { 
        // Create a string variable with default value 
        String str = "JavaTpoint is the best learning website"; 
        //call removeDuplicates() method for removing duplicate characters  
        removeDuplicates(str); 
    } 
}

Output

All the above-discussed methods are used for removing duplicate characters from the string. All the methods are easy to understand, and we can use any one of them to remove duplicates characters.

Next TopicJUnit test case example in Java

← prev next →