Question

I have a pathfinding algorithm which is run many times and must be extremely efficient, so I’m wondering what I can do to boost performance. I have an if statement which says this:

if (!(n != 1 && map.isCornerObstructed(p)) {
    // Do stuff...
}

It seems to me that the double inversion would take slightly longer than this logically equivalent version:

if (n == 1 || !map.isCornerObstructed(p)) {
    // Do stuff...
}

The problem is that the former is more readable in the context of the code, so I’m somewhat reluctant to change it if I don’t know what the result will be.

Is one more efficient than the other? Or is the Java compiler smart enough to optimize things like this automatically?

Answer 1

The code

Set<String> set = new HashSet<String>();
int n = set.size();
Object o = new Object();
if (!(n != 1 && set.contains(o))) {
  System.out.println("Foo");
  // Do stuff...
}

generates bytecode

 0  new java.util.HashSet [16]
 3  dup
 4  invokespecial java.util.HashSet() [18]
 7  astore_1 [set]
 8  aload_1 [set]
 9  invokeinterface java.util.Set.size() : int [19] [nargs: 1]
14  istore_2 [n]
15  new java.lang.Object [3]
18  dup
19  invokespecial java.lang.Object() [8]
22  astore_3 [o]
23  iload_2 [n]
24  iconst_1
25  if_icmpeq 38
28  aload_1 [set]
29  aload_3 [o]
30  invokeinterface java.util.Set.contains(java.lang.Object) : boolean [25] [nargs: 2]
35  ifne 46
38  getstatic java.lang.System.out : java.io.PrintStream [29]
41  ldc <String "Foo"> [35]
43  invokevirtual java.io.PrintStream.println(java.lang.String) : void [37]
46  return

The code

Set<String> set = new HashSet<String>();
int n = set.size();
Object o = new Object();
if (n == 1 || !set.contains(o)) {
  System.out.println("Foo");
  // Do stuff...
}

generates bytecode

 0  new java.util.HashSet [16]
 3  dup
 4  invokespecial java.util.HashSet() [18]
 7  astore_1 [set]
 8  aload_1 [set]
 9  invokeinterface java.util.Set.size() : int [19] [nargs: 1]
14  istore_2 [n]
15  new java.lang.Object [3]
18  dup
19  invokespecial java.lang.Object() [8]
22  astore_3 [o]
23  iload_2 [n]
24  iconst_1
25  if_icmpeq 38
28  aload_1 [set]
29  aload_3 [o]
30  invokeinterface java.util.Set.contains(java.lang.Object) : boolean [25] [nargs: 2]
35  ifne 46
38  getstatic java.lang.System.out : java.io.PrintStream [29]
41  ldc <String "Foo"> [35]
43  invokevirtual java.io.PrintStream.println(java.lang.String) : void [37]
46  return

which is exactly the same. Therefore, there will be no performance difference at all, no matter how finely you measure it. The compiled code is identical.

(Note that the reason for this is that javac actually goes and decomposes the if statement into individual condition tests and branches, so it actually works out the pathway for each possibility.)