In Java, what are the boolean "order of operations"?

70,143

Solution 1

The Java Tutorials has a list illustrating operator precedence. The equality operators will be evaluated first, then &&, then ||. Parentheses will be evaluated before anything else, so adding them can change the order. This is usually pretty much the same from language to language, but it's always a good idea to double check.

It's the small variations in behavior that you're not expecting that can cause you to spend an entire day debugging, so it's a good idea to put the parentheses in place so you're sure what the order of evaluation will be.

Solution 2

Boolean order of operations (in all languages I believe):

  1. parens
  2. NOT
  3. AND
  4. OR

So your logic above is equivalent to:

(cat != null && cat.getColor() == "orange") || cat.getColor() == "grey"

Solution 3

The expression is basically identical to:

if ( (cat != null && cat.getColor() == "orange") || cat.getColor() == "grey") {
  ...
}

The order of precedence here is that AND (&&) has higher precedence than OR (||).

You should also know that using == to test for String equality will sometimes work in Java but it is not how you should do it. You should do:

if (cat != null && ("orange".equals(cat.getColor()) || "grey".equals(cat.getColor()))) {
  ...
}

ie use the equals() methods for String comparison, not == which simply does reference equality. Reference equality for strings can be misleading. For example:

String a = new String("hello");
String b = new String("hello");
System.out.println(a == b); // false

Solution 4

First, your if statement contains three main expressions:

  1. cat != null
  2. cat.getColor() == "orange"
  3. cat.getColor() == "grey"

The first expression simply checks whether cat is not null. Its necessary otherwise the the second expression will get executed and will result in a NPE(null pointer excpetion). That's why the use of && between the first and second expression. When you use &&, if the first expression evaluates to false the second expression is never executed. Finally you check whether the cat's color is grey.

Finally note that your if statement is still wrong because if cat is null, the third expression is still executed and hence you get a null pointer exception.

The right way of doing it is:

if(cat != null && (cat.getColor() == "orange" || cat.getColor() == "grey")) { 
//do stuff 
} 

Check the order of parenthesis.

Solution 5

Yeah && is definitely evaluated before ||. But I see you are doing cat.getColor() == "orange" which might give you unexpected result. You may want to this instead :

if(cat != null && ("orange".equals(cat.getColor()) || "grey".equals(cat.getColor()))) {
    //do stuff
}
Share:
70,143
Stephano
Author by

Stephano

Oui, je travaille maintenant, un peu comme autrefois, seulement je ne sais plus travailler. Cela n’a pas d’importance, paraît-il.

Updated on July 05, 2022

Comments

  • Stephano
    Stephano over 1 year

    Let's take a simple example of an object Cat. I want to be sure the "not null" cat is either orange or grey.

    if(cat != null && cat.getColor() == "orange" || cat.getColor() == "grey") {
    //do stuff
    }
    

    I believe AND comes first, then the OR. I'm kinda fuzzy though, so here are my questions:

    1. Can someone walk me through this statement so I'm sure I get what happens?

    2. Also, what happens if I add parentheses; does that change the order of operations?

    3. Will my order of operations change from language to language?

  • Robert P
    Robert P over 13 years
    I think you're missing a paren in that first example, or I'm just too tired.
  • Bill the Lizard
    Bill the Lizard about 8 years
    @VinceEmigh The operands don't have to be evaluated in the same order as operator precedence. Even if you add parentheses, the program can still see that if(true || (true && s.equals(""))) will always be true, so it doesn't need to evaluate s.equals("") at all.
  • Dioxin
    Dioxin about 8 years
    My bad, I just realized I'm strongly mistaken. I wasn't thinking of precedence correctly. I was thinking in terms of evaluation (which gets evaluated first), as in which operator "owns" the booleans