Java运算符性能算法与按位运算

Question

In repetitive arithmetic operations where performance really matters, do bitwise operators have a positive or negative impact on performance? I tried to Google it but couldn't get a definitive answer.

For example should i use this:

int s = 15 << 4;

or this:

int s = 15 * 16;

to improve the performance of my application.

Also does operator precedence correlate with performance?

Answer 1

Even if these operations are not compile-time constant expressions (for example n << 4 ), the virtual machine would select the faster implementation during the JIT compilation, so you can write in either way which is most readable for you. The performance will be the same.

Here's the C++ code of HotSpot JVM C2 JIT compiler which replaces multiplication to power-of-two with the left shift. A little below you may find more optimizations for some constants (like replacing n * 12 with (n << 3) + (n << 2) ).

Answer 2

In this case you could use either.

Both are compile-time evaluable constant expressions so the compiler will perform the operation. So the runtime will not be impacted at all.

If you had contrived an example that was only evaluable at runtime, then it would have been harder to say, but if I were you I'd trust the compiler in any case. Always use the appropriate operator for your task so bugs don't creep in. You can always profile performance.

Answer 3

This code

public class A {
    public static void main(String[] args) {
        int a = 15 << 4;
        int b = 15 * 16;
    }
}

is compiled to

  public static void main(java.lang.String[]);
    Code:
       0: sipush        240
       3: istore_1
       4: sipush        240
       7: istore_2
       8: return