位掩蔽与移位（+；java字节码）

在使用IEEE754浮点时，我发现了两种将32位变量的前9位归零的方法。其中有一个比另一个好吗

Java相关补充：是否有一些列表提供有关指令效率的信息？我随机发现，BIPUSH通常被认为比LDC更快，但其他什么都没有

//1011111111001010001110101110001位
//000000000 1001010001110101110001有效位
整数位=0B10111111001010001110101110001；
int有效位=位&0b11111111；
int有效位2=位>>9；

字节码

L4
行号49 L4
伊洛德0
LDC 8388607/=0B11111111
土地
史前5
L5
线号50 L5
伊洛德0
第9步
伊什尔
第9步
IUSHR
史前6

---

谢谢。：）

字节码是一种可移植的中间语言。为了获得良好的性能，现代JVM会及时将其编译为本机代码，因此不要对其进行太多的解读：CPU实际执行的内容可能看起来非常不同。您必须分析生成的本机代码，才能得出为什么X比Y性能更好的结论

---

如何打印生成的汇编程序代码取决于JVM，请参阅此处以获取热点（即Oracle JDK和OpenJDK）的说明：

字节码是一种可移植的中间语言。为了获得良好的性能，现代JVM会及时将其编译为本机代码，因此不要对其进行太多的解读：CPU实际执行的内容可能看起来非常不同。您必须分析生成的本机代码，才能得出为什么X比Y性能更好的结论

---

如何打印生成的汇编程序代码取决于JVM，请参阅此处以获取Hotspot（即Oracle JDK和OpenJDK）的说明：

通常，移位操作应该更快。下面是一个简单的Java测试和结果值：

int bits = 0b10111111110010100011110101110001;

long time = System.nanoTime();
int significand;
for (int i = 0; i < 1000000000; i++) {
    significand = bits & 0b11111111111111111111111;
}
System.out.println(String.format("Time: %f (ms)",
    (System.nanoTime() - time) / 1000000f));

long time2 = System.nanoTime();
for (int i = 0; i < 1000000000; i++) {
    significand = bits << 9 >>> 9;
}
System.out.println(String.format("Time 2: %f (ms)",
    (System.nanoTime() - time2) / 1000000f));

int位=0B10111111001010001110101110001；
长时间=System.nanoTime（）；
int有效位；
对于（int i=0；i<100000000；i++）{
有效位=位&0b11111111；
}
System.out.println（String.format（“时间：%f（ms）”，
（System.nanoTime（）-time）/1000000f）；
longtime2=System.nanoTime（）；
对于（int i=0；i<100000000；i++）{
有效位=位>>9；
}
System.out.println（String.format（“时间2:%f（ms）”，
（System.nanoTime（）-time2）/1000000f）；

时间1:7.003190（毫秒）
时间2:2.633435（毫秒）

---

当然，这是大量重复的结果。

一般来说，换档操作应该更快。下面是一个简单的Java测试和结果值：

int bits = 0b10111111110010100011110101110001;

long time = System.nanoTime();
int significand;
for (int i = 0; i < 1000000000; i++) {
    significand = bits & 0b11111111111111111111111;
}
System.out.println(String.format("Time: %f (ms)",
    (System.nanoTime() - time) / 1000000f));

long time2 = System.nanoTime();
for (int i = 0; i < 1000000000; i++) {
    significand = bits << 9 >>> 9;
}
System.out.println(String.format("Time 2: %f (ms)",
    (System.nanoTime() - time2) / 1000000f));

int位=0B10111111001010001110101110001；
长时间=System.nanoTime（）；
int有效位；
对于（int i=0；i<100000000；i++）{
有效位=位&0b11111111；
}
System.out.println（String.format（“时间：%f（ms）”，
（System.nanoTime（）-time）/1000000f）；
longtime2=System.nanoTime（）；
对于（int i=0；i<100000000；i++）{
有效位=位>>9；
}
System.out.println（String.format（“时间2:%f（ms）”，
（System.nanoTime（）-time2）/1000000f）；

时间1:7.003190（毫秒）
时间2:2.633435（毫秒）

---

当然，这些都是大量重复的结果。

在现代处理器上，一个简单的整数算术运算很少会成为一个重要的性能问题。条件分支和缓存未命中更为重要。在现代处理器上，一个简单的整数算术运算成为一个重要的性能问题是非常罕见的。条件分支和缓存未命中可能更重要。我已经分析了我的代码（JProfiler），shinfting方法看起来确实更快（1.56x），但我在寻找更一般的答案，或者至少是在Joni的答案中找到的一个提示。无论如何，非常感谢。：）我已经分析了我的代码（JProfiler），shinfting方法看起来确实更快（1.56x），但我在寻找更一般的答案，或者至少是我在Joni的答案中找到的一个提示。无论如何，非常感谢。：）