Java中移位运算以及int、long和byte的转化

移位运算符

运算符	含义
<<	左移运算符，将运算符左边的对象向左移动运算符右边指定的位数（在低位补0）
>>	"有符号"右移运算 符，将运算符左边的对象向右移动运算符右边指定的位数。使用符号扩展机制，也就是说，如果值为正，则在高位补0，如果值为负，则在高位补1.
>>>	"无符号"右移运算 符，将运算符左边的对象向右移动运算符右边指定的位数。采用0扩展机制，也就是说，无论值的正负，都在高位补0.

举例：

将int转化为byte存在byte[]数组中：

    public static void setIntAt(byte[] buffer, int offset, int value) {
        buffer[offset + 0] = (byte)((value >> 24) & 0xff);
        buffer[offset + 1] = (byte)((value >> 16) & 0xff);
        buffer[offset + 2] = (byte)((value >> 8) & 0xff);
        buffer[offset + 3] = (byte)((value) & 0xff);
    }

同理将long转化为byte存在byte[]数组中：

    public static void setLongAt(byte[] buffer, int offset, long value) {
        buffer[offset + 0] = (byte) ((value >> 56) & 0xFF);
        buffer[offset + 1] = (byte) ((value >> 48) & 0xFF);
        buffer[offset + 2] = (byte) ((value >> 40) & 0xFF);
        buffer[offset + 3] = (byte) ((value >> 32) & 0xFF);
        buffer[offset + 4] = (byte) ((value >> 24) & 0xFF);
        buffer[offset + 5] = (byte) ((value >> 16) & 0xFF);
        buffer[offset + 6] = (byte) ((value >> 8) & 0xFF);
        buffer[offset + 7] = (byte) (value & 0xFF);
    }

相反，将byte[]数组转int：

public static int getIntAt(byte[] buffer, int offset) {
        int value = 0;
        value |= (buffer[offset + 0] & 0xFF) << 24
                | (buffer[offset + 1] & 0xFF) << 16
                | (buffer[offset + 2] & 0xFF) << 8
                | (buffer[offset + 3] & 0xFF);
        return value;
    }

同理将byte[]数组转long

    public static long getLongAt(byte[] buffer, int offset) {
        long value = 0;
        value |= (long)(buffer[offset + 0] & 0xFF) << 56
                | (long)(buffer[offset + 1] & 0xFF) << 48
                | (long)(buffer[offset + 2] & 0xFF) << 40
                | (long)(buffer[offset + 3] & 0xFF) << 32
                | (long)(buffer[offset + 4] & 0xFF) << 24
                | (long)(buffer[offset + 5] & 0xFF) << 16
                | (long)(buffer[offset + 6] & 0xFF) << 8
                | (long)(buffer[offset + 7] & 0xFF);
        return value;
    }

将byte[]数组以十六进制输出：

    public static String toHex(byte[] buffer) {
        StringBuffer result = new StringBuffer();

        for (int i = 0; i < buffer.length; i++) {
            byte bv = buffer[i];
            result.append(i == 0 ? "" : ' ')
                    .append(hex.charAt((bv >> 4) & 0x0F))
                    .append(hex.charAt(bv & 0x0F));
        }

        return result.toString();
    }

Demo：

public static void main(String[] args) {
		byte[] buffer = new byte[16];

		ByteAndStringUtil.setIntAt(buffer, 0, 27);
		ByteAndStringUtil.setLongAt(buffer, 4, -11584858);
		ByteAndStringUtil.setIntAt(buffer, 12, -20);
		for (int index = 0; index < buffer.length; index ++) {
			System.out.print(buffer[index] + "!");
		}

		System.out.println();

		System.out.println(ByteAndStringUtil.toHex(buffer));

		int fileId = ByteAndStringUtil.getIntAt(buffer, 0);
		long offset = ByteAndStringUtil.getLongAt(buffer, 4);
		int length = ByteAndStringUtil.getIntAt(buffer, 12);

		System.out.println(fileId + ", " + offset
				+ ", " + length);


	}

0!0!0!27!-1!-1!-1!-1!-1!79!58!-90!-1!-1!-1!-20!
00 00 00 1B FF FF FF FF FF 4F 3A A6 FF FF FF EC
27, -11584858, -20

对，很对！