Question

我目前正在开展一个小项目，我最终搞乱字节，短值等，经过一些阅读，我仍然不明白一些东西，比如什么是“位移”，为什么我们使用它，什么时候需要，以及它是如何工作的。

另外，我发现这个函数将short转换为byte：

private byte[] short2byte(short[] sData) {
    int shortArrsize = sData.length;
    byte[] bytes = new byte[shortArrsize * 2];
    for (int i = 0; i < shortArrsize; i++) {
        bytes[i * 2] = (byte) (sData[i] & 0x00FF);
        bytes[(i * 2) + 1] = (byte) (sData[i] >> 8);
        sData[i] = 0;
    }
    return bytes;

}

我想我理解这个功能，但我的问题是我不确定这两行是做什么的：

bytes[i * 2] = (byte) (sData[i] & 0x00FF);
bytes[(i * 2) + 1] = (byte) (sData[i] >> 8);

我认为它与位移有关，所以有人可以解释一下这意味着什么吗？如果您有关于字节，短字，位移等的链接或良好文档，请尽可能包括。

亲切的问候

Answer 1

有问题的两行实际上将一个短值拆分为2个字节的值。如果您有短变量n = 0xCCDD，行字节[i * 2] =（n＆amp; 0x00FF）将最低有效字节提取到bytes[i *2] 即。在0xDD

中存储bytes[i * 2]

行字节[i * 2 + 1] =（n＆gt;＆gt; 8），右边8个字节，并给出n中最高有效字节的值即。以字节[i * 2 + 1]

存储0xCC

查看http://docs.oracle.com/javase/tutorial/java/nutsandbolts/op3.html将有助于更好地理解它。

Answer 2

比特移位只是在数字表示中移动1 s的位置。例如：

0001101 // This is the binary representation of 13
0011010 // This is 13 << 1, or 26, or 13 * 2
0000110 // This is 13 >> 1, or 6, or floor(13 / 2)

0110100 // 13 << 2 = 52 = 13 * 2^2
1101000 // 13 << 3 = 104 = 13 * 2^3

0000011 // 13 >> 2 = 3 = floor(13 / 2^2)
0000001 // 13 >> 3 = 1 = floor(13 / 2^3)

你困惑的另一条线是“按位”; A & B会在1和A都有B的所有位置生成1个数字：

  1011010 //  90
& 0000011 // & 3
--------- // ---
  0000010 //   2
//     ^---- This is the only position where both 90 and 3 have a 1

Answer 3

所以第一个：比特转移

我猜你听说过二进制数字了。现在大多数人在我们的日常业务中使用十进制数字系统，您的数字范围从0到9。您使用的每个号码都由0-9的数字组成。二进制系统只使用数字0和1，这非常方便计算机使用，因为那时你可以很容易地用功率表示数字：

0 =没有力量

1 =权力

与十进制数字系统相同，您可以通过将数字彼此相邻来制作更大的数字：十进制数10是9 + 1。在二进制10中是1 + 1。

Binary = Decimal
0   = 0
1   = 1
10  = 2
11  = 3
100 = 4
101 = 5
110 = 6
111 = 7

等等。

计算机通常使用固定长度的数字（至少使用整数类型的整数，如int，long，short，byte，...），因此它们将左边的所有剩余数字填充为0：

5 in decimal = 101 in binary = 00000101 in 8-bit (byte) = 0000000000000101 in 16-bit (short)

等等。

什么位移位会将所有位移到一个方向：

Right-Shift by two digits:
00001101 >> 2 = 00000011

Left-Shift by three digits:
00001101 << 3 = 01101000

左移相当于乘以2而右移相当于除以2（这里说的是正数，因为负数有点不同）。

现在到第二个：掩蔽 现在这是关于这一部分： sData [i]＆amp;设为$ 00FF

首先，这里我们有另一个数字符号：十六进制数字。它的工作原理与二进制数非常相似，现在有16个不同的数字：0,1,2,3,4,5,6,7,8,9，A，B，C，D，E，F。它们中的每一个都代表二进制的四位数字，因此您只需用以下数字替换每个数字即可在两者之间进行转换：

Hex = Binary
0   = 0000
1   = 0001
2   = 0010
3   = 0011
4   = 0100
5   = 0101
6   = 0110
7   = 0111
8   = 1000
9   = 1001
A   = 1010
B   = 1011
C   = 1100
D   = 1101
E   = 1110
F   = 1111

因此，此处给出的数字为0x00FF，等于16位二进制的0000000011111111。

现在到＆amp;或实际的掩蔽。＆amp; -Operator为每个位返回1，其中两个输入均为1和0，其中任一输入为0：

0101010101010101
&
0000000011111111
=
0000000001010101

所以你看，你可以使用＆amp; -operator屏蔽掉一个输入字符串中0的所有位。

那么函数的这一部分是将短路（16位长）分成两个独立的8位字节。让我们说sData [i]包含这个数字：0011001101010101

bytes[i * 2] = (byte) (sData[i] & 0x00FF);
=
bytes[i * 2] = (byte) (0011001101010101 & 0000000011111111);
=
bytes[i * 2] = (byte) (0000000001010101); //lower 8 bit



bytes[(i * 2) + 1] = (byte) (sData[i] >> 8);
=
bytes[(i * 2) + 1] = (byte) (0011001101010101 >> 8); //Right shift by 8 spaces
=
bytes[(i * 2) + 1] = (byte) (0000000000110011); //upper 8 bit

Java Bit Shifting，短转换为字节

3 个答案: