package com.fastbee.common.utils.gateway.protocol;
|
|
|
import com.fastbee.common.exception.ServiceException;
|
import org.apache.commons.lang3.ArrayUtils;
|
import org.apache.commons.lang3.StringUtils;
|
|
import java.io.ByteArrayOutputStream;
|
import java.io.DataOutputStream;
|
import java.io.IOException;
|
import java.nio.ByteOrder;
|
import java.nio.charset.Charset;
|
import java.nio.charset.StandardCharsets;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.List;
|
import java.util.UUID;
|
|
|
public class ByteUtils {
|
|
|
// public static Payload resolvePayload(byte[] content, short start, ModbusCode code) {
|
// Payload payload;
|
// switch (code) {
|
// case Read01:
|
// case Read02:
|
// payload = new RealCoilPayload(start, content); break;
|
// case Read03:
|
// case Read04:
|
// payload = new ReadPayload(content, start); break;
|
// default:
|
// payload = WritePayload.getInstance();
|
// }
|
//
|
// return payload;
|
// }
|
|
public static Write10Build write10Build(Object... args) {
|
int num = 0; List<byte[]> bytes = new ArrayList<>();
|
for(Object arg : args) {
|
if(arg instanceof Integer) {
|
num += 2;
|
bytes.add(getBytes((Integer) arg));
|
} else if(arg instanceof Long) {
|
num += 4;
|
bytes.add(getBytes((Long) arg));
|
} else if(arg instanceof Float) {
|
num += 2;
|
bytes.add(getBytes((Float) arg));
|
} else if(arg instanceof Double) {
|
num += 4;
|
bytes.add(getBytes((Double) arg));
|
} else if(arg instanceof Short) {
|
num += 1;
|
bytes.add(getBytesOfReverse((Short) arg));
|
} else if(arg instanceof Byte) {
|
num += 1;
|
bytes.add(new byte[]{0x00, (byte) arg});
|
} else if(arg instanceof String) {
|
byte[] bytes1 = arg.toString().getBytes(StandardCharsets.UTF_8);
|
if(bytes1.length % 2 != 0) {
|
num += bytes1.length / 2 + 1;
|
byte[] addMessage = new byte[bytes1.length + 1];
|
addBytes(addMessage, bytes1, 0);
|
bytes.add(addMessage);
|
} else {
|
num += bytes1.length / 2;
|
bytes.add(bytes1);
|
}
|
} else {
|
throw new ServiceException("不支持的数据类型");
|
}
|
}
|
|
Integer length = bytes.stream().map(item -> item.length).reduce((a, b) -> a + b).get();
|
byte[] write = new byte[length];
|
|
int index = 0;
|
for(int i=0; i<bytes.size(); i++) {
|
byte[] values = bytes.get(i);
|
addBytes(write, values, index);
|
index += values.length;
|
}
|
|
return new Write10Build(num, write);
|
}
|
|
public static class Write10Build {
|
public int num;
|
public byte[] message;
|
|
public Write10Build(int num, byte[] message) {
|
this.num = num;
|
this.message = message;
|
}
|
}
|
|
public static byte[] create(byte b){
|
return new byte[]{b};
|
}
|
|
/**
|
* 字节转成字节数组
|
* @param data
|
* @return
|
*/
|
public static byte[] getBytes(byte data) {
|
return new byte[] {data};
|
}
|
|
/**
|
* 将short数据类型转化成Byte数组
|
* @see ByteOrder#LITTLE_ENDIAN
|
* @param data short值
|
* @return byte[]数组
|
*/
|
public static byte[] getBytes(short data) {
|
byte[] bytes = new byte[2];
|
bytes[0] = (byte) (data & 0xff);
|
bytes[1] = (byte) ((data & 0xff00) >> 8);
|
return bytes;
|
}
|
|
/**
|
* 将short数据类型转化成Byte数组
|
* @see ByteOrder#BIG_ENDIAN
|
* @param data short值
|
* @return byte[]数组
|
*/
|
public static byte[] getBytesOfReverse(short data) {
|
byte[] bytes = new byte[2];
|
bytes[1] = (byte) (data & 0xff);
|
bytes[0] = (byte) ((data & 0xff00) >> 8);
|
return bytes;
|
}
|
|
/**
|
* @see ByteOrder#LITTLE_ENDIAN
|
* @param bytes
|
* @param offset
|
* @return
|
*/
|
public static short bytesToShort(byte[] bytes, int offset) {
|
return (short) ((0xff & bytes[0 + offset]) | (0xff00 & (bytes[1 + offset] << 8)));
|
}
|
|
/**
|
* 将字节数组转换成short数据
|
* @see ByteOrder#BIG_ENDIAN
|
* @param bytes 字节数组
|
* @return short值
|
*/
|
public static short bytesToShortOfReverse(byte[] bytes) {
|
return ByteUtils.bytesToShortOfReverse(bytes, 0);
|
}
|
|
/**
|
* 将字节数组转换成short数据，采用倒序的表达方式
|
* @param bytes 字节数组
|
* @param offset 起始位置
|
* @return short值
|
*/
|
public static short bytesToShortOfReverse(byte[] bytes, int offset) {
|
return (short) ((0xff & bytes[1 + offset]) | (0xff00 & (bytes[0 + offset] << 8)));
|
}
|
|
/**
|
* 将int数据类型转化成Byte数组
|
* @see ByteOrder#LITTLE_ENDIAN
|
* @param data int值
|
* @return byte[]数组
|
*/
|
public static byte[] getBytes(int data) {
|
byte[] bytes = new byte[4];
|
bytes[0] = (byte) (data & 0xff);
|
bytes[1] = (byte) ((data >> 8) & 0xff);
|
bytes[2] = (byte) ((data >> 16) & 0xff);
|
bytes[3] = (byte) ((data >> 24) & 0xff);
|
return bytes;
|
}
|
|
/**
|
* 将int数据类型转化成Byte数组 倒序
|
* @see ByteOrder#BIG_ENDIAN
|
* @param data int值
|
* @return byte[]数组
|
*/
|
public static byte[] getBytesOfReverse(int data) {
|
byte[] src = new byte[4];
|
src[0] = (byte) ((data >> 24) & 0xFF);
|
src[1] = (byte) ((data >> 16) & 0xFF);
|
src[2] = (byte) ((data >> 8) & 0xFF);
|
src[3] = (byte) (data & 0xFF);
|
return src;
|
}
|
|
/**
|
* 将long数据类型转化成Byte数组
|
* @see ByteOrder#LITTLE_ENDIAN
|
* @param data long值
|
* @return byte[]数组
|
*/
|
public static byte[] getBytes(long data) {
|
byte[] bytes = new byte[8];
|
bytes[0] = (byte) (data & 0xff);
|
bytes[1] = (byte) ((data >> 8) & 0xff);
|
bytes[2] = (byte) ((data >> 16) & 0xff);
|
bytes[3] = (byte) ((data >> 24) & 0xff);
|
bytes[4] = (byte) ((data >> 32) & 0xff);
|
bytes[5] = (byte) ((data >> 40) & 0xff);
|
bytes[6] = (byte) ((data >> 48) & 0xff);
|
bytes[7] = (byte) ((data >> 56) & 0xff);
|
return bytes;
|
}
|
|
/**
|
* 将long数据类型转化成Byte数组 倒序
|
* @see ByteOrder#BIG_ENDIAN
|
* @param data long值
|
* @return byte[]数组
|
*/
|
public static byte[] getBytesOfReverse(long data) {
|
byte[] bytes = new byte[8];
|
bytes[7] = (byte) (data & 0xff);
|
bytes[6] = (byte) ((data >> 8) & 0xff);
|
bytes[5] = (byte) ((data >> 16) & 0xff);
|
bytes[4] = (byte) ((data >> 24) & 0xff);
|
bytes[3] = (byte) ((data >> 32) & 0xff);
|
bytes[2] = (byte) ((data >> 40) & 0xff);
|
bytes[1] = (byte) ((data >> 48) & 0xff);
|
bytes[0] = (byte) ((data >> 56) & 0xff);
|
return bytes;
|
}
|
|
/**
|
* 将float数据类型转化成Byte数组
|
* @see ByteOrder#LITTLE_ENDIAN
|
* @param data float值
|
* @return byte[]数组
|
*/
|
public static byte[] getBytes(float data) {
|
int intBits = Float.floatToIntBits(data);
|
return getBytes(intBits);
|
}
|
|
/**
|
* 将float数据类型转化成Byte数组 倒序
|
* @see ByteOrder#BIG_ENDIAN
|
* @param data float值
|
* @return byte[]数组
|
*/
|
public static byte[] getBytesOfReverse(float data) {
|
int intBits = Float.floatToIntBits(data);
|
return getBytesOfReverse(intBits);
|
}
|
|
/**
|
* 将double数据类型转化成Byte数组
|
* @see ByteOrder#LITTLE_ENDIAN
|
* @param data double值
|
* @return byte[]数组
|
*/
|
public static byte[] getBytes(double data) {
|
long intBits = Double.doubleToLongBits(data);
|
return getBytes(intBits);
|
}
|
|
/**
|
* 将double数据类型转化成Byte数组 倒序
|
* @see ByteOrder#BIG_ENDIAN
|
* @param data double值
|
* @return byte[]数组
|
*/
|
public static byte[] getBytesOfReverse(double data) {
|
long intBits = Double.doubleToLongBits(data);
|
return getBytesOfReverse(intBits);
|
}
|
|
/**
|
* 字符串转字节数组(UTF-8)
|
* @param data
|
* @return
|
*/
|
public static byte[] getBytes(String data) {
|
return data.getBytes(StandardCharsets.UTF_8);
|
}
|
|
/**
|
* 将字符串转换成byte[]数组
|
* @param data 字符串值
|
* @param charsetName 编码方式
|
* @return 字节数组
|
*/
|
public static byte[] getBytes(String data, String charsetName) {
|
Charset charset = Charset.forName(charsetName);
|
return data.getBytes(charset);
|
}
|
|
/*
|
* 把16进制字符串转换成字节数组
|
* @param hex
|
* @return
|
*/
|
public static byte[] hexToByte(String hexStr) {
|
if(StringUtils.isBlank(hexStr)) {
|
return null;
|
}
|
if(hexStr.length()%2 != 0) {//长度为单数
|
hexStr = "0" + hexStr;//前面补0
|
}
|
|
char[] chars = hexStr.toCharArray();
|
int len = chars.length/2;
|
byte[] bytes = new byte[len];
|
for (int i = 0; i < len; i++) {
|
int x = i*2;
|
bytes[i] = (byte)Integer.parseInt(String.valueOf(new char[]{chars[x], chars[x+1]}), 16);
|
}
|
return bytes;
|
|
}
|
|
public static byte getByte(byte[] src, int offset) {
|
return src[offset];
|
}
|
|
/**
|
* 字节数组转16进制
|
* @param bArray
|
* @return
|
*/
|
public static final String bytesToHex(byte[] bArray) {
|
StringBuffer sb = new StringBuffer(bArray.length);
|
String sTemp;
|
for (int i = 0; i < bArray.length; i++) {
|
sTemp = Integer.toHexString(0xFF & bArray[i]);
|
if (sTemp.length() < 2) sb.append(0);
|
sb.append(sTemp.toUpperCase());
|
}
|
return sb.toString();
|
}
|
|
/**
|
* 字节数组转16进制且格式化十六进制
|
* @param bArray
|
* @return
|
*/
|
public static final String bytesToHexByFormat(byte[] bArray) {
|
StringBuffer sb = new StringBuffer(bArray.length);
|
String sTemp;
|
for (int i = 0; i < bArray.length; i++) {
|
sTemp = Integer.toHexString(0xFF & bArray[i]);
|
if (sTemp.length() < 2) sb.append(0);
|
sb.append(sTemp.toUpperCase()).append(' ');
|
}
|
return sb.toString();
|
}
|
|
/**
|
* 字节数组转16进制
|
* @param src
|
* @return
|
*/
|
public static final String bytesToHex(byte[] src, int offset, int length) {
|
byte[] bArray = ArrayUtils.subarray(src, offset, offset + length);
|
return bytesToHex(bArray);
|
}
|
|
public static final String byteToHex(byte value) {
|
String s = Integer.toHexString(0xff & value);
|
if(s.length() == 1) return "0"+s;
|
return s;
|
}
|
|
public static final String shortToHex(short value) {
|
String s = Integer.toHexString(value);
|
switch (s.length()) {
|
case 1: return "000" + s;
|
case 2: return "00" + s;
|
case 3: return "0" + s;
|
default: return s;
|
}
|
}
|
|
public static final String intToHex(int value) {
|
StringBuilder s = new StringBuilder(Integer.toHexString(value));
|
String v1 = s.toString().replace("f","");
|
if (v1.length() <4){
|
for (int i = 0; i < 4 - v1.length(); i++) {
|
s.insert(0, "0");
|
}
|
return s.toString().replace("f","");
|
}
|
else return s.toString().replace("f","");
|
}
|
|
public static final String hexTo8Bit(int value,int index){
|
String s = Integer.toBinaryString(value);
|
StringBuilder result = new StringBuilder(s);
|
if (s.length() < index){
|
for (int i = 0; i < index - s.length(); i++) {
|
result.insert(0,"0");
|
}
|
}
|
return result.toString();
|
}
|
|
/**
|
* @函数功能: BCD码转为10进制串(阿拉伯数据)
|
* @输入参数: BCD码
|
* @输出结果: 10进制串
|
*/
|
public static String bcdToStr(byte[] bytes){
|
StringBuffer temp=new StringBuffer(bytes.length*2);
|
|
for(int i=0;i<bytes.length;i++){
|
temp.append((byte)((bytes[i] & 0xf0)>>>4));
|
temp.append((byte)(bytes[i] & 0x0f));
|
}
|
|
return temp.toString();
|
}
|
|
/**
|
*
|
* @param src 原报文
|
* @param offset 起始位置
|
* @param length 长度
|
* @return
|
*/
|
public static String bcdToStr(byte[] src, int offset, int length){
|
byte[] bArray = ArrayUtils.subarray(src, offset, offset + length);
|
return bcdToStr(bArray);
|
}
|
|
public static byte[] str2Bcd(String asc) {
|
int len = asc.length();
|
int mod = len % 2;
|
|
if (mod != 0) {
|
asc = "0" + asc;
|
len = asc.length();
|
}
|
|
byte abt[];
|
if (len >= 2) {
|
len = len / 2;
|
}
|
|
byte bbt[] = new byte[len];
|
abt = asc.getBytes();
|
int j, k;
|
|
for (int p = 0; p < asc.length()/2; p++) {
|
if ( (abt[2 * p] >= '0') && (abt[2 * p] <= '9')) {
|
j = abt[2 * p] - '0';
|
} else if ( (abt[2 * p] >= 'a') && (abt[2 * p] <= 'z')) {
|
j = abt[2 * p] - 'a' + 0x0a;
|
} else {
|
j = abt[2 * p] - 'A' + 0x0a;
|
}
|
|
if ( (abt[2 * p + 1] >= '0') && (abt[2 * p + 1] <= '9')) {
|
k = abt[2 * p + 1] - '0';
|
} else if ( (abt[2 * p + 1] >= 'a') && (abt[2 * p + 1] <= 'z')) {
|
k = abt[2 * p + 1] - 'a' + 0x0a;
|
}else {
|
k = abt[2 * p + 1] - 'A' + 0x0a;
|
}
|
|
int a = (j << 4) + k;
|
byte b = (byte) a;
|
bbt[p] = b;
|
}
|
return bbt;
|
}
|
|
private static byte toByte(char c) {
|
return (byte) c;
|
}
|
|
/**
|
* 将字节数组转换成 ushort 数据
|
* @param bytes 字节数组
|
* @param offset 起始位置
|
* @return short值
|
*/
|
public static int bytesToUShort(byte[] bytes, int offset) {
|
return ((0xff & bytes[0 + offset]) | (0xff00 & (bytes[1 + offset] << 8)));
|
}
|
|
/**
|
* 将字节数组转换成 ushort 数据，采用倒序的方式
|
* @param bytes 字节数组
|
* @return short值
|
*/
|
public static int bytesToUShortOfReverse(byte[] bytes) {
|
return ByteUtils.bytesToShortOfReverse(bytes, 0);
|
}
|
|
/**
|
* 将字节数组转换成 ushort 数据，采用倒序的方式
|
* @param bytes 字节数组
|
* @param offset 起始位置
|
* @return short值
|
*/
|
public static int bytesToUShortOfReverse(byte[] bytes, int offset) {
|
return ((0xff & bytes[1 + offset]) | (0xff00 & (bytes[0 + offset] << 8)));
|
}
|
|
/**
|
* byte数组中取int数值，本方法适用于(低位在前，高位在后)的顺序，和intToBytes配套使用
|
*
|
* @param src
|
* byte数组
|
* @param offset
|
* 从数组的第offset位开始
|
* @return int数值
|
*/
|
public static int bytesToInt(byte[] src, int offset) {
|
return ((src[offset] & 0xFF) | ((src[offset + 1] & 0xFF) << 8)
|
| ((src[offset + 2] & 0xFF) << 16) | ((src[offset + 3] & 0xFF) << 24));
|
}
|
|
/**
|
* byte数组中取int数值，本方法适用于(低位在前，高位在后)的顺序，和intToBytes配套使用
|
* @param src byte数组
|
* @return int数值
|
*/
|
public static int bytesToInt(byte[] src) {
|
return ByteUtils.bytesToInt(src, 0);
|
}
|
|
/**
|
* 将字节数组转换成int数据，采用倒序的方式
|
* @param bytes 字节数组
|
* @param offset 起始位置
|
* @return int值
|
*/
|
public static int bytesToIntOfReverse(byte[] bytes, int offset) {
|
return (0xff & bytes[3 + offset]) |
|
(0xff00 & (bytes[2 + offset] << 8)) |
|
(0xff0000 & (bytes[1 + offset] << 16)) |
|
(0xff000000 & (bytes[0 + offset] << 24));
|
}
|
|
/**
|
* 将字节数组转换成int数据，采用倒序的方式
|
* @param bytes 字节数组
|
* @return int值
|
*/
|
public static int bytesToIntOfReverse(byte[] bytes) {
|
return ByteUtils.bytesToIntOfReverse(bytes, 0);
|
}
|
|
/**
|
* 将字节数组转换成uint数据
|
* @param bytes 字节数组
|
* @param offset 起始位置
|
* @return int值
|
*/
|
public static long bytesToUInt(byte[] bytes, int offset) {
|
int value = bytesToInt(bytes, offset);
|
if (value >= 0) return value;
|
return 65536L * 65536L + value;
|
}
|
|
/**
|
* 将字节数组转换成uint数据
|
* @param bytes 字节数组
|
* @return int值
|
*/
|
public static long bytesToUInt(byte[] bytes) {
|
return ByteUtils.bytesToUInt(bytes, 0);
|
}
|
|
/**
|
* 将字节数组转换成uint数据
|
* @param bytes 字节数组
|
* @param offset 起始位置
|
* @return int值
|
*/
|
public static long bytesToUIntOfReverse(byte[] bytes, int offset) {
|
int value = bytesToIntOfReverse(bytes, offset);
|
if (value >= 0) return value;
|
return 65536L * 65536L + value;
|
}
|
|
/**
|
* 将字节数组转换成uint数据 倒序
|
* @param bytes 字节数组
|
* @return int值
|
*/
|
public static long bytesToUIntOfReverse(byte[] bytes) {
|
return ByteUtils.bytesToUIntOfReverse(bytes, 0);
|
}
|
|
/**
|
* 将字节数组转换成float数据
|
* @param bytes 字节数组
|
* @return float值
|
*/
|
public static float bytesToFloat(byte[] bytes) {
|
return Float.intBitsToFloat(bytesToInt(bytes, 0));
|
}
|
|
/**
|
* 将字节数组转换成float数据
|
* @param bytes 字节数组
|
* @param offset 起始位置
|
* @return float值
|
*/
|
public static float bytesToFloat(byte[] bytes, int offset) {
|
return Float.intBitsToFloat(bytesToInt(bytes,offset));
|
}
|
|
/**
|
* 将字节数组转换成float数据
|
* @param bytes 字节数组
|
* @return float值
|
*/
|
public static float bytesToFloatOfReverse(byte[] bytes) {
|
return bytesToFloatOfReverse(bytes, 0);
|
}
|
|
/**
|
* 将字节数组转换成float数据
|
* @param bytes 字节数组
|
* @param offset 偏移量
|
* @return float值
|
*/
|
public static float bytesToFloatOfReverse(byte[] bytes, int offset) {
|
return Float.intBitsToFloat(bytesToIntOfReverse(bytes, offset));
|
}
|
|
|
/**
|
* byte数组中取double数值
|
* @param src byte数组
|
* @return double数值
|
*/
|
public static double bytesToDouble(byte[] src) {
|
return Double.longBitsToDouble(bytesToLong(src));
|
}
|
|
/**
|
* byte数组中取double数值
|
* @param src byte数组
|
* @param offset 从数组的第offset位开始
|
* @return double数值
|
*/
|
public static double bytesToDouble(byte[] src, int offset) {
|
return Double.longBitsToDouble(bytesToLong(src, offset));
|
}
|
|
/**
|
* byte数组中取double数值
|
* @param src byte数组
|
* @return double数值
|
*/
|
public static double bytesToDoubleOfReverse(byte[] src) {
|
return bytesToDoubleOfReverse(src, 0);
|
}
|
|
/**
|
* byte数组中取double数值
|
* @param src byte数组
|
* @param offset 从数组的第offset位开始
|
* @return double数值
|
*/
|
public static double bytesToDoubleOfReverse(byte[] src, int offset) {
|
return Double.longBitsToDouble(bytesToLongOfReverse(src, offset));
|
}
|
|
/**
|
* 去掉字节数组尾数为零的字节,并将其转成字符串
|
* @param src
|
* @param charset
|
* @return
|
*/
|
public static String bytesToString(byte[] src, Charset charset){
|
int search = Arrays.binarySearch(src, (byte) 0);
|
return new String(Arrays.copyOf(src, search), charset);
|
}
|
|
/**
|
* 去掉字节数组尾数为零的字节,并将其转成字符串
|
* @param src
|
* @return
|
*/
|
public static String bytesToString(byte[] src){
|
return new String(wipeLastZero(src));
|
}
|
|
/**
|
* 去掉字节数组尾数为零的字节,并将其转成字符串
|
* @param src
|
* @return
|
*/
|
public static String bytesToString(byte[] src, int startIndex, int endIndex){
|
return new String(wipeLastZero(subBytes(src, startIndex, endIndex)));
|
}
|
|
/**
|
* 去掉字节数组尾数为零的字节,并将其转成字符串
|
* @param src
|
* @return
|
*/
|
public static String bytesToString(byte[] src, int startIndex, int endIndex, Charset charset){
|
return new String(wipeLastZero(subBytes(src, startIndex, endIndex)), charset);
|
}
|
|
/**
|
* 将byte[]数组的数据进行翻转
|
* @param reverse 等待反转的字符串
|
*/
|
public static void bytesReverse(byte[] reverse) {
|
if (reverse != null) {
|
byte tmp = 0;
|
for (int i = 0; i < reverse.length / 2; i++) {
|
tmp = reverse[i];
|
reverse[i] = reverse[reverse.length - 1 - i];
|
reverse[reverse.length - 1 - i] = tmp;
|
}
|
}
|
}
|
|
/**
|
* 去除包含0的字节
|
* @param src
|
* @return
|
*/
|
private static byte[] wipeLastZero(byte[] src){
|
int index = 0;
|
for(int i=0; i<src.length; i++){
|
if(src[i] == 0) {
|
break;
|
}
|
|
index++;
|
}
|
|
return subBytes(src, 0, index);
|
}
|
|
/**
|
* 字节转为long, 偏移位从0开始
|
* @param bytes
|
* @return
|
*/
|
public static long bytesToLong(byte[] bytes) {
|
return ByteUtils.bytesToLong(bytes, 0);
|
}
|
|
/**
|
* 字节转为long
|
* @param bytes
|
* @param offset 偏移位置
|
* @return
|
*/
|
public static long bytesToLong(byte[] bytes, int offset) {
|
return (0xffL & (long) bytes[0 + offset]) |
|
(0xff00L & ((long) bytes[1 + offset] << 8)) |
|
(0xff0000L & ((long) bytes[2 + offset] << 16)) |
|
(0xff000000L & ((long) bytes[3 + offset] << 24)) |
|
(0xff00000000L & ((long) bytes[4 + offset] << 32)) |
|
(0xff0000000000L & ((long) bytes[5 + offset] << 40)) |
|
(0xff000000000000L & ((long) bytes[6 + offset] << 48)) |
|
(0xff00000000000000L & ((long) bytes[7 + offset] << 56));
|
}
|
|
/**
|
* 将字节数组转换成long数据 倒序
|
* @param bytes 字节数组
|
* @return long值
|
*/
|
public static long bytesToLongOfReverse(byte[] bytes) {
|
return ByteUtils.bytesToLongOfReverse(bytes, 0);
|
}
|
|
/**
|
* 将字节数组转换成long数据 倒序
|
* @param bytes 字节数组
|
* @param offset 起始位置
|
* @return long值
|
*/
|
public static long bytesToLongOfReverse(byte[] bytes, int offset) {
|
return (0xffL & (long) bytes[7 + offset]) |
|
(0xff00L & ((long) bytes[6 + offset] << 8)) |
|
(0xff0000L & ((long) bytes[5 + offset] << 16)) |
|
(0xff000000L & ((long) bytes[4 + offset] << 24)) |
|
(0xff00000000L & ((long) bytes[3 + offset] << 32)) |
|
(0xff0000000000L & ((long) bytes[2 + offset] << 40)) |
|
(0xff000000000000L & ((long) bytes[1 + offset] << 48)) |
|
(0xff00000000000000L & ((long) bytes[0 + offset] << 56));
|
}
|
|
/**
|
* 字符数组 切割
|
* @param bytes 字节数组
|
* @param beginIndex 开始索引
|
* @param endIndex 结束索引
|
* @return
|
*/
|
public static byte[] subBytes(byte[] bytes, int beginIndex, int endIndex) {
|
byte[] result = new byte[endIndex - beginIndex];
|
System.arraycopy(bytes, beginIndex, result, 0, result.length);
|
return result;
|
}
|
|
/**
|
* 子字节 从开始位置{beginIndex} 到结束
|
* @param bytes
|
* @param beginIndex
|
* @return
|
*/
|
public static byte[] subBytes(byte[] bytes, int beginIndex) {
|
return ByteUtils.subBytes(bytes, beginIndex, bytes.length);
|
}
|
|
/**
|
* 将截取数组指定数据,并将其转为字符串
|
* @param bytes
|
* @param beginIndex
|
* @param endIndex
|
* @return
|
*/
|
public static String subBytesToString(byte[] bytes, int beginIndex, int endIndex){
|
byte[] subBytes = subBytes(bytes, beginIndex, endIndex);
|
return bytesToString(subBytes);
|
}
|
|
/**
|
* byte数组添加整个target数组
|
*
|
* 源字节数组
|
* @param targetBytes
|
* 添加对象数组
|
* @param beginIndex
|
* 开始下标
|
* @return
|
*/
|
public static byte[] addBytes(byte[] sourceBytes, byte[] targetBytes, int beginIndex) {
|
if (targetBytes == null) {
|
return sourceBytes;
|
}
|
int targetSize = targetBytes.length;
|
if (sourceBytes == null) {
|
beginIndex = 0;
|
sourceBytes = new byte[targetSize];
|
}
|
int sourceSize = sourceBytes.length;
|
if (sourceSize - beginIndex < targetSize) {
|
return sourceBytes;
|
} else {
|
for (int i = 0; i < targetSize; i++) {
|
sourceBytes[beginIndex + i] = targetBytes[i];
|
}
|
}
|
return sourceBytes;
|
|
}
|
|
/**
|
* 将一个uuid对象转化成byte[]
|
* @param uuid uuid对象
|
* @return 字节数组
|
*/
|
public static byte[] UUID2Byte(UUID uuid) {
|
ByteArrayOutputStream ba = new ByteArrayOutputStream(16);
|
DataOutputStream da = new DataOutputStream(ba);
|
try {
|
da.writeLong(uuid.getMostSignificantBits());
|
da.writeLong(uuid.getLeastSignificantBits());
|
ba.close();
|
da.close();
|
}
|
catch (IOException e) {
|
e.printStackTrace();
|
}
|
|
byte[] buffer = ba.toByteArray();
|
// 进行错位
|
byte temp=buffer[0];
|
buffer[0] = buffer[3];
|
buffer[3] =temp;
|
temp=buffer[1];
|
buffer[1]=buffer[2];
|
buffer[2]=temp;
|
|
temp = buffer[4];
|
buffer[4]=buffer[5];
|
buffer[5] =temp;
|
|
temp = buffer[6];
|
buffer[6]=buffer[7];
|
buffer[7] =temp;
|
|
return buffer;
|
}
|
|
/**
|
* 获取字节的指定位值 0 or 1
|
* @param value
|
* @param index
|
* @return
|
*/
|
public static byte bitAtByte(byte value, int index) {
|
return (byte) ((value & (1 << index)) > 0 ? 1 : 0);
|
}
|
|
/**
|
*将bool数组转换到byte数组<br />
|
* @param array bool数组
|
* @return 字节数组
|
*/
|
public static byte[] boolArrayToByte(boolean[] array) {
|
if (array == null) return null;
|
|
int length = array.length % 8 == 0 ? array.length / 8 : array.length / 8 + 1;
|
byte[] buffer = new byte[length];
|
|
for (int i = 0; i < array.length; i++) {
|
if (array[i]) {
|
buffer[i / 8] += (1 << i % 8);
|
}
|
}
|
|
return buffer;
|
}
|
|
public static Integer cutMessageHexTo(byte[] source, int startIndex, int endIndex){
|
byte[] subarray = ArrayUtils.subarray(source, startIndex, endIndex);
|
String s = bytesToHexString(subarray);
|
return Integer.parseInt(s,16);
|
}
|
|
/**
|
* byte数组转换炒年糕十六进制字符串
|
*
|
* @param bArray byte数组
|
* @return hex字符串
|
*/
|
public static String bytesToHexString(byte[] bArray) {
|
StringBuilder sb = new StringBuilder(bArray.length);
|
for (int i = 0; i < bArray.length; i++) {
|
String hexStr = Integer.toHexString(0xFF & bArray[i]);
|
if (hexStr.length() < 2) {
|
sb.append(0);
|
}
|
sb.append(hexStr.toUpperCase());
|
}
|
return sb.toString();
|
}
|
|
|
}
|
