Android中蓝牙数据和Socket数据发送 ---------二进制、十进制、十六进制串、byte数组、字符串、ASCII之间的相互转化

最新推荐文章于 2023-03-05 15:48:40 发布

ChloeDimen

最新推荐文章于 2023-03-05 15:48:40 发布

阅读量2.3k

点赞数 2

分类专栏：蓝牙

本文链接：https://blog.csdn.net/jim19890923/article/details/85264786

版权

蓝牙专栏收录该内容

2 篇文章 0 订阅

订阅专栏

/**
* byte数组转成字符串
*/
public String btye2Str(byte[] data) {
String str = new String(data);
return str;
}

//byte转HEX

public static String byteToHex(byte b) {
    String hex = Integer.toHexString(b & 0xFF);
    if (hex.length() < 2) {
        hex = "0" + hex;
    }
    return hex;
}

/**
* 将byte数组化为十六进制串
*/

public static final StringBuilder byte2hex(byte[] data) {
StringBuilder stringBuilder = new StringBuilder(data.length);
for (byte byteChar : data) {
stringBuilder.append(String.format("%02X ", byteChar).trim());
}
return stringBuilder;
}

/**
* 将byte数组转化成浮点数（4个字节带小数的浮点数）
*/
public static float byte2int_Float(byte b[]) {
int bits = b[3] & 0xff | (b[2] & 0xff) << 8 | (b[1] & 0xff) << 16
| (b[0] & 0xff) << 24;

int sign = ((bits & 0x80000000) == 0) ? 1 : -1;
int exponent = ((bits & 0x7f800000) >> 23);
int mantissa = (bits & 0x007fffff);

mantissa |= 0x00800000;
// Calculate the result:
float f = (float) (sign * mantissa * Math.pow(2, exponent - 150));

return f;
}

/**
* 将十六进制串转化为byte数组
*/
public static final byte[] hex2byte(String hex) throws IllegalArgumentException {
if (hex.length() % 2 != 0) {
throw new IllegalArgumentException();
}
char[] arr = hex.toCharArray();
byte[] b = new byte[hex.length() / 2];
for (int i = 0, j = 0, l = hex.length(); i < l; i++, j++) {
String swap = "" + arr[i++] + arr[i];
int byteint = Integer.parseInt(swap, 16) & 0xFF;
b[j] = new Integer(byteint).byteValue();
}
return b;
}

/**
* 将十六进制串转换为二进制
* */
public static byte[] parseHexStr2Byte(String hexStr) {
if (hexStr.length() < 1) {
return null;
}
byte[] result = new byte[hexStr.length() / 2];
for (int i = 0; i < hexStr.length() / 2; i++) {
int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
result[i] = (byte) (high * 16 + low);
}
return result;
}
/**

* 将字符串转成ASCII值
*/
public static String strToASCII(String data) {
String requestStr = "";
for (int i = 0; i < data.length(); i++) {
char a = data.charAt(i);
int aInt = (int) a;
requestStr = requestStr + integerToHexString(aInt);
}
return requestStr;
}

//字符串转ASCII
public String convertStringToHex(String str) {

    char[] chars = str.toCharArray();

    StringBuffer hex = new StringBuffer();
    for (int i = 0; i < chars.length; i++) {
        hex.append(Integer.toHexString((int) chars[i]));
    }

    return hex.toString();
}

/**
* 将十进制整数转为十六进制数，并补位
* */
public static String integerToHexString(int s) {
String ss = Integer.toHexString(s);
if (ss.length() % 2 != 0) {
ss = "0" + ss;//0F格式
}
return ss.toUpperCase();
}

/**
* 将二进制转换成十六进制串
* */
public static String parseByte2HexStr(byte buf[]) {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < buf.length; i++) {
String hex = Integer.toHexString(buf[i] & 0xFF);
if (hex.length() == 1) {
hex = '0' + hex;
}
sb.append(hex.toUpperCase());
}
return sb.toString();
}

android中在声明数字时默认采用的是十进制。

//十进制转成十六进制  Integer.toHexString(14);
//十进制转成八进制    Integer.toOctalString(14);
//十进制转成二进制    Integer.toBinaryString(12);

//十六进制转成十进制  Integer.valueOf("FFFF",16).toString();
//十六进制转成二进制   Integer.toBinaryString(Integer.valueOf("FFFF",16));
//十六进制转成八进制  Integer.toOctalString(Integer.valueOf("FFFF",16));

//八进制转成十进制    Integer.valueOf("576",8).toString();
//八进制转成二进制    Integer.toBinaryString(Integer.valueOf("23",8));
//八进制转成十六进制  Integer.toHexString(Integer.valueOf("23",8));

//二进制转十进制      Integer.valueOf("0101",2).toString();
//二进制转八进制        Integer.toOctalString(Integer.parseInt("0101", 2));
//二进制转十六进制    Integer.toHexString(Integer.parseInt("0101", 2));

SOCKET通讯：int32 int64 long
byte[] buffer=new byte[1024];
接收字节数组：index=in.read（buffer,0,buffer.length）;

【高端在前】

//字节数组转int型，高位在前，低位在后  (int 4字节)=（pc端int32默认高位在前）
public static int bytes4ToInt(byte[] src) {
    int value = (int) (
    ((src[0] & 0xFF)<<24)|
               ((src[1] & 0xFF)<<16)|
               ((src[2] & 0xFF)<< 8)|
                (src[3] & 0xFF));
    return value;
}
//int型转byte[]，高位在前，低位在后  (int 4字节)=（pc端int32默认高位在前）
public static byte[] intToBytes4H(int res){
    byte[] targets = new byte[4];
    targets[0] = (byte) (res  >>24 & 0xff);
    targets[1] = (byte) ((res >>16) & 0xff);
    targets[2] = (byte) ((res >> 8) & 0xff);
    targets[3] = (byte) (res & 0xff);
    return targets;
}
//字节数组转long型，高位在前，低位在后  (long 8字节)=（pc端int64默认高位在前）
public static long  byte8TolongH( byte[] buffer ) {
long num= ((buffer[0]&0xff) << 56) +
            ((buffer[1]&0xff) <<48) +
            ((buffer[2]&0xff) <<40) +
            ((buffer[3]&0xff)<<32) +
            ((buffer[4]&0xff)<<24)+
            ((buffer[5]&0xff)<<16) +
            ((buffer[6]&0xff)<<8) +
            (buffer[7]& 0xff);
    return num;
}
//long型转byte[]，高位在前，低位在后  (long 8字节)=（pc端int64默认高位在前）
public static byte[] longTobyte8H(long res) {
    byte[] targets = new byte[8];
    targets[0] = (byte) (res >>> 56 & 0xff);
    targets[1] = (byte) (res >>> 48 & 0xff);
    targets[2] = (byte) (res >>> 40 & 0xff);
    targets[3] = (byte) (res >>> 32 & 0xff);
    targets[4] = (byte) (res >>> 24 & 0xff);
    targets[5] = (byte) ((res >> 16)& 0xff);
    targets[6] = (byte) ((res >> 8) & 0xff);
    targets[7] = (byte) (res & 0xff);
    return targets;
}

【低端在前】

//字节数组转int型，低位在前，高位在后  (int 4字节)=（pc端int32默认高位在前）
public static int bytes4ToInt(byte[] src) {
    int value = (int) (
    ((src[0] & 0xFF))|
               ((src[1] & 0xFF)<< 8)|
               ((src[2] & 0xFF)<<16)|
                (src[3] & 0xFF)<<24);
    return value;
}
//int型转byte[]，低位在前，高位在后  (int 4字节)=（pc端int32默认高位在前）
public static byte[] intToBytes4L(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) & 0xff);
    return targets;
}
//字节数组转long型，低位在前，高位在后  (long 8字节)=（pc端int64默认高位在前）
public static long  byte8TolongL( byte[] buffer ) {
   long num=  (buffer[0]& 0xff) +
              ((buffer[1]&0xff) <<8) +
              ((buffer[2]&0xff) <<16) +
              ((buffer[3]&0xff) <<24)+
              ((buffer[4]&0xff) <<32) +
              ((buffer[5]&0xff) <<40) +
              ((buffer[6]&0xff) <<48) +
              ((buffer[7]&0xff) << 56);
  return num;
}
//long型转byte[]，低位在前，高位在后  (long 8字节)=（pc端int64默认高位在前）
public static byte[] longTobyte8L(long res) {
byte[] targets = new byte[8];
targets[0] = (byte) (res & 0xff);
targets[1] = (byte) ((res >> 8) & 0xff);
targets[2] = (byte) ((res >> 16)& 0xff);
targets[3] = (byte) (res >>> 24 & 0xff);
targets[4] = (byte) (res >>> 32 & 0xff);
targets[5] = (byte) (res >>> 40 & 0xff);
targets[6] = (byte) (res >>> 48 & 0xff);
targets[7] = (byte) (res >>> 56 & 0xff);
   return targets;
}
【Byte[] ---- HexString】如串口通信

//byte[]转换成hexString字符串,无符号。每个Byte之间无空格分隔。字母小写
public static String Bytes2HexString(byte[] b, int size){
//size==b.length,toUpperCase()将字符串小写字符转换为大写,toLowerCase()将字符串大写字符转换为小写
     String ret = "";
     for (int i = 0; i < size; i++) {
       String hex = Integer.toHexString(b[i] & 0xFF);
       if (hex.length() == 1) {
    hex = "0" + hex;
   }
       ret += hex.toUpperCase();
     }
     return ret;
   }

//HexString字符串转换成byte[]无符号。每个Byte之间无空格分隔。
public static byte[] HexString2Bytes(String src) {
int len = src.length() / 2;
byte[] ret = new byte[len];
byte[] tmp = src.getBytes();
for (int i = 0; i < len; i++) {
ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1]);
}
return ret;
}
public static byte uniteBytes(byte src0, byte src1) {
byte _b0 = Byte.decode("0x" + new String(new byte[]{src0})).byteValue();
_b0 = (byte)(_b0 << 4);
byte _b1 = Byte.decode("0x" + new String(new byte[]{src1})).byteValue();
byte ret = (byte)(_b0 ^ _b1);
return ret;
}

【String ---- HexString】

//String字符串转换成hexString字符串,无符号。每个Byte之间无空格分隔。如“name”
public static String str2HexStr(String str) {
char[] chars = "0123456789ABCDEF".toCharArray();
StringBuilder sb = new StringBuilder("");
byte[] bs = str.getBytes();
int bit;
for (int i = 0; i < bs.length; i++) {
  bit = (bs[i] & 0x0f0) >> 4;
  sb.append(chars[bit]);
  bit = bs[i] & 0x0f;
  sb.append(chars[bit]);
  //sb.append(' ');//有符号，每个Byte之间用空格分隔
}
return sb.toString().trim();
}
//无符号hexString字符串,转换成String字符串。每个Byte之间无空格分隔。
public static String hexStr2Str(String hexStr) {
String info="";
String str = "0123456789ABCDEF";
char[] hexs = hexStr.toCharArray();
byte[] bytes = new byte[hexStr.length() / 2];
int n;
for (int i = 0; i < bytes.length; i++) {
  n = str.indexOf(hexs[2 * i]) * 16;
  n += str.indexOf(hexs[2 * i + 1]);
  bytes[i] = (byte) (n & 0xff);
}
return new String(bytes);
}
---------------------
作者：qq_34075348
来源：CSDN
原文：https://blog.csdn.net/qq_34075348/article/details/81222610
版权声明：本文为博主原创文章，转载请附上博文链接！