android中的byte数组转换

最新推荐文章于 2024-08-09 15:12:40 发布

转载最新推荐文章于 2024-08-09 15:12:40 发布 · 653 阅读

文章标签：

本文介绍了一系列实用的方法来实现不同数据类型之间的转换，包括单字节到32位整数、单字节到十六进制数、4字节数组到32位整数等转换函数。同时，还提供了将16位short、32位int及long转换为byte数组的方法，以及byte数组与short数组之间的相互转换。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

/**

     *
 将一个单字节的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;

    }