byte[]与short、int、long、float、double的互换

import java.util.Locale;

public class Tool {

/*
* 低位在前,byte转unsigned byte
* */
public static int byteToInt(byte b) {
    return b & 0xFF;
}

/*
* 低位在前,bytes转short
* */
public static short byteArrayToShort(byte[] bytes, int startPos) {
    if (bytes == null || startPos < 0) return 0;
    short s = 0;
    int b0 = byteToInt(bytes[startPos]);
    int b1 = byteToInt(bytes[startPos + 1]);
    s = (short) (b0 + (b1 << 8));
    return s;
}

/*
* 低位在前,bytes转int
* */
public static int byteArrayToInt(byte[] bytes, int startPos) {
    if (bytes == null || startPos < 0) return 0;
    int i = 0;
    for (int k = 0; k < 4; k++) {
        i |= (byteToInt(bytes[startPos + k]) << (8 * k));
    }
    return i;
}

/*
* 低位在前，bytes转long
* */
public static long byteArrayToLong(byte[] bytes, int startPos) {
    if (bytes == null || startPos < 0) return 0;
    long l = 0;
    for (int i = 0; i < 8; i++) {
        l |= (long) ((bytes[i] & 0xFF) << (8 * i));
    }
    return l;
}

/*
* 低位在前,bytes转float
* */
public static float byteArrayToFloat(byte[] bytes, int startPos) {
    if (bytes == null || startPos < 0) return 0;
    float f = 0;
    f = Float.intBitsToFloat(byteArrayToInt(bytes, startPos));
    return f;
}

/*

* 低位在前,bytes转double
* */
public static double byteArrayToDouble(byte[] bytes, int startPos) {
if (bytes == null || startPos < 0) return 0;
long value = 0;
for (int i = 0; i < 8; i++) {
value |= ((long) (bytes[i] & 0xFF)) << (8 * i);
}
return Double.longBitsToDouble(value);
}

/*
 * short转bytes,bytes中高位在前
 * */
public static boolean shortToByteArray(short value, byte[] target, int startPos) {
    if (target == null || startPos < 0) return false;
    target[startPos] = (byte) (value >> 8);
    target[startPos + 1] = (byte) value;
    return true;
}

/*
 * int转bytes,bytes中高位在前
 * */
public static boolean intToByteArray(int value, byte[] target, int startPos) {
    if (target == null || startPos < 0) return false;
    target[startPos] = (byte) (value >> 24);
    target[startPos + 1] = (byte) (value >> 16);
    target[startPos + 2] = (byte) (value >> 8);
    target[startPos + 3] = (byte) value;
    return true;
}

/*
 * long转bytes,bytes中高位在前
 * */
public static boolean longToByteArray(long value, byte[] target, int startPos) {
    if (target == null || startPos < 0) return false;
    for (int i = 0; i < 8; i++) {
        target[startPos + i] = (byte) (value >> (8 * (7 - i)));
    }
    return true;
}

/*
 * float转bytes,bytes中高位在前
 * */
public static boolean floatToByteArray(float value, byte[] target, int startPos) {
    if (target == null || startPos < 0) return false;
    int i = Float.floatToIntBits(value);
    intToByteArray(i, target, startPos);
    return true;
}

/*
* double转bytes,bytes中高位在前
* */
public static boolean doubleToByteArray(double value, byte[] target, int startPos) {
    if (target == null || startPos < 0) return false;
    long l = Double.doubleToLongBits(value);
    longToByteArray(l, target, startPos);
    return true;
}

}