如何检查两个集合的相等性忽略大小写？

Question

I want to treat lowercase and uppercase values the same, and make sure two collections are equal (does not have to be sorted)

This is my implementation:

private boolean stringCollectionEqualsIgnoreCase(Collection<String> c1, Collection<String> c2)
{
    Set<String> s1 = new HashSet<>();
    c1.forEach(i -> s1.add(i.toLowerCase()));

    Set<String> s2 = new HashSet<>();
    c2.forEach(i -> s2.add(i.toLowerCase()));

    return s1.size() == s2.size() && s2.containsAll(s1);
}

Is there an easier way to do this? Or is it better to have my own method

Answer 1

Your actual solution is very acceptable. It is clear enough and it should have a overall good performance.

You should use Set.equals() instead of Set.containsAll() . It makes the same things but it spare you from comparing the size as optimization.

1) A stream version of your code could be :

private boolean stringCollectionEqualsIgnoreCase(Collection<String> c1, Collection<String> c2) {
    return c1.stream()
             .map(String::toLowerCase)
             .collect(toSet())
             .equals(c2.stream()
                       .map(String::toLowerCase)
                       .collect(toSet()));
}

2) Here is a second alternative with Treeset .
I am not sure that it is easier but it avoids explicit loops and makes the logic more explicit as factored out :

private boolean stringCollectionEqualsIgnoreCase(Collection<String> c1, Collection<String> c2)
{
    Comparator<String> comp = Comparator.comparing(String::toLowerCase);
    Set<String> s1 = new TreeSet<>(comp);
    Set<String> s2 = new TreeSet<>(comp);
    s1.addAll(c1);
    s2.addAll(c2);
    return s1.equals(s2);
}

Note that it removes duplicates according to the comparator. That means that it sorts. So it could be slower or faster than your actual solution according to the cases. Of course for small Set s to compare, it doesn't matter.

Answer 2

Since there is no native library providing this, I think you'll always have to do some workaround, but the following could be an elegant solution without having to change your existing collections.

public boolean containsAllIgnoreCase(Collection<String> var1, Collection<String> var2) {
    return var1.stream()
               .map(String::toLowerCase)
               .collect(toList())
               .containsAll(var2.stream()
                                .map(String::toLowerCase)
                                .collect(toList());
}

Or even more easier to read

public List<String> toLowerCaseList(Collection<String> var) {
    return var.stream().map(String::toLowerCase).toList();
}

public boolean containsAllIgnoreCase(Collection<String> var1, Collection<String> var2) {
    return toLowerCaseList(var1).containsAll(toLowerCaseList(var2));
}

Answer 3

If an implementation that works with Set s is enough, you could store your unique elements in a TreeSet with a special case-insensitive comparator:

Set<String> uniqueStrings = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);

This way you can make the comparison simply with uniqueStrings.equals(anotherTreeSet) . It's a bit of a hack, I have to admit.