Delete duplicate strings in string array

Question

I am making a program based on string processing in Java in which I need to remove duplicate strings from a string array. In this program, the size of all strings are same.

The 'array' which is a string array contains a number of strings in which two strings resemble each other. So using the below code the duplicate string must get removed but it is not removed.

How to remove the duplicate strings?

I am using the following code.

    for(int s=0;s<array.length-1;s++)
    {
        for(int m=0;m<array.length;m++)
        {
                for(int n=0;n<array[m].length();n++)
                {   
                    if(array[s].charAt(n)==array[m].charAt(n))
                    {
                      continue;
                    }
                    else 
                break;
        } 
        if(n==array[m].length())
        {
            ArrayUtils.removeElement(array, array[s]);
        }
    }

Why don't you use a structure better suited for removing duplicate, like a HashSet for example, instead of arrays? — assylias, Apr 28 '12 at 19:38

score 44 · Accepted Answer · answered Apr 28 '12 at 19:42

44

This will work

array = new HashSet<String>(Arrays.asList(array)).toArray(new String[0]);

or just use a HashSet instead of an array.

answered Apr 28 '12 at 19:42

Garrett Hall

29,524
10
61
76

2

What is the purpose of `new String[0]`? – Stevoisiak Mar 31 '21 at 22:30
@Stevoisiak heres a link explaining the use of new String[0] https://stackoverflow.com/a/65902425/16034206 – experiment unit 1998X Jul 02 '22 at 15:54

score 8 · Answer 2 · answered May 15 '18 at 12:11

Proposed solution does not keep the order of the elements. If you use Java 8 or higher and want to maintain the order you can use streams as follows:

array = Arrays.stream(array).distinct().toArray(String[]::new);

Full example: https://www.javacodeexamples.com/java-string-array-remove-duplicates-example/849

score 2 · Answer 3 · answered Apr 28 '12 at 19:42

Set<String> set = new HashSet<String>();
Collections.addAll(set, array);

or start with

for(int s=0;s<array.length-1;s++)
{
    for(int m=s + 1;m<array.length;m++)
    {

                if(array[s] != null && array[s].equals(array[m]))
                {
                  // array = ArrayUtils.removeElement(array, array[s]); --m;??
                  array[m] = null; // Mark for deletion later on
                }
    } 
}

score 2 · Answer 4 · answered Apr 28 '12 at 19:42

2

Unless this is [homework] I would use a Set

String[] array =
Set<String> uniqueWords = new HashSet<String>(Arrays.asList(array));

answered Apr 28 '12 at 19:42

Peter Lawrey

525,659
79
751
1,130

score 2 · Answer 5 · edited Aug 21 '18 at 09:05

2

import java.util.*;
public class Stringarray {

    public static void main(String args[]){

        String[] name = {"aim","rajesh","raju","aim"};

    Set<String> myset  = new HashSet<String>();
    Collections.addAll(myset,name);

       System.out.println(myset);
    }
}

edited Aug 21 '18 at 09:05

Azzabi Haythem

2,318
7
26
32

answered Aug 21 '18 at 07:21

Thangenapally Rajesh

21
1

score 1 · Answer 6 · answered Jul 28 '20 at 16:24

1

Set data structure will do automatically the job for. Most likely option for you will be HashSet, if you care about the order of elements look at TreeSet

List<String> input = Arrays.asList(array);
Set<String> unique = new HashSet<>(input);

answered Jul 28 '20 at 16:24

Traycho Ivanov

2,887
14
24

score 0 · Answer 7 · answered Apr 28 '12 at 19:43

Why don't you use String.equals() for comparison instead of iterating through the characters in the strings manually?
Your logic is actually flawed: for array[s] == "12345" and array[m] == "123" it would claim that they are equal
moreover, in your inner loop for(int m=0;m<array.length;m++) m will also become equal to s at some point, so you will compare a string to itself

These notes assume that you need to implement the removal logic with your own code, not being allowed to use the class library. If this is not the case, as others noted, using a HashSet is the simplest approach.

score 0 · Answer 8 · answered Apr 28 '12 at 19:47

Why didn't you remove the most inner loop with in favor of String.equals(String)?

In first iteration you are comparing array[0] with array[0] which are equal, and it would be removed. Then you will compare the original array[1] with all other elements in array, and if they are equal, you are removing array[1] (not the other one).

There are some problems, if there are some duplicate Strings, you are removing the first one, which will reduce the size of the array without reducing r so, some of the Strings in the array are skipped.

I would use a data structure which forces uniqueness, such as a Set.

What will happen if you have 3 equal Strings in your array, I'm not sure what will happen.

I believe you would encounter some ArrayIndexOutOfBoundsExceptions.

score 0 · Answer 9 · answered Apr 28 '12 at 19:53

0

I think the if condition at the end should be if(n==(array[m].length()-1))

Having said that, you seem to be trying to implement what String.equals() method does in your inner most loop.

answered Apr 28 '12 at 19:53

Martin Prakash

66
4

score 0 · Answer 10 · answered Oct 25 '13 at 10:34

     String[] arr = {"w10","w20","w10","w30","w20","w40","w50","w50"};
     List<String> arrList = new ArrayList<String>();
     int cnt= 0;
       //List<String> arrList = Arrays.asList(arr);
       List<String> lenList = new ArrayList<String>();
          for(int i=0;i<arr.length;i++){
        for(int j=i+1;j<arr.length;j++){
           if(arr[i].equals(arr[j])){
             cnt+=1;
           }                
        }
        if(cnt<1){
          arrList.add(arr[i]);
        }
          cnt=0;
        }

for(int k=0;k<arrList.size();k++){
            System.out.println("Array without Duplicates: "+arrList.get(k));
        }

score 0 · Answer 11 · answered Aug 06 '19 at 09:42

List<String> al = new ArrayList<String>();
String[] months={"Jan","Feb","Mar","Apr","Jan","Mar","May","May"};
for(int i=0;i<months.length;i++){
    for(int j=1;j<months.length;j++){
        if(months[i].equalsIgnoreCase(months[j])){
            if(!al.contains(months[i])){
                al.add(months[i]);
            }
        }
    }
}

Afif Khaja · Answer 12 · 2020-07-29T15:24:38.950

0

Sring[] myStringArray = {"hello", "hello", "moto"};
String[] filteredArray = new LinkedHashSet<String>(Arrays.asList(myStringArray))
                         .toArray(new String[0]);

System.out.println("filteredArray Size: " + filteredArray.length);
System.out.println("filteredArray[0] = " + filteredArray[0]);
System.out.println("filteredArray[1] = " + filteredArray[1]);

edited Jul 29 '20 at 15:24

answered Jul 28 '20 at 15:40

Afif Khaja

1
2

score 0 · Answer 13 · answered May 20 '21 at 05:47

public static List<String> sortHandleArrayList(String... arrayInput) {
    List<String> list = new ArrayList<>();
    for (String string : arrayInput) {
        if (!list.contains(string)) {
            list.add(string);
        }
    }
    Collections.sort(list);
    return list;
}

score 0 · Answer 14 · answered May 30 '21 at 08:19

To remove duplicate String from String[] without using Collection

    public static void removeDuplicate(String[] str, int size){
            for(int i=0; i<size-1; i++){
                if(str[i]!=null){
                    for(int j=i+1; j<size-1; j++){
                        if(str[i].equals(str[j])){
                            str[j]=null;
                        }
                    }
                }
            }
            for(int i=0; i<size;i++){
                if(str[i]==null)
                   continue;
                System.out.println(str[i]);
            }
        }

score -3 · Answer 15 · answered Oct 09 '13 at 06:56

Duplicate integer remove : this is the perfect answer /// Haris ///

public static void duplicateRemove(int[] arr) {
    int temp = 0;

    for (int i = 0; i < arr.length; i++) {
        for (int j = 0; j < arr.length; j++) {
            if (arr[i] < arr[j]) {
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }

    int count;
    for (int j = 0; j < arr.length;) {
        count = 1;
        for (int i = j + 1; i < arr.length; i++) {
            if (arr[i] == arr[j]) {
                count++;
            } else
                break;

        }
        System.out.println(arr[j] + " is :  " + count);
        j += count;
    }

}

The question is regarding removing duplicate STRINGS not integers — ılǝ, Oct 09 '13 at 07:18

Delete duplicate strings in string array

15 Answers15

Linked