java--byte與基礎類型轉換

byte b[]={0x41,(byte) 0xc8,0,0}; 
//方法1 流輸入，適用於ME/SE環境
//默認大端數，如果小端數，可以先翻轉數組
DataInputStream dis=new DataInputStream(new ByteArrayInputStream(b));
float f=dis.readFloat();
dis.close();
System.out.println(f);

//方法2 緩存輸入，適用於SE/EE環境
ByteBuffer buf=ByteBuffer.allocateDirect(4); //無額外內存的直接緩存
//buf=buf.order(ByteOrder.LITTLE_ENDIAN);//默認大端，小端用這行
buf.put(b);
buf.rewind();
float f2=buf.getFloat();
System.out.println(f2);

//方法三，自定義工具類
package cn.yuehua.io;

/**
 * byte[] 轉換
 * 采用大端順序，即對於0x11223344，byte[0]保存0x11，byte[1]保存0x22，byte[2]保存0x33，byte[3]保存0x44
 */
public class ByteArrayConveter {
    //char -> byte[2]
    public static byte[] getByteArray(char c){
        byte[] b = new byte[2];
        b[0] = (byte)((c & 0xff00) >> 8);
        b[1] = (byte)(c & 0x00ff);
        return b;
    }
    // 從byte數組的index處的連續兩個字節獲得一個char
    public static char getChar(byte[] arr, int index) {
        return (char) (0xff00 & arr[index] << 8 | (0xff & arr[index + 1]));
    }
    // short轉換為byte[2]數組
    public static byte[] getByteArray(short s) {
        byte[] b = new byte[2];
        b[0] = (byte) ((s & 0xff00) >> 8);
        b[1] = (byte) (s & 0x00ff);
        return b;
    }
    // 從byte數組的index處的連續兩個字節獲得一個short
    public static short getShort(byte[] arr, int index) {
        return (short) (0xff00 & arr[index] << 8 | (0xff & arr[index + 1]));
    }
    // int轉換為byte[4]數組
    public static byte[] getByteArray(int i) {
        byte[] b = new byte[4];
        b[0] = (byte) ((i & 0xff000000) >> 24);
        b[1] = (byte) ((i & 0x00ff0000) >> 16);
        b[2] = (byte) ((i & 0x0000ff00) >> 8);
        b[3] = (byte)  (i & 0x000000ff);
        return b;
    }
    // 從byte數組的index處的連續4個字節獲得一個int
    public static int getInt(byte[] arr, int index) {
        return     (0xff000000     & (arr[index+0] << 24))  |
                (0x00ff0000     & (arr[index+1] << 16))  |
                (0x0000ff00     & (arr[index+2] << 8))   |
                (0x000000ff     &  arr[index+3]);
    }
    // float轉換為byte[4]數組
    public static byte[] getByteArray(float f) {
        int intbits = Float.floatToIntBits(f);//將float里面的二進制串解釋為int整數
        return getByteArray(intbits);
    }
    // 從byte數組的index處的連續4個字節獲得一個float
    public static float getFloat(byte[] arr, int index) {
        return Float.intBitsToFloat(getInt(arr, index));
    }
    // long轉換為byte[8]數組
    public static byte[] getByteArray(long l) {
        byte b[] = new byte[8];
        b[0] = (byte)  (0xff & (l >> 56));
        b[1] = (byte)  (0xff & (l >> 48));
        b[2] = (byte)  (0xff & (l >> 40));
        b[3] = (byte)  (0xff & (l >> 32));
        b[4] = (byte)  (0xff & (l >> 24));
        b[5] = (byte)  (0xff & (l >> 16));
        b[6] = (byte)  (0xff & (l >> 8));
        b[7] = (byte)  (0xff & l);
        return b;
    }
    // 從byte數組的index處的連續8個字節獲得一個long
    public static long getLong(byte[] arr, int index) {
        return     (0xff00000000000000L     & ((long)arr[index+0] << 56))  |
                (0x00ff000000000000L     & ((long)arr[index+1] << 48))  |
                (0x0000ff0000000000L     & ((long)arr[index+2] << 40))  |
                (0x000000ff00000000L     & ((long)arr[index+3] << 32))  |
                (0x00000000ff000000L     & ((long)arr[index+4] << 24))  |
                (0x0000000000ff0000L     & ((long)arr[index+5] << 16))  |
                (0x000000000000ff00L     & ((long)arr[index+6] << 8))   |
                (0x00000000000000ffL     &  (long)arr[index+7]);
    }
    // double轉換為byte[8]數組
    public static byte[] getByteArray(double d) {
        long longbits = Double.doubleToLongBits(d);
        return getByteArray(longbits);
    }
    // 從byte數組的index處的連續8個字節獲得一個double
    public static double getDouble(byte[] arr, int index) {
        return Double.longBitsToDouble(getLong(arr, index));
    }


    public static void main(String[] args) {
        float f = 11.9f;
        byte[] byteArray = getByteArray(f);
        float aFloat = getFloat(byteArray, 0);
        System.out.println(aFloat);
    }
}