Duplicates elements not removed from ArrayList

Question

I am trying to add unique elements to an array using the below code. I used Ignorecase, but still I am getting duplicates.

    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;

    public class RemoveDuplicatesIgnoreCase {

    public static void main(String args[]) {

        // String Array with duplicates Colors
        String[] colorArray={"Black","BLACK","black","Cobalt","COBALT","cobalt","IVORY","Ivory","ivory","White","WHITE","white"};
        List<String> uniqueColorList=new ArrayList<String>();
        for (String color : colorArray) {
            if(!uniqueColorList.contains(color)&& !uniqueColorList.contains(color.toLowerCase())&& !uniqueColorList.contains(color.toUpperCase()))
            {
                uniqueColorList.add(color);
            }
        }
        Iterator<String> itr=uniqueColorList.iterator();
        while(itr.hasNext())
        {
            System.out.println(itr.next());
        }

    }

}

Output:

Black
BLACK
Cobalt
COBALT
IVORY
White
WHITE

I want to avoid adding case sensitive & case insensitive duplicates.

Should it be case sensitive? – erencan Dec 05 '13 at 12:33 — erencan, Dec 05 '13 at 12:33

score 4 · Answer 1 · answered Dec 05 '13 at 12:31

4

I would use a SET instead of a ArrayList and add the string in lowercase. The Set doesn't allowed duplicate element.

Set<String> uniqueColorList = new HashSet<String>();
for (String color : colorArray) {
    uniqueColorList.add(color.toLowerCase());
}

answered Dec 05 '13 at 12:31

TheEwook

11,037
6
36
55

1

Maybe he needs to use a List in the rest of his application – user1021726 Dec 05 '13 at 12:32
@user1021726 I think it's unlikely but yes I agree he might! – TheEwook Dec 05 '13 at 12:33
considering everything is in his `main`, yes very unlikely :P But if this was in a bigger API or in a bigger program you might not want to, or be able to, change the data type – user1021726 Dec 05 '13 at 12:35
You also don't keep the original case. – Domi Dec 05 '13 at 12:35

score 2 · Answer 2 · answered Dec 05 '13 at 12:31

2

you have to lowerCase both values, to find a match

answered Dec 05 '13 at 12:31

deterministicFail

1,271
9
28

Bohemian · Answer 3 · 2013-12-05T14:15:34.507

I would use a Set of lowercase versions of the colors to track uniqueness:

public static void main(String args[]) {

    String[] colorArray={"Black","BLACK","black","Cobalt","COBALT","cobalt","IVORY","Ivory","ivory","White","WHITE","white"};

    List<String> colors = new ArrayList<String>();
    Set<String> uniqueColors = new HashSet<String>();
    for (String color : colorArray) {
        if (set.add(color.toLowerCase()) {
            uniqueColors.add(color);
        }
    }
    // colors now contains case-insensitive unique names 
}

This code makes use of two things about a Set:

Sets allow only unique values, so by putting in lowercase copies of the string we get the case-insensitive part taken care of
The add() method returns true if the operation changed the set, which will only happen if the value being added is new to the set, Using this return value avoids having to use contains() - simply attempt to add the value and you'll find out if it's unique or not.

score 1 · Answer 4 · answered Dec 05 '13 at 13:01

I think the RIGHT way to do this would be encapsulating the Color in an Object. It is only minimal overhead and makes your code A LOT more readable:

public class ColorString {
    public final String str;

    public ColorString(String str) {
      this.str = str;
    }

    public boolean equals(Object obj) {
        if (obj == null) return false;
        if (obj == this) return true;
        if (!(obj instanceof ColorString )) return false;

        ColorString col = (ColorString) obj;

        if (this.str == null) return (col.str == null);

        return this.str.equalsIgnoreCase(col.str);
    }

    public int hashCode() { // Always override hashCode AND equals
        return str.toLowerCase().hashCode();
    }

}

If you do it like this, you can use all the standard-methods, you can use a Set, an ArrayList.contains and so on. This solution is more sensible, since it is the representation of the idea: You don't have Strings, but you have a "color" and you have special rules, when two "color"s should be considered equal or not.

And if you want to expand your solution e.g. by allowing multiple colors with similar names to be treated as the same "color" you just have to change one method and everything still works!

score 0 · Accepted Answer · edited May 23 '17 at 12:03

Your problem is that you only cover all lower-case and all upper-case Strings, and not any other mix of cases (e.g. you also have capitalized Strings).

To make things short, you can just extend ArrayList and override contains to use ignore-case comparison for each String , as suggested in this thread:

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class RemoveDuplicatesIgnoreCase {
    public static void main(String args[]) {

        // String Array with duplicates Colors
        String[] colorArray={"Black","BLACK","black","Cobalt","COBALT","cobalt","IVORY","Ivory","ivory","White","WHITE","white"};
        List<String> uniqueColorList=new IgnoreCaseStringList<String>();
        for (String color : colorArray) {
            if(!uniqueColorList.contains(color))
            {
                uniqueColorList.add(color);
            }
        }
        Iterator<String> itr=uniqueColorList.iterator();
        while(itr.hasNext())
        {
            System.out.println(itr.next());
        }

    }

}

public class IgnoreCaseStringList extends ArrayList<String> {
    @Override
    public boolean contains(Object o) {
        String paramStr = (String)o;
        for (String s : this) {
            if (paramStr.equalsIgnoreCase(s)) return true;
        }
        return false;
    }
}

score 0 · Answer 6 · answered Dec 05 '13 at 12:33

It doesn't work because you start by adding Black which is neither uppercase nor lowercase.

You could just decide to add uppercase or lowercase strings, and better yet, use a TreeSet if ordering doesn't matter to you. TreeSet will make it sorted alphabeticly.

Ruchira Gayan Ranaweera · Answer 7 · 2013-12-05T12:54:14.443

I want to avoid adding case sensitive & case insensitive duplicates.

You have to get all Strings in to either lowercase or uppercase the moment you are compare String same as comparing values.

you can use equalsIgnoreCase()

But better and easy way is use a Set since it keep unique vales only.

Set<String> uniqueVal = new HashSet<String>();
for (String color : colorArray) {
    uniqueVal.add(color.toLowerCase());
}

you can convert Set into List again

List<String> uniqueList=new ArrayList<>(uniqueVal); 
// Now list contains unique values only

score 0 · Answer 8 · answered Dec 05 '13 at 12:34

0

The reason is you are checikng for all lowercase

When you are checking for BLACK there is Black in the list but Black != black.

The first char of the lowercase string is uppercase.

answered Dec 05 '13 at 12:34

Wald

1,063
7
13

score 0 · Answer 9 · answered Dec 05 '13 at 12:35

first off this part:

uniqueColorList.contains(color)

won't work, this is because when it does .equals on the strings, the case is different. then your next problem is that the lower and upper case don't work, because the first one if mixed. What it boils down to is the fact that WHITE and White are technically unique. The easiest option is to just use a single set case, as per ZouZou's suggestion. otherwise you need to do what Domi said and implement your own contains method to do a case insensitive check

score 0 · Answer 10 · answered Dec 05 '13 at 12:35

Set<String> duplicateDection = new HashSet<>()
if (duplicateDection.add(color.toLowerCase())) {
  uniqueColorList.add(color);
}

If removing items from the list you also need to remove them from the duplicate detection:

uniqueColorList.remove(color);
duplicateDetection.remove(color.toLowerCase());

score 0 · Answer 11 · answered Dec 05 '13 at 12:42

You only check that list being build already contains 'same case' 'upper case' 'lower case' variants of the element to be added, so the search is not exhaustive if the list contains already a string with the different case combination then it passes condition and adds the color.

score 0 · Answer 12 · answered Dec 05 '13 at 12:47

Try this..

public static void main(String[] a) {
    String[] colorArray = {"Black", "BLACK", "black", "Cobalt", "COBALT", "cobalt", "IVORY", "Ivory", "ivory", "White", "WHITE", "white"};
    List<String> uniqueColorList = new ArrayList<String>();

    for (int i = 0; i < colorArray.length; i++) {
        for (int j = i+1; j < colorArray.length; j++) {
            if (!colorArray[i].equals("")) {
                if (colorArray[i].equalsIgnoreCase(colorArray[j])) {
                    colorArray[j] = "";
                }
            }
        }
    }
    System.out.println(Arrays.toString(colorArray));;
    for (String color : colorArray) {
        if (!color.equals("")) {
            uniqueColorList.add(color);
        }
    }
    Iterator<String> itr = uniqueColorList.iterator();
    while (itr.hasNext()) {
        System.out.println(itr.next());
    }
}

score 0 · Answer 13 · answered Dec 05 '13 at 12:55

public static void main(String args[]) {

    String[] colorArray={"Black","BLACK","black","Cobalt","COBALT","cobalt","IVORY","Ivory","ivory","White","WHITE","white"};
    Set<String> uniqueColorList = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
    for (String color : colorArray) {
            uniqueColorList.add(color);
    }
    Iterator<String> itr=uniqueColorList.iterator();
    while(itr.hasNext())
    {
        System.out.println(itr.next());
    }

}

this will solve your problem

Output:

Black
Cobalt
IVORY
White

Duplicates elements not removed from ArrayList

13 Answers13