Checking equality of three or more Strings in Java

Question

I know this is a very basic question, but I am always trying to find ways to make my code a clean and concise as possible. Is there a way to compare the equality of three or more strings in a single if() statement? I am currently using the && operator to progressively compare each string. However, as you could imagine, between long variable names and methods being called, these if() statements get very cluttered very quickly. Additionally I am planning to have an unknown number of these Strings, and would like to avoid complex for loops with cluttered if()s nested inside of them. This is what my code currently looks like:

String a = new String("a");
String b = new String("b");
String c = new String("c");
if(a.equals(b) && b.equals(c)) {
    doSomething();
}

Is there a way, or a collection of some sort that I can use that would allow me to compare these values more like this:

if(a.equals(b).equals(c)) {
    doSomething();
}

Answer 1

If you have several objects of the same type, it's a good idea to organize them in the data structure like array or list. So suppose you have a List of String objects:

List<String> strings = Arrays.asList("a", "b", "a", ...);

You want to know whether all the strings in the list equal to each other. This can be done in a number of methods. Probably the shortest one is:

if(new HashSet<>(strings).size() == 1) {
    // all strings are equal
}

Longer, but more optimal solution is proposed by @niceguy. If you are using Java-8, you can also do this way:

if(strings.stream().distinct().count() == 1) {
    // all strings are equal
}

Answer 2

There is no simple way to chain your equals() commands like this. In order to be able to chain them this way, equals() would have to return a reference to the String itself. Then, however, it can't return a boolean value that represents the outcome of the comparison anymore.

Also, I see it as not particularly problematic to compare three strings separately as in your first example. Make sure you keep your code well formatted, and it will remain easy to understand, even for longer variable names:

if(myValueAWithALongName.equals(myValueBWithALongName) &&
   myValueBWithALongName.equals(myValueCWithALongName) &&
   myValueCWithALongName.equals(myValueDWithALongName) &&
   ... ) {

Alternatively, you could use one of the other solutions proposed in this thread and wrap your values into a Collection and write a helper method. Note however that this might have a negative impact on memory usage, performance and possibly readablity.

---

On a side note, you should never create Strings using the Constructor new String(). Simply assign the string literal directly to your variable:

String a = "a";

Answer 3

There are different ways to approach this problem depending on the number of String objects being compared.

If you only have a few String objects to be compared and you pretty much need to do this kind of comparison in one or two places in your application, you can wrap the code in a method inside the class that needs such a comparison so that the code becomes more readable :

 public boolean isConditionSatisfied(String a,String b,String c) {
    return Objects.equals(a,b) && Objects.equals(b,c);
 }

The client code then be simplified and more readable :

if(isConditionSatisfied(a,b,c)) { //doSomething }

Note that Objects.equals is an inbuilt method available since JDK 1.7. In comparison to the other answers, the use of Object.equals safeguards you from a NullPointerExcsption which in my opinion is an absolute necessity.

If you find yourself needing this kind of a comparison quite often (and not only for String objects) why look for a solution only for comparing String objects? Why not find a generic solution that will work for any kind or number of objects?

public class ObjectUtils {

    public static boolean multipleEquals(Object... objectsToCompare) {

        if (null == objectsToCompare) {
            return false;
        } else if (objectsToCompare.length == 0) {
            return false;
        } else if (objectsToCompare.length == 1)      {
            return true;
        }

        boolean allEqual = true;
        for (int curr = 1; curr < objectsToCompare.length; ++curr) {
            if(!Objects.equals(objectsToCompare[0],objectsToCompare[curr])) {
                allEqual = false;
                break;
            }
        }

        return allEqual;
    }
}

Ok so you want to compare 4 String objects, why not :

if(ObjectUtils.multipleEquals("1","1","1","1") { }

But now you want to compare 5 Integer objects, no problem :

if(ObjectUtils.multipleEquals(1,2,3,4,5) { }

You can even mix and match objects :

if(ObjectUtils.multipleEquals("1",2,"3",4) { }

Answer 4

Additionally I am planning to have an unknown number of these Strings, and would like to avoid complex for loops with cluttered if()s nested inside of them.

I don't think that a for loop would be that complex.

You can certainly check for equality by trying

a.equals(b)
b.equals(c)
etc.

But comparing everything to a will have the same result. If everything is equal to a, everything is equal to each other.

a.equals(b)
a.equals(c)
etc.

This makes the for loop simpler. If you don't mind the overhead of comparing a to itself you can simply check your entire array or collection (or whatever) against a for equality.

The if doesn't look cluttered either. return from the function as soon as one pair of strings is not equal.

Answer 5

This may be an unusual idea, but situations like this are where a little metaprogramming may come in handy.

public static void nEquals(int nOverloads, PrintStream out) {
    if (nOverloads < 2)
        throw new IllegalArgumentException();

    for (int i = 2; i <= nOverloads; ++i) {
        out.println("public static boolean equals(");
        out.print("        Object obj0");

        for (int j = 1; j < i; ++j) {
            out.print(", Object obj" + j);
        }

        out.println(") {");
        out.print("    return obj0.equals(obj1)");

        for (int j = 2; j < i; ++j) {
            out.print(" && obj0.equals(obj" + j + ")");
        }

        out.println(";");
        out.println("}");
    }
}

nEquals(4, System.out); prints the following:

public static boolean equals(
        Object obj0, Object obj1) {
    return obj0.equals(obj1);
}
public static boolean equals(
        Object obj0, Object obj1, Object obj2) {
    return obj0.equals(obj1) && obj0.equals(obj2);
}
public static boolean equals(
        Object obj0, Object obj1, Object obj2, Object obj3) {
    return obj0.equals(obj1) && obj0.equals(obj2) && obj0.equals(obj3);
}

You can generate as many overloads as you want, no need for varargs. Just copy and paste to a utility class and you're done.

if (Util.equals(a, b, c)) {
    doSomething();
}

For such a simple code generation, the margin for error is small. The only downside is maintainability, because if somebody ever did need to tinker with it (such as to change the handling of null, which is ignored in both my and your examples), they need to modify the generator and run it again.

Answer 6

How about something like this:

boolean allEqual(List<String> elements) {
    if(elements.isEmpty() || elements.size() == 1) {
        return true;
    }
    String current = elements.get(0);
    if(current == null) {
        return false;
    }
    for(int i = 1; i < elements.size(); i++) {
        if(!current.equals(elements.get(i))) {
            return false;
        }
        current = elements.get(i);
    }
    return true;
}

Not exactly pretty, but you need to write it only once and it works for an arbitrary number of strings.

Answer 7

One more way is to use String as implementation of Comparable.

public <T extends Comparable<T>> boolean equality(T... objects) {
    Arrays.sort(objects);
    return objects[0].compareTo(objects[objects.length - 1]) == 0;
}

Pros: This solution is universal for all Comparable objects.

Cons: If all values equals that it'll be N(great!) comparison otherwise N logN max. Also here will be allocated memory for temporary storage for sort method which will vary from very small to N/2.