short与byte[]、int与byte[]互转(通过位运算实现)

///////////////////////////// short /////////////////////////////

 /*** 将short数值转换为占两个字节的byte数组，本方法适用于(低位在前，高位在后)的顺序。
 * 
与bytesToShort_LH配套使用
 *
 * @param shortVal short 要转换的short值
 * @return byte[] Byte数组
 */
  public static byte[] shortToBytes_LH(short shortVal) {
    byte[] bytes = new byte[2];
    bytes[0] = (byte) (shortVal & 0xff);
    bytes[1] = (byte) (shortVal >> 8 & 0xff);
    return bytes;
}

/*** 将short数值转换为占两个字节的Byte数组，本方法适用于(低位在前，高位在后)的顺序。
 * 
与bytesToShort_LH配套使用
 *
 * @param shortVal short 要转换的short值
 * @return Byte[] byte数组
 */
public static Byte[] short2Bytes_LH(short shortVal) {
    Byte[] bytes = new Byte[2];
    bytes[0] = (byte) (shortVal & 0xff);
    bytes[1] = (byte) (shortVal >> 8 & 0xff);
    return bytes;
}

/*** 将short数值转换为占两个字节的byte数组，本方法适用于(低位在前，高位在后)的顺序。
 * 
与bytesToInt_HL配套使用
 *
 * @param shortVal int 要转换的int值
 * @return byte[] byte数组
 */
public static byte[] shortToBytes_HL(short shortVal) {
    byte[] bytes = new byte[2];
    bytes[0] = (byte) (shortVal >> 8 & 0xff);
    bytes[1] = (byte) (shortVal & 0xff);
    return bytes;
}

/**
 * byte数组中取short数值，本方法适用于(低位在前，高位在后)的顺序。
 * 
与shortToBytes_LH配套使用
 *
 * @param src    byte[]  byte数组
 * @param offset int 从数组的第offset位开始
 * @return int 数值
 */
public static short bytesToShort_LH(byte[] src, int offset) {
    short value;
    value = (short) (src[offset] & 0x00ff | ((src[offset + 1]) << 8) & 0xff00);
    return value;
}

/**
 * byte数组中取short数值，本方法适用于(低位在后，高位在前)的顺序。
 * 
与shortToBytes_HL配套使用
 *
 * @param src    byte[]  byte数组
 * @param offset int 从数组的第offset位开始
 * @return int 数值
 */
public static short bytesToShort_HL(byte[] src, int offset) {
    short value;
    value = (short) (((src[offset]) << 8) & 0xff00 | src[offset + 1] & 0x00ff);
    return value;
}

 /////////////////////////////  int   /////////////////////////////

/*** 将int数值转换为占四个字节的byte数组，本方法适用于(低位在前，高位在后)的顺序。
 * 
与bytesToInt_LH配套使用
 *
 * @param intVal int 要转换的int值
 * @return byte[] byte数组
 */
public static byte[] intToBytes_LH(int intVal) {
    byte[] bytes = new byte[4];
    bytes[0] = (byte) (intVal & 0xff);
    bytes[1] = (byte) (intVal >> 8 & 0xff);
    bytes[2] = (byte) (intVal >> 16 & 0xff);
    bytes[3] = (byte) (intVal >> 24 & 0xff);
    return bytes;
}

/*** 将int数值转换为占四个字节的Byte数组，本方法适用于(低位在前，高位在后)的顺序。
 * 
与bytesToInt_LH配套使用
 *
 * @param intVal int 要转换的int值
 * @return Byte[] Byte数组
 */
public static Byte[] int2Bytes_LH(int intVal) {
    Byte[] bytes = new Byte[4];
    bytes[0] = (byte) (intVal & 0xff);
    bytes[1] = (byte) (intVal >> 8 & 0xff);
    bytes[2] = (byte) (intVal >> 16 & 0xff);
    bytes[3] = (byte) (intVal >> 24 & 0xff);
    return bytes;
}

/*** 将int数值转换为占四个字节的byte数组，本方法适用于(高位在前，低位在后)的顺序。
 * 
与bytesToInt_HL配套使用
 *
 * @param intVal int  要转换的int值
 * @return byte[] byte数组
 */
public static byte[] intToBytes_HL(int intVal) {
    byte[] bytes = new byte[4];
    bytes[0] = (byte) ((intVal >> 24) & 0xFF);
    bytes[1] = (byte) ((intVal >> 16) & 0xFF);
    bytes[2] = (byte) ((intVal >> 8) & 0xFF);
    bytes[3] = (byte) (intVal & 0xFF);
    return bytes;
}

/**
 * byte数组中取int数值，本方法适用于(低位在前，高位在后)的顺序。
 * 
与intToBytes_LH配套使用
 *
 * @param src    byte[]  byte数组
 * @param offset int 从数组的第offset位开始
 * @return int 数值
 */
public static int bytesToInt_LH(byte[] src, int offset) {
    int value;
    value = (((src[3 + offset] & 0x00ff) << 24) & 0xff000000)
            | (((src[2 + offset] & 0x00ff) << 16) & 0x00ff0000)
            | (((src[1 + offset] & 0x00ff) << 8) & 0x0000ff00)
            | ((src[offset] & 0x00ff));
    return value;
}

/**
 * byte数组中取int数值，本方法适用于(低位在后，高位在前)的顺序。
 * 
与intToBytes_Hl配套使用
 *
 * @param src    byte[]  byte数组
 * @param offset int 从数组的第offset位开始
 * @return int 数值
 */
public static int bytesToInt_HL(byte[] src, int offset) {
    int value;
    value = (((src[offset] & 0xFF) << 24)
            | ((src[offset + 1] & 0xFF) << 16)
            | ((src[offset + 2] & 0xFF) << 8)
            | (src[offset + 3] & 0xFF));
    return value;
}