Question

问题＃1

在Java中，转移的次数比使用单个语句转移的次数要多一倍吗？

例如，是

int x = 5;
x = x << 16;

比

快

int x = 5;
for (int i=0; i<16; ++i) {
    x = x << 1;
}

此外，

怎么样？

int x = 5;
for (int i=0; i<16; ++i) {
    x = x*2;
}

编辑：“x＆lt;＆lt; 16”的精确性能是什么？它是否与“x <1”相同的速度？

问题＃2

我是否可以使用在线资源来确定Java中的各种按位操作性能，这样我就不必浪费StackOverflow用户的时间了？： - ）

Answer 1

...这样我就不必浪费StackOverflow用户的时间了吗？

你也在浪费自己的时间。编写应用程序的完整原型，对其进行概要分析，然后然后对其进行优化。我很确定你会因为位移而发现瓶颈不。

这种方式过早地进行了优化。

“x <＆lt; 16”的精确性能是什么？它的速度是否与“x <1”相同？

是的，它是一样的。但从技术上讲，它实际上取决于编译器，JVM实现，JIT，CPU架构......在这种情况下， Java规范对执行时间没有任何限制。

Answer 2

在基本逻辑方面，单一班次可以提供更高的性能。

当使用for loop版本时，对于循环的每次迭代，都会检查循环的终止条件，i递增，执行按位运算并赋值{{1 }}

使用单个移位时，将执行单个按位操作，并对x进行分配。

正如其他人所说，这看起来确实像是过早优化。

为了回答你的问题，从逻辑上讲，第一个例子比其他例子更快。

也就是说，根据语言和编译器的不同，编译器可能会看到您的x始终运行16次，然后继续优化代码，将其更改为for loop。如果是这种情况，您会发现您给出的每个代码示例之间没有区别。

Answer 3

为什么不写一个简单的基准测试并亲自看看？

    long start1 = System.nanoTime();
    for (int k = 0; k < 100000000; k++) {
        int x = 5;
        x = x << 16;
    }
    long stop1 = System.nanoTime();

    long start2 = System.nanoTime();
    for (int k = 0; k < 100000000; k++) {
        int x = 5;
        for (int i = 0; i < 16; ++i) {
            x = x << 1;
        }
    }
    long stop2 = System.nanoTime();

    long start3 = System.nanoTime();
    for (int k = 0; k < 100000000; k++) {
        int x = 5;
        for (int i = 0; i < 16; ++i) {
            x = x * 2;
        }
    }
    long stop3 = System.nanoTime();

    System.out.println(stop1 - start1);
    System.out.println(stop2 - start2);
    System.out.println(stop3 - start3);

Answer 4

我会使用第一个。
但它可能是相同的。
也许首先是更快，因为我认为JVM有一个内置的指令，而另一方面，它必须阅读几个指令，可能会更慢。

你不应该考虑这些轻微的“速度提升”事情。这些小算术/逻辑运算的速度是巨大的，它不会对程序性能产生太大影响。

位移X比位移X倍快？

编辑：“x＆lt;＆lt; 16”的精确性能是什么？它是否与“x <1”相同的速度？

4 个答案: