android中的byte数组转换

/**

      * 将一个单字节的byte转换成32位的int

      *

      * @param b

      *            byte

      * @return convert result

      */

     public static int unsignedByteToInt( byte b) {

         return ( int ) b & 0xFF ;

     }

 

     /**

      * 将一个单字节的Byte转换成十六进制的数

      *

      * @param b

      *            byte

      * @return convert result

      */

     public static String byteToHex( byte b) {

         int i = b & 0xFF ;

         return Integer.toHexString(i);

     }

 

     /**

      * 将一个4byte的数组转换成32位的int

      *

      * @param buf

      *            bytes buffer

      * @param byte[]中开始转换的位置

      * @return convert result

      */

     public static long unsigned4BytesToInt( byte [] buf, int pos) {

         int firstByte = 0 ;

         int secondByte = 0 ;

         int thirdByte = 0 ;

         int fourthByte = 0 ;

         int index = pos;

         firstByte = ( 0x000000FF & (( int ) buf[index]));

         secondByte = ( 0x000000FF & (( int ) buf[index + 1 ]));

         thirdByte = ( 0x000000FF & (( int ) buf[index + 2 ]));

         fourthByte = ( 0x000000FF & (( int ) buf[index + 3 ]));

         index = index + 4 ;

         return (( long ) (firstByte << 24 | secondByte << 16 | thirdByte << 8 | fourthByte)) & 0xFFFFFFFFL;

     }

 

     /**

      * 将16位的short转换成byte数组

      *

      * @param s

      *            short

      * @return byte[] 长度为2

      * */

     public static byte [] shortToByteArray( short s) {

         byte [] targets = new byte [ 2 ];

         for ( int i = 0 ; i < 2 ; i++) {

             int offset = (targets.length - 1 - i) * 8 ;

             targets[i] = ( byte ) ((s >>> offset) & 0xff );

         }

         return targets;

     }

 

     /**

      * 将32位整数转换成长度为4的byte数组

      *

      * @param s

      *            int

      * @return byte[]

      * */

     public static byte [] intToByteArray( int s) {

         byte [] targets = new byte [ 2 ];

         for ( int i = 0 ; i < 4 ; i++) {

             int offset = (targets.length - 1 - i) * 8 ;

             targets[i] = ( byte ) ((s >>> offset) & 0xff );

         }

         return targets;

     }

 

     /**

      * long to byte[]

      *

      * @param s

      *            long

      * @return byte[]

      * */

     public static byte [] longToByteArray( long s) {

         byte [] targets = new byte [ 2 ];

         for ( int i = 0 ; i < 8 ; i++) {

             int offset = (targets.length - 1 - i) * 8 ;

             targets[i] = ( byte ) ((s >>> offset) & 0xff );

         }

         return targets;

     }

 

     /** 32位int转byte[] */

     public static byte [] int2byte( int res) {

         byte [] targets = new byte [ 4 ];

         targets[ 0 ] = ( byte ) (res & 0xff ); // 最低位

         targets[ 1 ] = ( byte ) ((res >> 8 ) & 0xff ); // 次低位

         targets[ 2 ] = ( byte ) ((res >> 16 ) & 0xff ); // 次高位

         targets[ 3 ] = ( byte ) (res >>> 24 ); // 最高位,无符号右移。

         return targets;

     }

 

     /**

      * 将长度为2的byte数组转换为16位int

      *

      * @param res

      *            byte[]

      * @return int

      * */

     public static int byte2int( byte [] res) {

         // res = InversionByte(res);

         // 一个byte数据左移24位变成0x??000000，再右移8位变成0x00??0000

         int targets = (res[ 0 ] & 0xff ) | ((res[ 1 ] << 8 ) & 0xff00 ); // | 表示安位或

         return targets;

     }

 

     /**

      * byte数组与short数组转换

      *

      * @param data

      * @param items

      * @return

      */

     public static short [] byteArray2ShortArray( byte [] data) {

         if (data == null ) {

             // Log.e(TAG, "byteArray2ShortArray, data = null");

             return null ;

         }

 

         short [] retVal = new short [data.length / 2 ];

         for ( int i = 0 ; i < retVal.length; i++) {

             retVal[i] = ( short ) ((data[i * 2 ] & 0xff ) | (data[i * 2 + 1 ] & 0xff ) << 8 );

         }

 

         return retVal;

     }

 

     /**

      * byte数组与short数组转换

      *

      * @param data

      * @param items

      * @return

      */

     public static byte [] shortArray2ByteArray( short [] data) {

         byte [] retVal = new byte [data.length * 2 ];

         for ( int i = 0 ; i < retVal.length; i++) {

             int mod = i % 2 ;

             if (mod == 0 ) {

                 retVal[i] = ( byte ) (data[i / 2 ]);

             } else {

                 retVal[i] = ( byte ) (data[i / 2 ] >> 8 );

             }

         }

 

         return retVal;

     }

 

     /**

      * 对象转数组

      *

      * @param obj

      * @return

      */

     public static byte [] toByteArray(Object obj) {

         byte [] bytes = null ;

         ByteArrayOutputStream bos = new ByteArrayOutputStream();

         try {

             ObjectOutputStream oos = new ObjectOutputStream(bos);

             oos.writeObject(obj);

             oos.flush();

             bytes = bos.toByteArray();

             oos.close();

             bos.close();

         } catch (IOException ex) {

             ex.printStackTrace();

         }

         return bytes;

     }

 

     /**

      * 数组转对象

      *

      * @param bytes

      * @return

      */

     public static Object toObject( byte [] bytes) {

         Object obj = null ;

         try {

             ByteArrayInputStream bis = new ByteArrayInputStream(bytes);

             ObjectInputStream ois = new ObjectInputStream(bis);

             obj = ois.readObject();

             ois.close();

             bis.close();

         } catch (IOException ex) {

             ex.printStackTrace();

         } catch (ClassNotFoundException ex) {

             ex.printStackTrace();

         }

         return obj;

     }