Looping over a list, checking a boolean and return value

Question

public boolean checkNameStartsWith(List<Foo> foos) {
    for (Foo foo : foos) {
        if (!(foo.getName().startsWith("bar"))) {
            return Boolean.FALSE;
        }
    }
    return Boolean.TRUE;
}

There are a number of different ways to do this, what do people prefer and why?

Answer 1

I'd change Boolean.FALSE to false and Boolean.TRUE to true. Using the constants objects from Boolean is rather unnecessary since the method returns with primitive boolean.

Answer 2

Though for loop is enough, you can rewrite using Guava if you like lambdas:

public boolean checkNameStartsWith(List<Foo> foos){
    return Iterables.all(foos, new Predicate<Foo>() {
        public boolean apply(Foo foo) {
            return foo.getName().startsWith("bar");
        }
    });
}

Answer 3

In addition to the other answers, I suggest adding a second parameter to the checkNameStartsWith method named prefix, e.g.

public boolean checkNameStartsWith(List<Foo> foos, final String prefix) {
    for (Foo foo : foos) {
        if (!foo.getName().startsWith(prefix)) {
            return false;
        }
    }
    return true;
}

Answer 4

I know it probably doesn't matter from a performance standpoint (due to branch prediction and compiler optimization), but I still prefer this form:

public boolean checkNameStartsWith(List<Foo> foos) {
    for (Foo foo : foos) {
        if (foo.getName().startsWith("bar")) continue;

        // Mismatch found
        return false; 
    }
    return true;
}

I think it's because it makes it easier to see that you're absolutely done with the iteration once you've determined there's no match. Otherwise, you might have something like this:

public boolean myMethod(List<Foo> foos, final String prefix) {
    for (Foo foo : foos) {
        if (!foo.getName().startsWith(prefix)) {
            // do something complex (many lines of code)
        }
        // here you could possibly do something else, regardless of condition true/false
    }
    return true;
}

You don't know unless you search for the end of the loop whether something is still done if the condition is false.

Answer 5

Boolean.FALSE and Boolean.TRUE should be definitely replaced with true and false because of auto-boxing. You don't need an additional Integer.intValue() call for each invocation.

I'm pretty sure Oracle HotSpot will optimize this automatically, but the code readability still suffers.