What is the performance difference, if any, between if(!foo) and if(foo == false) in Java?

Question

Logically, if(!foo) and if(foo == false) are equivalent. How are they represented in Java? Is there any difference between the two after compilation, either in the bytecode or in performance? I was unable to find an answer in the JLS, and searching brought up a lot of results about = vs. == typos and ==/equals() behavior. (In this case, the symbols hampered my searching; for future searchers, negation operator, equals false, equal to false, not condition).

To head off the CW debate: this question is NOT asking which variant people prefer or which is considered better style. I am interested in the differences in the implementation of the language, so there is a correct answer. Related-but-not-quite-a-dupe: Difference between while (x = false) and while (!x) in Java?

EDIT:

The general consensus seems to be that a good compiler should optimize these to the same thing. That makes sense and is what I suspected, but -- to ask an even MORE academic question -- is that behavior actually mandated anywhere, or is it "merely" the reasonable thing to do?

Answer 1

The JLS would specify the required behavior of the statements. However, how they are implemented is an implementation detail of the compiler and the JVM.

In practice, any compiler worth its salt should emit the same bytecode for those statements. And even if not, the JVM would optimize them properly.

Also, a better way to answer this, is to check for yourself, using javap:

1. Compile a Test.java with the following content:

   class Test {
       void equals(boolean f) {
           if (f == false) {}
       }
       void not(boolean f) {
           if (!f) {}
       }
   }
   $ javac Test.java
   

2. De-assemble it:

   $ javap -c Test
   Compiled from "Test.java"
   class Test extends java.lang.Object{
   Test();
     Code:
      0:   aload_0
      1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
      4:   return
   
   void equals(boolean);
     Code:
      0:   iload_1
      1:   ifne    4
      4:   return
   
   void not(boolean);
     Code:
      0:   iload_1
      1:   ifne    4
      4:   return
   
   }
   

UPDATE: Responding your question about the "academic" question. As mentioned above, the JLS is only concerned with the behavior. There is nothing in the standard that actually specifies how it should be implemented (well, JVMS provides a lot of guidance).

As long as the compiler preserves the same identical behavior, the compiler is free to implement it different, with possibility different runtime performance.