package com.walker.tcp.util;
|
|
import java.math.BigInteger;
|
import java.text.DecimalFormat;
|
|
public class ByteUtils {
|
|
/**
|
* 2进制
|
*
|
* @param b
|
* @return
|
*/
|
public static String toBinary(byte b) {
|
StringBuilder stringBuilder = new StringBuilder();
|
String val = ByteUtils.byteToHexString(b);
|
BigInteger integer = new BigInteger(val, 16);
|
stringBuilder.append(integer.toString(2));
|
while (stringBuilder.length() < 8) {
|
stringBuilder.insert(0, "0");
|
}
|
return stringBuilder.toString();
|
}
|
|
/**
|
* 获取高四位
|
* @param data
|
* @return
|
*/
|
public static int getHeight4(byte data){
|
int height;
|
height = ((data & 0xf0) >> 4);
|
return height;
|
}
|
|
/**
|
* 获取低四位
|
* @param data
|
* @return
|
*/
|
public static int getLow4(byte data){
|
int low;
|
low = (data & 0x0f);
|
return low;
|
}
|
/**
|
* 去除int最高位
|
*
|
* @param val
|
* @return
|
*/
|
public static int delH(int val) {
|
return val = (val << 1 & 0xff) >>> 1;
|
}
|
|
public static String byteToHexString(byte src) {
|
StringBuilder stringBuilder = new StringBuilder("");
|
int v = src & 0xFF;
|
String hv = Integer.toHexString(v);
|
if (hv.length() < 2) {
|
stringBuilder.append(0);
|
}
|
stringBuilder.append(hv);
|
return stringBuilder.toString();
|
}
|
|
/**
|
* Convert byte[] to hex string. 把字节数组转化为字符串
|
*
|
* @param src
|
* @param begin
|
* byte[] 起始位置
|
* @param len
|
* 长度
|
* @return
|
*/
|
public static String bytesToHexString(byte[] src, int begin, int len) {
|
StringBuilder stringBuilder = new StringBuilder("");
|
if (src == null || src.length <= 0) {
|
return null;
|
}
|
// 这里我们可以将byte转换成int，然后利用Integer.toHexString(int)来转换成16进制字符串。
|
int end = begin + len;
|
for (int i = begin; i < end; i++) {
|
int v = src[i] & 0xFF;
|
String hv = Integer.toHexString(v);
|
if (hv.length() < 2) {
|
stringBuilder.append(0);
|
}
|
stringBuilder.append(hv);
|
}
|
return stringBuilder.toString();
|
}
|
|
/**
|
* Convert byte[] to hex string. 把字节数组转化为字符串
|
*
|
*
|
* @param src
|
* byte[]
|
* @return hex string
|
*/
|
public static String bytesToHexString(byte[] src) {
|
StringBuilder stringBuilder = new StringBuilder("");
|
if (src == null || src.length <= 0) {
|
return null;
|
}
|
// 这里我们可以将byte转换成int，然后利用Integer.toHexString(int)来转换成16进制字符串。
|
for (int i = 0; i < src.length; i++) {
|
int v = src[i] & 0xFF;
|
String hv = Integer.toHexString(v);
|
if (hv.length() < 2) {
|
stringBuilder.append(0);
|
}
|
stringBuilder.append(hv);
|
}
|
return stringBuilder.toString();
|
}
|
|
/**
|
* 空格分隔
|
* @param src
|
* @return
|
*/
|
public static String bytesToHexString2(byte[] src) {
|
StringBuilder stringBuilder = new StringBuilder("");
|
if (src == null || src.length <= 0) {
|
return null;
|
}
|
// 这里我们可以将byte转换成int，然后利用Integer.toHexString(int)来转换成16进制字符串。
|
for (int i = 0; i < src.length; i++) {
|
int v = src[i] & 0xFF;
|
String hv = Integer.toHexString(v);
|
if (hv.length() < 2) {
|
stringBuilder.append(0);
|
}
|
stringBuilder.append(hv).append(" ");
|
}
|
return stringBuilder.toString();
|
}
|
|
/**
|
* 字节数组转成16进制表示格式的字符串
|
*
|
* @param byteArray
|
* 需要转换的字节数组
|
* @return 16进制表示格式的字符串
|
**/
|
public static String toHexString(byte[] byteArray) {
|
if (byteArray == null || byteArray.length < 1)
|
throw new IllegalArgumentException("this byteArray must not be null or empty");
|
|
final StringBuilder hexString = new StringBuilder();
|
for (int i = 0; i < byteArray.length; i++) {
|
if ((byteArray[i] & 0xff) < 0x10)//0~F前面不零
|
hexString.append("0");
|
hexString.append(Integer.toHexString(0xFF & byteArray[i]));
|
}
|
return hexString.toString().toLowerCase();
|
}
|
|
|
/**
|
* Convert byte[] to hex string[]. 把字节数组转化为字符串数组
|
*
|
*/
|
public static String[] bytesToHexStrings(byte[] src) {
|
String s = bytesToHexString(src);
|
String[] ss = new String[src.length];
|
for (int j = 0; j < ss.length; j++) {
|
ss[j] = s.substring(2 * j, 2 * (j + 1));
|
}
|
return ss;
|
}
|
|
/**
|
* Convert hex string to byte[] 把字符串转化为字节数组
|
*
|
* @param hexString
|
* the hex string, 两位string一个byte, 允许有空格分隔
|
* @return byte[]
|
*/
|
public static byte[] hexStringToBytes(String hexString) {
|
if (hexString == null || hexString.equals("")) {
|
return null;
|
}
|
hexString = hexString.replaceAll(" ", "");
|
hexString = hexString.toUpperCase();
|
int length = hexString.length() / 2;
|
char[] hexChars = hexString.toCharArray();
|
byte[] d = new byte[length];
|
for (int i = 0; i < length; i++) {
|
int pos = i * 2;
|
d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
|
}
|
|
|
return d;
|
}
|
|
// ------------
|
|
/**
|
* 将 10进制int 转换为占一个字节的hexString
|
*
|
* @param src
|
* @return
|
*/
|
public static String int2HexString(int src) {
|
StringBuilder stringBuilder = new StringBuilder();
|
String hv = Integer.toHexString(src);
|
if (hv.length() < 2) {
|
stringBuilder.append(0);
|
}
|
stringBuilder.append(hv);
|
return stringBuilder.toString();
|
|
}
|
|
/**
|
* 将10进制int转换为占2个字节的hexString(低字节在前)
|
*
|
* @param src
|
* @return
|
*/
|
public static String intToHexString(int src) {
|
byte[] b = ByteUtils.toBytes(src);
|
return ByteUtils.bytesToHexString(b);
|
}
|
/**
|
* 将10进制int转换为占2个字节的hexString(高字节在前)
|
*
|
* @param src
|
* @return
|
*/
|
public static String intToHexStringH(int src) {
|
byte[] b = ByteUtils.toBytesH(src);
|
return ByteUtils.bytesToHexString(b);
|
}
|
|
/**
|
* 将10进制String 转换为占2个字节的hexString(低位在前)
|
*
|
* @param src
|
* @return
|
*/
|
public static String toHexString(String src) {
|
return intToHexString(Integer.valueOf(src));
|
}
|
|
/**
|
* 将10进制int转换为占4个字节的hexString
|
*
|
* @param src
|
* @return
|
*/
|
public static String intTo4HexString(int src) {
|
return ByteUtils.bytesToHexString(ByteUtils.intToBytes(src));
|
|
}
|
|
/**
|
* int -> byte[iArrayLen]
|
*
|
* @param iSource
|
* @param iArrayLen
|
* <=4
|
* @return
|
*/
|
public static byte[] toByteArray(int iSource, int iArrayLen) {
|
byte[] bLocalArr = new byte[iArrayLen];
|
for (int i = 0; i < iArrayLen; i++) {
|
// bLocalArr[i] = (byte) (iSource >> 8 * (iArrayLen - i - 1) &
|
// 0xFF);
|
bLocalArr[i] = (byte) (iSource >> 8 * i);
|
}
|
return bLocalArr;
|
}
|
|
/**
|
* int -> byte[2]
|
*
|
* @param
|
* @return 低位在前
|
*/
|
public static byte[] toBytes(int v) {
|
byte[] targets = new byte[2];
|
targets[0] = (byte) (0xff & v);
|
targets[1] = (byte) (0xff & (v >> 8));
|
return targets;
|
}
|
/**
|
* int -> byte[2]
|
*
|
* @param
|
* @return 高位在前
|
*/
|
public static byte[] toBytesH(int v) {
|
byte[] targets = new byte[2];
|
targets[1] = (byte) (0xff & v);
|
targets[0] = (byte) (0xff & (v >> 8));
|
return targets;
|
}
|
|
/**
|
* int -> byte[4]
|
* 低位在前
|
*
|
* @param num
|
* @return
|
*/
|
public static byte[] intToBytes(int num) {
|
byte[] targets = new byte[4];
|
|
targets[0] = (byte) (num & 0xff);// 最低位
|
targets[1] = (byte) ((num >> 8) & 0xff);// 次低位
|
targets[2] = (byte) ((num >> 16) & 0xff);// 次高位
|
targets[3] = (byte) (num >>> 24);// 最高位,无符号右移。
|
return targets;
|
}
|
|
/**
|
* 低位在前 ，3位的byte[] 转 int
|
*
|
* @return
|
*/
|
public static int toInt3(byte[] bs, int begain) {
|
int accum = 0;
|
accum = bs[begain + 0] & 0xFF;
|
accum |= (bs[begain + 1] & 0xFF) << 8;
|
accum |= (bs[begain + 2] & 0xFF) << 16;
|
return accum;
|
}
|
|
/**
|
* 低位在前 ，4位的byte 转 int
|
*
|
* @param bs
|
* 低位在前 byte数组
|
* @return
|
*/
|
public static int toInt4(byte[] bs) {
|
int accum = 0;
|
accum = bs[0] & 0xFF;
|
accum |= (bs[1] & 0xFF) << 8;
|
accum |= (bs[2] & 0xFF) << 16;
|
accum |= (bs[3] & 0xFF) << 24;
|
return accum;
|
}
|
|
/**
|
* 获取 高位在前的4位byte int值<br>
|
*
|
* @param bs
|
* 高位在前 byte数组
|
* @return
|
*/
|
public static int toIntByH(byte[] bs, int start) {
|
int accum = 0;
|
accum = bs[start + 3] & 0xFF;
|
accum |= (bs[start + 2] & 0xFF) << 8;
|
accum |= (bs[start + 1] & 0xFF) << 16;
|
accum |= (bs[start + 0] & 0xFF) << 24;
|
return accum;
|
}
|
|
/**
|
* 将低位在前 ，4位的byte 转 int
|
*
|
* @param bs
|
* byte数组
|
* @param pos
|
* 起始位置
|
* @return
|
*/
|
public static int toInt4(byte[] bs, int pos) {
|
int accum = 0;
|
accum = bs[pos + 0] & 0xFF;
|
accum |= (bs[pos + 1] & 0xFF) << 8;
|
accum |= (bs[pos + 2] & 0xFF) << 16;
|
accum |= (bs[pos + 3] & 0xFF) << 24;
|
return accum;
|
}
|
|
/**
|
* 低位在前 的 byte[2] 转 int, int*0.01转成double并保留两位小数
|
*
|
* @param res
|
* @param begainIdx
|
* 起始位置
|
* @return
|
*/
|
public static double toDouble(byte[] res, int begainIdx) {
|
Double data = toInt2(res, begainIdx) * 0.01;
|
DecimalFormat bd = new DecimalFormat("#.00");
|
data = Double.valueOf( bd.format(data) );
|
|
return data;
|
}
|
/**
|
* 低位在前 的 byte[2] 转 int
|
*
|
* @param res
|
* @param begainIdx
|
* 起始位置
|
* @return
|
*/
|
public static int toInt2(byte[] res, int begainIdx) {
|
// 一个byte数据左移24位变成0x??000000，再右移8位变成0x00??0000
|
int targets = (res[begainIdx] & 0xff) | ((res[begainIdx + 1] << 8) & 0xff00);
|
|
return targets;
|
}
|
|
/**
|
* byte[] 转 int
|
*
|
* @param res
|
* 低位在前 ，2位的byte数组
|
* @return
|
*/
|
public static int toInt2(byte[] res) {
|
// 一个byte数据左移24位变成0x??000000，再右移8位变成0x00??0000
|
int targets = (res[0] & 0xff) | ((res[1] << 8) & 0xff00); // | 表示安位或
|
return targets;
|
}
|
|
/**
|
* Convert char to byte
|
*
|
* @param c
|
* char
|
* @return byte
|
*/
|
private static byte charToByte(char c) {
|
return (byte) "0123456789ABCDEF".indexOf(c);
|
}
|
|
/**
|
* 获取接收到的信息中的指令码
|
*
|
* @param msg
|
* 接收到的信息
|
* @return
|
*/
|
public static String getMsgCmd(byte[] msg) {
|
byte[] cmd = { msg[6], msg[7] };
|
return bytesToHexString(cmd);
|
}
|
|
/**
|
* 返回命令字符串，如：106
|
* @param cmdArea
|
* @return
|
* @author 时克英
|
* @date 2020-08-20
|
*/
|
public static String getCommand(byte[] cmdArea){
|
return bytesToHexString(cmdArea);
|
}
|
|
/**
|
* 将i进制字符串转换成j进制字符串
|
*
|
* @param str
|
* @param i
|
* @param j
|
*/
|
public static String itoj(String str, int i, int j) {
|
String[] strs = str.split("\\s+");
|
String result = "";
|
for (String string : strs) {
|
String hex = Integer.toString(Integer.parseInt(string, i), j);
|
result += hex;
|
}
|
return result;
|
}
|
|
public static void main(String[] args){
|
byte[] b = new byte[] { (byte) 0xAA, (byte) 0xf5 };
|
int i = ByteUtils.toInt2(b);
|
System.out.println("byte[] value = " + i);
|
}
|
}
|
