Why is method1 and method2 the same at the Bytecode level?

Question

I wrote this simple Test class to see how Java evaluates boolean algebra at the Bytecode level:

public class Test {      private static boolean a, b;      public static boolean method1(){         return !(a || b);     }      public static boolean method2(){         return !a && !b;     } } 

If you simplify method1() using DeMorgan's Laws, you should get method2(). After looking at the Bytecode (using javap -c Test.class), it looks like:

Compiled from "Test.java" public class Test {     public Test();     Code:             0: aload_0     1: invokespecial #1                  // Method java/lang/Object."<init>":             ()V     4: return      public static boolean method1();     Code:             0: getstatic     #2                  // Field a:Z             3: ifne          16             6: getstatic     #3                  // Field b:Z             9: ifne          16             12: iconst_1     13: goto          17             16: iconst_0     17: ireturn      public static boolean method2();     Code:             0: getstatic     #2                  // Field a:Z             3: ifne          16             6: getstatic     #3                  // Field b:Z             9: ifne          16             12: iconst_1     13: goto          17             16: iconst_0     17: ireturn } 

So my question is, why is method1() and method2() exactly the same at the Bytecode level?

Answer 1

What your seeing is a compiler optimization. When javac encounters method1() it applies an optimization (based on De Morgan's Laws as you pointed out but also short circuiting the && comparison) that allows it to branch early if a is true (thus no need to evaluate b).