java%4d,java - 检索一个数字 - 堆栈内存溢出

TL; DR使用b & 6 ，例如(byte)(11 & 6) 。 请参阅getBits()实现。

首先，将11为一个byte是没有意义的，因为>>运算符会将它强制转换回int值。

为了向您展示代码无效的原因，这里有一个显示所有中间步骤的程序：

public static void main(String[] args) {

for (byte i = 0; i <= 16; i++) {

int i1 = i >> 1;

int i2 = i1 << 6;

int i3 = i2 >> 5;

System.out.printf("%3d %s -> %3d %s -> %3d %10s -> %3d %s%n", i, bin(i), i1, bin(i1), i2, bin(i2), i3, bin(i3));

}

}

private static String bin(int value) {

String s = Integer.toBinaryString(value);

return "0000000".substring(Math.min(7, s.length() - 1)) + s;

}

输出：

0 00000000 -> 0 00000000 -> 0 00000000 -> 0 00000000

1 00000001 -> 0 00000000 -> 0 00000000 -> 0 00000000

2 00000010 -> 1 00000001 -> 64 01000000 -> 2 00000010

3 00000011 -> 1 00000001 -> 64 01000000 -> 2 00000010

4 00000100 -> 2 00000010 -> 128 10000000 -> 4 00000100

5 00000101 -> 2 00000010 -> 128 10000000 -> 4 00000100

6 00000110 -> 3 00000011 -> 192 11000000 -> 6 00000110

7 00000111 -> 3 00000011 -> 192 11000000 -> 6 00000110

8 00001000 -> 4 00000100 -> 256 100000000 -> 8 00001000

9 00001001 -> 4 00000100 -> 256 100000000 -> 8 00001000

10 00001010 -> 5 00000101 -> 320 101000000 -> 10 00001010

11 00001011 -> 5 00000101 -> 320 101000000 -> 10 00001010

12 00001100 -> 6 00000110 -> 384 110000000 -> 12 00001100

13 00001101 -> 6 00000110 -> 384 110000000 -> 12 00001100

14 00001110 -> 7 00000111 -> 448 111000000 -> 14 00001110

15 00001111 -> 7 00000111 -> 448 111000000 -> 14 00001110

16 00010000 -> 8 00001000 -> 512 1000000000 -> 16 00010000

您的高位没有被清除，因为它在int值上运行。 如果将所有内容更改为byte ，则会得到：

public static void main(String[] args) {

for (byte i = 0; i <= 16; i++) {

byte i1 = (byte)(i >> 1);

byte i2 = (byte)(i1 << 6);

byte i3 = (byte)(i2 >> 5);

System.out.printf("%3d %s -> %3d %s -> %4d %s -> %3d %s%n", i, bin(i), i1, bin(i1), i2, bin(i2), i3, bin(i3));

}

}

private static String bin(byte value) {

String s = Integer.toBinaryString(value & 0xFF);

return "0000000".substring(s.length() - 1) + s;

}

0 00000000 -> 0 00000000 -> 0 00000000 -> 0 00000000

1 00000001 -> 0 00000000 -> 0 00000000 -> 0 00000000

2 00000010 -> 1 00000001 -> 64 01000000 -> 2 00000010

3 00000011 -> 1 00000001 -> 64 01000000 -> 2 00000010

4 00000100 -> 2 00000010 -> -128 10000000 -> -4 11111100

5 00000101 -> 2 00000010 -> -128 10000000 -> -4 11111100

6 00000110 -> 3 00000011 -> -64 11000000 -> -2 11111110

7 00000111 -> 3 00000011 -> -64 11000000 -> -2 11111110

8 00001000 -> 4 00000100 -> 0 00000000 -> 0 00000000

9 00001001 -> 4 00000100 -> 0 00000000 -> 0 00000000

10 00001010 -> 5 00000101 -> 64 01000000 -> 2 00000010

11 00001011 -> 5 00000101 -> 64 01000000 -> 2 00000010

12 00001100 -> 6 00000110 -> -128 10000000 -> -4 11111100

13 00001101 -> 6 00000110 -> -128 10000000 -> -4 11111100

14 00001110 -> 7 00000111 -> -64 11000000 -> -2 11111110

15 00001111 -> 7 00000111 -> -64 11000000 -> -2 11111110

16 00010000 -> 8 00001000 -> 0 00000000 -> 0 00000000

这里，问题是你从>>获得的符号扩展。 即使切换到>>>也不会起作用，因为>>>在转换发生之前仍然使用符号扩展强制转换为int 。

要摆脱符号扩展，你必须使用b & 0xFF将byte转换为int ，因为&将强制b强制转换为符号扩展的int ，然后按位AND运算符将删除所有这些位。

当然，如果您打算使用按位AND，只需使用它来获得所需的结果，即b & 0b00000110 (或b & 6 )。

出于与上述相同的原因， getBits()方法不起作用。

解决方案仍然是使用按位AND运算符，但是从提供的from和to值构造位掩码。

这里的技巧是使用(1 << x) - 1来创建x位的掩码，例如5 - > 0b00011111 。 因此，如果您想要2到4(包括2和4)，请构建0x00011111 (5！位)和0x00000011 (2位)，然后将它们XOR以获得0x00011100 。

public static byte getBits(byte b, int from, int to) {

if (from < 0 || from > to || to > 7)

throw new IllegalArgumentException();

int mask = ((1 << (to + 1)) - 1) ^ ((1 << from) - 1);

return (byte)(b & mask);

}

0 00000000 -> 0 00000000

1 00000001 -> 0 00000000

2 00000010 -> 2 00000010

3 00000011 -> 2 00000010

4 00000100 -> 4 00000100

5 00000101 -> 4 00000100

6 00000110 -> 6 00000110

7 00000111 -> 6 00000110

8 00001000 -> 0 00000000

9 00001001 -> 0 00000000

10 00001010 -> 2 00000010

11 00001011 -> 2 00000010

12 00001100 -> 4 00000100

13 00001101 -> 4 00000100

14 00001110 -> 6 00000110

15 00001111 -> 6 00000110

16 00010000 -> 0 00000000

对于其他原始类型，重载方法：

public static byte getBits(byte value, int from, int to) {

if (from < 0 || from > to || to > 7)

throw new IllegalArgumentException();

int mask = ((1 << (to + 1)) - 1) ^ ((1 << from) - 1);

return (byte)(value & mask);

}

public static short getBits(short value, int from, int to) {

if (from < 0 || from > to || to > 15)

throw new IllegalArgumentException();

int mask = ((1 << (to + 1)) - 1) ^ ((1 << from) - 1);

return (short)(value & mask);

}

public static int getBits(int value, int from, int to) {

if (from < 0 || from > to || to > 31)

throw new IllegalArgumentException();

int mask = ((1 << (to + 1)) - 1) ^ ((1 << from) - 1);

return value & mask;

}

public static long getBits(long value, int from, int to) {

if (from < 0 || from > to || to > 63)

throw new IllegalArgumentException();

long mask = ((1L << (to + 1)) - 1) ^ ((1L << from) - 1); //

return value & mask;

}