进制的总结

(a & 0xf0) >> 4 字节的高四位
a & 0x0f 字节的低四位

//十进制转成十六进制 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);
}