Java 位移位X比位移位1 X快吗？

问题1

在Java中，多次移位是否比使用一条语句将数据移位相同的数字要昂贵得多

例如，是

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

intx=5；
x=x
…这样我就不用浪费StackOverflow用户的时间了

你也在浪费自己的时间。编写应用程序的完整原型，对其进行分析，然后对其进行优化。我很肯定你会发现瓶颈并不是由于位的移动

这闻起来太远了

“x”的精确性能是什么
…这样我就不用浪费StackOverflow用户的时间了

你也在浪费自己的时间。为你的应用程序编写一个完整的原型，对其进行分析，然后对其进行优化。我相信你会发现瓶颈并不是因为位的变化

这闻起来太远了

“x的精确性能是什么？就基本逻辑而言，单次移位将提供更高的性能

使用
for loop
版本时，对于循环的每次迭代，检查循环的终止条件，
i
递增，执行逐位操作，并向
x
赋值

使用单移位时，执行单位操作并将赋值给
x

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

为了回答您的问题，逻辑上，第一个示例比其他示例更快

也就是说，根据语言和编译器的不同，编译器可能会看到您的
for循环
始终运行16次，然后继续优化您的代码，将其更改为
x。在基本逻辑方面，单次移位将提供更高的性能

使用
for loop
版本时，对于循环的每次迭代，检查循环的终止条件，
i
递增，执行逐位操作，并向
x
赋值

使用单移位时，执行单位操作并将赋值给
x

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

为了回答您的问题，逻辑上，第一个示例比其他示例更快

也就是说，根据语言和编译器的不同，编译器可能会看到您的
for循环
始终运行16次，然后继续优化代码，将其更改为
x为什么不编写一个简单的基准测试并亲自查看呢

    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);

long start1=System.nanoTime（）；
对于（int k=0；k<100000000；k++）{
int x=5；
为什么不写一个简单的基准测试，自己看看呢

    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);

long start1=System.nanoTime（）；
对于（int k=0；k<100000000；k++）{
int x=5；
x=x我会使用第一个。

但可能是差不多的。

可能第一个更快，因为我认为JVM有一个内置的指令，而另一个，它必须读取几个指令，而这些指令可能会更慢。

你不应该想太多这些微小的“速度提升”的事情。
这些小算术/逻辑运算的速度非常快，对程序性能影响不大。

我会使用第一个。

但可能是差不多的。

可能第一个更快，因为我认为JVM有一个内置的指令，而另一个，它必须读取几个指令，而这些指令可能会更慢。

你不应该想太多这些微小的“速度提升”的事情。
这些小小的算术/逻辑运算的速度非常快，不会对程序性能产生太大影响。

进行多位移位几乎总是比使用一位循环快一个数量级。正确的答案是，非常清楚的是，使用单位移位可以提供无与伦比的性能直接写入一条机器指令。至于其他习惯用法，你仍然可以幸运地让JIT编译器自己意识到循环的summa summarum只是那一个移位。但是为什么要这样做呢。现在我记得，即使在CPU硬件级别，也有一个专用电路，即所谓的桶移位器，它使操作只需一个时钟周期。1987年在Intel 80386上引入。如果你需要更直接的答案——是的，
x所有“正常”计算机都有多位移位操作，可以在一条指令中完成N位移位。（在一些粗糙的RISC处理器上，它可能需要2-3条指令，但这些指令上的任何操作都需要2-3条指令。）长移位可能比短移位需要更多的内部周期，但差异很难测量。@Kirby
javap-c YourClass
可能会在下次你有疑问时有所帮助。多位移位几乎总是比使用一位循环快一个数量级。正确的答案是绝对清楚使用单次移位可以提供无与伦比的性能。它可以直接转换为一条机器指令。至于其他习惯用法，您仍然可以幸运地让JIT编译器自己意识到循环的summa summarum就是那一次移位。但是为什么要这样做呢？现在我记得，即使在CPU硬件级别，也有一种专用电路，即所谓的桶形移位器，它使移位操作只需一个时钟周期。1987年在英特尔80386上引入。如果你需要更直接的答案——是的，
x所有“普通”计算机都有多位移位操作，可在一条指令中完成N位移位。（在一些粗糙的RISC处理器上，可能需要2-3条指令，但在这些处理器上，任何指令都需要2-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);