import org.apache.commons.lang3.ArrayUtils;
import java.io.*;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.Charset;
import java.util.Arrays;
/**
* 字节数组转换工具类
*/
public class ByteUtils {
public static final String GBK = "GBK";
public static final String UTF8 = "utf-8";
public static final char[] ascii = "0123456789ABCDEF".toCharArray();
private static char[] HEX_VOCABLE = {'0', '1', '2', '3', '4', '5', '6',
'7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
/**
* 将short整型数值转换为字节数组
*
* @param data
* @return
*/
public static byte[] getBytes(short data) {
byte[] bytes = new byte[2];
bytes[0] = (byte) ((data & 0xff00) >> 8);
bytes[1] = (byte) (data & 0xff);
return bytes;
}
/**
* 将字符转换为字节数组
*
* @param data
* @return
*/
public static byte[] getBytes(char data) {
byte[] bytes = new byte[2];
bytes[0] = (byte) (data >> 8);
bytes[1] = (byte) (data);
return bytes;
}
/**
* 将布尔值转换为字节数组
*
* @param data
* @return
*/
public static byte[] getBytes(boolean data) {
byte[] bytes = new byte[1];
bytes[0] = (byte) (data ? 1 : 0);
return bytes;
}
/**
* 将整型数值转换为字节数组
*
* @param data
* @return
*/
public static byte[] getBytes(int data) {
byte[] bytes = new byte[4];
bytes[0] = (byte) ((data & 0xff000000) >> 24);
bytes[1] = (byte) ((data & 0xff0000) >> 16);
bytes[2] = (byte) ((data & 0xff00) >> 8);
bytes[3] = (byte) (data & 0xff);
return bytes;
}
/**
* 将long整型数值转换为字节数组
*
* @param data
* @return
*/
public static byte[] getBytes(long data) {
byte[] bytes = new byte[8];
bytes[0] = (byte) ((data >> 56) & 0xff);
bytes[1] = (byte) ((data >> 48) & 0xff);
bytes[2] = (byte) ((data >> 40) & 0xff);
bytes[3] = (byte) ((data >> 32) & 0xff);
bytes[4] = (byte) ((data >> 24) & 0xff);
bytes[5] = (byte) ((data >> 16) & 0xff);
bytes[6] = (byte) ((data >> 8) & 0xff);
bytes[7] = (byte) (data & 0xff);
return bytes;
}
/**
* 将float型数值转换为字节数组
*
* @param data
* @return
*/
public static byte[] getBytes(float data) {
int intBits = Float.floatToIntBits(data);
return getBytes(intBits);
}
/**
* 将double型数值转换为字节数组
*
* @param data
* @return
*/
public static byte[] getBytes(double data) {
long intBits = Double.doubleToLongBits(data);
return getBytes(intBits);
}
/**
* 将字符串按照charsetName编码格式的字节数组
*
* @param data 字符串
* @param charsetName 编码格式
* @return
*/
public static byte[] getBytes(String data, String charsetName) {
Charset charset = Charset.forName(charsetName);
return data.getBytes(charset);
}
/**
* 将字符串按照GBK编码格式的字节数组
*
* @param data
* @return
*/
public static byte[] getBytes(String data) {
return getBytes(data, GBK);
}
/**
* 将字节数组第0字节转换为布尔值
*
* @param bytes
* @return
*/
public static boolean getBoolean(byte[] bytes) {
return bytes[0] == 1;
}
/**
* 将字节数组的第index字节转换为布尔值
*
* @param bytes
* @param index
* @return
*/
public static boolean getBoolean(byte[] bytes, int index) {
return bytes[index] == 1;
}
/**
* 将字节数组前2字节转换为short整型数值
*
* @param bytes
* @return
*/
public static short getShort(byte[] bytes) {
return (short) ((0xff00 & (bytes[0] << 8)) | (0xff & bytes[1]));
}
/**
* 将字节数组从startIndex开始的2个字节转换为short整型数值
*
* @param bytes
* @param startIndex
* @return
*/
public static short getShort(byte[] bytes, int startIndex) {
return (short) ((0xff00 & (bytes[startIndex] << 8)) | (0xff & bytes[startIndex + 1]));
}
/**
* 将字节数组前2字节转换为字符
*
* @param bytes
* @return
*/
public static char getChar(byte[] bytes) {
return (char) ((0xff00 & (bytes[0] << 8)) | (0xff & bytes[1]));
}
/**
* 将字节数组从startIndex开始的2个字节转换为字符
*
* @param bytes
* @param startIndex
* @return
*/
public static char getChar(byte[] bytes, int startIndex) {
return (char) ((0xff00 & (bytes[startIndex] << 8)) | (0xff & bytes[startIndex + 1]));
}
/**
* 将字节数组前4字节转换为整型数值
*
* @param bytes
* @return
*/
public static int getInt(byte[] bytes) {
return (0xff000000 & (bytes[0] << 24) | (0xff0000 & (bytes[1] << 16))
| (0xff00 & (bytes[2] << 8)) | (0xff & bytes[3]));
}
/**
* 将字节数组从startIndex开始的4个字节转换为整型数值
*
* @param bytes
* @param startIndex
* @return
*/
public static int getInt(byte[] bytes, int startIndex) {
return (0xff000000 & (bytes[startIndex] << 24)
| (0xff0000 & (bytes[startIndex + 1] << 16))
| (0xff00 & (bytes[startIndex + 2] << 8)) | (0xff & bytes[startIndex + 3]));
}
/**
* 将字节数组前8字节转换为long整型数值
*
* @param bytes
* @return
*/
public static long getLong(byte[] bytes) {
return (0xff00000000000000L & ((long) bytes[0] << 56)
| (0xff000000000000L & ((long) bytes[1] << 48))
| (0xff0000000000L & ((long) bytes[2] << 40))
| (0xff00000000L & ((long) bytes[3] << 32))
| (0xff000000L & ((long) bytes[4] << 24))
| (0xff0000L & ((long) bytes[5] << 16))
| (0xff00L & ((long) bytes[6] << 8)) | (0xffL & (long) bytes[7]));
}
/**
* 将字节数组从startIndex开始的8个字节转换为long整型数值
*
* @param bytes
* @param startIndex
* @return
*/
public static long getLong(byte[] bytes, int startIndex) {
return (0xff00000000000000L & ((long) bytes[startIndex] << 56)
| (0xff000000000000L & ((long) bytes[startIndex + 1] << 48))
| (0xff0000000000L & ((long) bytes[startIndex + 2] << 40))
| (0xff00000000L & ((long) bytes[startIndex + 3] << 32))
| (0xff000000L & ((long) bytes[startIndex + 4] << 24))
| (0xff0000L & ((long) bytes[startIndex + 5] << 16))
| (0xff00L & ((long) bytes[startIndex + 6] << 8)) | (0xffL & (long) bytes[startIndex + 7]));
}
/**
* 将字节数组前4字节转换为float型数值
*
* @param bytes
* @return
*/
public static float getFloat(byte[] bytes) {
return Float.intBitsToFloat(getInt(bytes));
}
/**
* 将字节数组从startIndex开始的4个字节转换为float型数值
*
* @param bytes
* @param startIndex
* @return
*/
public static float getFloat(byte[] bytes, int startIndex) {
byte[] result = new byte[4];
System.arraycopy(bytes, startIndex, result, 0, 4);
return Float.intBitsToFloat(getInt(result));
}
/**
* 将字节数组前8字节转换为double型数值
*
* @param bytes
* @return
*/
public static double getDouble(byte[] bytes) {
long l = getLong(bytes);
return Double.longBitsToDouble(l);
}
/**
* 将字节数组从startIndex开始的8个字节转换为double型数值
*
* @param bytes
* @param startIndex
* @return
*/
public static double getDouble(byte[] bytes, int startIndex) {
byte[] result = new byte[8];
System.arraycopy(bytes, startIndex, result, 0, 8);
long l = getLong(result);
return Double.longBitsToDouble(l);
}
/**
* 将charsetName编码格式的字节数组转换为字符串
*
* @param bytes
* @param charsetName
* @return
*/
public static String getString(byte[] bytes, String charsetName) {
return new String(bytes, Charset.forName(charsetName));
}
/**
* 将GBK编码格式的字节数组转换为字符串
*
* @param bytes
* @return
*/
public static String getString(byte[] bytes) {
return getString(bytes, GBK);
}
/**
* 将16进制字符串转换为字节数组
*
* @param hex
* @return
*/
public static byte[] hexStringToBytes(String hex) {
if (hex == null || "".equals(hex)) {
return null;
}
int len = hex.length() / 2;
byte[] result = new byte[len];
char[] chArr = hex.toCharArray();
for (int i = 0; i < len; i++) {
int pos = i * 2;
result[i] = (byte) (toByte(chArr[pos]) << 4 | toByte(chArr[pos + 1]));
}
return result;
}
/**
* 将16进制字符串转换为字节数组
*
* @param hex
* @return
*/
public static byte[] hexToBytes(String hex) {
if (hex.length() % 2 != 0)
throw new IllegalArgumentException(
"input string should be any multiple of 2!");
hex.toUpperCase();
byte[] byteBuffer = new byte[hex.length() / 2];
byte padding = 0x00;
boolean paddingTurning = false;
for (int i = 0; i < hex.length(); i++) {
if (paddingTurning) {
char c = hex.charAt(i);
int index = indexOf(hex, c);
padding = (byte) ((padding << 4) | index);
byteBuffer[i / 2] = padding;
padding = 0x00;
paddingTurning = false;
} else {
char c = hex.charAt(i);
int index = indexOf(hex, c);
padding = (byte) (padding | index);
paddingTurning = true;
}
}
return byteBuffer;
}
private static int indexOf(String input, char c) {
int index = ArrayUtils.indexOf(HEX_VOCABLE, c);
if (index < 0) {
throw new IllegalArgumentException("err input:" + input);
}
return index;
}
/**
* 将BCD编码的字节数组转换为字符串
*
* @param bcds
* @return
*/
public static String bcdToString(byte[] bcds) {
if (bcds == null || bcds.length == 0) {
return null;
}
byte[] temp = new byte[2 * bcds.length];
for (int i = 0; i < bcds.length; i++) {
temp[i * 2] = (byte) ((bcds[i] >> 4) & 0x0f);
temp[i * 2 + 1] = (byte) (bcds[i] & 0x0f);
}
StringBuffer res = new StringBuffer();
for (int i = 0; i < temp.length; i++) {
res.append(ascii[temp[i]]);
}
return res.toString();
}
/**
* 字节转整形
*
* @param value
* @return
*/
public static int bcdToInt(byte value) {
return ((value >> 4) * 10) + (value & 0x0F);
}
/**
* 字节数组转16进制字符串
*
* @param bs
* @return
*/
public static String bytesToHex(byte[] bs) {
StringBuilder sb = new StringBuilder();
for (byte b : bs) {
int high = (b >> 4) & 0x0f;
int low = b & 0x0f;
sb.append(HEX_VOCABLE[high]);
sb.append(HEX_VOCABLE[low]);
}
return sb.toString();
}
/**
* 字节数组取前len个字节转16进制字符串
*
* @param bs
* @param len
* @return
*/
public static String bytesToHex(byte[] bs, int len) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < len; i++) {
byte b = bs[i];
int high = (b >> 4) & 0x0f;
int low = b & 0x0f;
sb.append(HEX_VOCABLE[high]);
sb.append(HEX_VOCABLE[low]);
}
return sb.toString();
}
/**
* 字节数组偏移offset长度之后的取len个字节转16进制字符串
*
* @param bs
* @param offset
* @param len
* @return
*/
public static String bytesToHex(byte[] bs, int offset, int len) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < len; i++) {
byte b = bs[offset + i];
int high = (b >> 4) & 0x0f;
int low = b & 0x0f;
sb.append(HEX_VOCABLE[high]);
sb.append(HEX_VOCABLE[low]);
}
return sb.toString();
}
/**
* 字节数组转16进制字符串
*
* @param
* @return
*/
public static String byteToHex(byte b) {
StringBuilder sb = new StringBuilder();
int high = (b >> 4) & 0x0f;
int low = b & 0x0f;
sb.append(HEX_VOCABLE[high]);
sb.append(HEX_VOCABLE[low]);
return sb.toString();
}
/**
* 将字节数组取反
*
* @param src
* @return
*/
public static String negate(byte[] src) {
if (src == null || src.length == 0) {
return null;
}
byte[] temp = new byte[2 * src.length];
for (int i = 0; i < src.length; i++) {
byte tmp = (byte) (0xFF ^ src[i]);
temp[i * 2] = (byte) ((tmp >> 4) & 0x0f);
temp[i * 2 + 1] = (byte) (tmp & 0x0f);
}
StringBuffer res = new StringBuffer();
for (int i = 0; i < temp.length; i++) {
res.append(ascii[temp[i]]);
}
return res.toString();
}
/**
* 比较字节数组是否相同
*
* @param a
* @param b
* @return
*/
public static boolean compareBytes(byte[] a, byte[] b) {
if (a == null || a.length == 0 || b == null || b.length == 0
|| a.length != b.length) {
return false;
}
if (a.length == b.length) {
for (int i = 0; i < a.length; i++) {
if (a[i] != b[i]) {
return false;
}
}
} else {
return false;
}
return true;
}
/**
* 只比对指定长度byte
*
* @param a
* @param b
* @param len
* @return
*/
public static boolean compareBytes(byte[] a, byte[] b, int len) {
if (a == null || a.length == 0 || b == null || b.length == 0
|| a.length < len || b.length < len) {
return false;
}
for (int i = 0; i < len; i++) {
if (a[i] != b[i]) {
return false;
}
}
return true;
}
/**
* 将字节数组转换为二进制字符串
*
* @param items
* @return
*/
public static String bytesToBinaryString(byte[] items) {
if (items == null || items.length == 0) {
return null;
}
StringBuffer buf = new StringBuffer();
for (byte item : items) {
buf.append(byteToBinaryString(item));
}
return buf.toString();
}
/**
* 将字节转换为二进制字符串
*
* @param
* @return
*/
public static String byteToBinaryString(byte item) {
byte a = item;
StringBuffer buf = new StringBuffer();
for (int i = 0; i < 8; i++) {
buf.insert(0, a % 2);
a = (byte) (a >> 1);
}
return buf.toString();
}
/**
* 对数组a,b进行异或运算
*
* @param a
* @param b
* @return
*/
public static byte[] xor(byte[] a, byte[] b) {
if (a == null || a.length == 0 || b == null || b.length == 0
|| a.length != b.length) {
return null;
}
byte[] result = new byte[a.length];
for (int i = 0; i < a.length; i++) {
result[i] = (byte) (a[i] ^ b[i]);
}
return result;
}
/**
* 对数组a,b进行异或运算 运算长度len
*
* @param a
* @param b
* @param len
* @return
*/
public static byte[] xor(byte[] a, byte[] b, int len) {
if (a == null || a.length == 0 || b == null || b.length == 0) {
return null;
}
if (a.length < len || b.length < len) {
return null;
}
byte[] result = new byte[len];
for (int i = 0; i < len; i++) {
result[i] = (byte) (a[i] ^ b[i]);
}
return result;
}
/**
* 将short整型数值转换为字节数组
*
* @param num
* @return
*/
public static byte[] shortToBytes(int num) {
byte[] temp = new byte[2];
for (int i = 0; i < 2; i++) {
temp[i] = (byte) ((num >>> (8 - i * 8)) & 0xFF);
}
return temp;
}
/**
* 将字节数组转为整型
*
* @param
* @return
*/
public static int bytesToShort(byte[] arr) {
int mask = 0xFF;
int temp = 0;
int result = 0;
for (int i = 0; i < 2; i++) {
result <<= 8;
temp = arr[i] & mask;
result |= temp;
}
return result;
}
/**
* 将整型数值转换为指定长度的字节数组
*
* @param num
* @return
*/
public static byte[] intToBytes(int num) {
byte[] temp = new byte[4];
for (int i = 0; i < 4; i++) {
temp[i] = (byte) ((num >>> (24 - i * 8)) & 0xFF);
}
return temp;
}
/**
* 将整型数值转换为指定长度的字节数组
*
* @param src
* @param len
* @return
*/
public static byte[] intToBytes(int src, int len) {
if (len < 1 || len > 4) {
return null;
}
byte[] temp = new byte[len];
for (int i = 0; i < len; i++) {
temp[len - 1 - i] = (byte) ((src >>> (8 * i)) & 0xFF);
}
return temp;
}
/**
* 将字节数组转换为整型数值
*
* @param arr
* @return
*/
public static int bytesToInt(byte[] arr) {
int mask = 0xFF;
int temp = 0;
int result = 0;
for (int i = 0; i < 4; i++) {
result <<= 8;
temp = arr[i] & mask;
result |= temp;
}
return result;
}
/**
* 将long整型数值转换为字节数组
*
* @param num
* @return
*/
public static byte[] longToBytes(long num) {
byte[] temp = new byte[8];
for (int i = 0; i < 8; i++) {
temp[i] = (byte) ((num >>> (56 - i * 8)) & 0xFF);
}
return temp;
}
/**
* 将字节数组转换为long整型数值
*
* @param arr
* @return
*/
public static long bytesToLong(byte[] arr) {
int mask = 0xFF;
int temp = 0;
long result = 0;
int len = Math.min(8, arr.length);
for (int i = 0; i < len; i++) {
result <<= 8;
temp = arr[i] & mask;
result |= temp;
}
return result;
}
/**
* 将16进制字符转换为字节
*
* @param c
* @return
*/
public static byte toByte(char c) {
byte b = (byte) "0123456789ABCDEF".indexOf(c);
return b;
}
/**
* 功能描述:把两个字节的字节数组转化为整型数据,高位补零,例如:<br/>
* 有字节数组byte[] data = new byte[]{1,2};转换后int数据的字节分布如下:<br/>
* 00000000 00000000 00000001 00000010,函数返回258
*
* @param lenData 需要进行转换的字节数组
* @return 字节数组所表示整型值的大小
*/
public static int bytesToIntWhereByteLengthEquals2(byte lenData[]) {
if (lenData.length != 2) {
return -1;
}
byte fill[] = new byte[]{0, 0};
byte real[] = new byte[4];
System.arraycopy(fill, 0, real, 0, 2);
System.arraycopy(lenData, 0, real, 2, 2);
int len = byteToInt(real);
return len;
}
/**
* 功能描述:将byte数组转化为int类型的数据
*
* @param byteVal 需要转化的字节数组
* @return 字节数组所表示的整型数据
*/
public static int byteToInt(byte[] byteVal) {
int result = 0;
for (int i = 0; i < byteVal.length; i++) {
int tmpVal = (byteVal[i] << (8 * (3 - i)));
switch (i) {
case 0:
tmpVal = tmpVal & 0xFF000000;
break;
case 1:
tmpVal = tmpVal & 0x00FF0000;
break;
case 2:
tmpVal = tmpVal & 0x0000FF00;
break;
case 3:
tmpVal = tmpVal & 0x000000FF;
break;
}
result = result | tmpVal;
}
return result;
}
public static byte CheckXORSum(byte[] bData) {
byte sum = 0x00;
for (int i = 0; i < bData.length; i++) {
sum ^= bData[i];
}
return sum;
}
/**
* 从offset开始 将后续长度为len的byte字节转为int
*
* @param data
* @param offset
* @param len
* @return
*/
public static int bytesToInt(byte[] data, int offset, int len) {
int mask = 0xFF;
int temp = 0;
int result = 0;
len = Math.min(len, 4);
for (int i = 0; i < len; i++) {
result <<= 8;
temp = data[offset + i] & mask;
result |= temp;
}
return result;
}
/**
* byte字节数组中的字符串的长度
*
* @param data
* @return
*/
public static int getBytesStringLen(byte[] data) {
int count = 0;
for (byte b : data) {
if (b == 0x00)
break;
count++;
}
return count;
}
// 颠倒数组元素顺序
public static byte[] reverse(byte a[]) { //颠倒数组元素的顺序
int N = a.length;
for (byte i = 0; i < N / 2; i++) {
byte temp = a[i];
a[i] = a[N - 1 - i];
a[N - 1 - i] = temp;
}
return a;
}
/**
* 将int转为高字节在前,低字节在后的byte数组(大端)
*
* @param n int
* @return byte[]
*/
public static byte[] int2BytesBig(int n) {
byte[] b = new byte[4];
b[3] = (byte) (n & 0xff);
b[2] = (byte) (n >> 8 & 0xff);
b[1] = (byte) (n >> 16 & 0xff);
b[0] = (byte) (n >> 24 & 0xff);
return b;
}
/**
* 将int转为低字节在前,高字节在后的byte数组(小端)
*
* @param n int
* @return byte[]
*/
public static byte[] int2BytesLittle(int n) {
byte[] b = new byte[4];
b[0] = (byte) (n & 0xff);
b[1] = (byte) (n >> 8 & 0xff);
b[2] = (byte) (n >> 16 & 0xff);
b[3] = (byte) (n >> 24 & 0xff);
return b;
}
/**
* byte数组到int的转换(小端)
*
* @param bytes
* @return
*/
public static int bytes2IntLittle(byte[] bytes) {
int int1 = bytes[0] & 0xff;
int int2 = (bytes[1] & 0xff) << 8;
int int3 = (bytes[2] & 0xff) << 16;
int int4 = (bytes[3] & 0xff) << 24;
return int1 | int2 | int3 | int4;
}
/**
* byte数组到int的转换,指定长度(小端)
*
* @param bytes
* @return
*/
public static int bytes2IntLittle(byte[] bytes, int position, int length) {
byte[] temp = new byte[length];
System.arraycopy(bytes, position, temp, 0, length);
int int1 = temp[0] & 0xff;
int int2 = (temp[1] & 0xff) << 8;
int int3 = (temp[2] & 0xff) << 16;
int int4 = (temp[3] & 0xff) << 24;
return int1 | int2 | int3 | int4;
}
/**
* byte数组到无符号int的转换(小端)
*
* @param bytes
* @return
*/
public static long bytes2unsignedIntLittle(byte[] bytes) {
int int1 = bytes[0] & 0xff;
int int2 = (bytes[1] & 0xff) << 8;
int int3 = (bytes[2] & 0xff) << 16;
int int4 = (bytes[3] & 0xff) << 24;
return (int1 | int2 | int3 | int4) & 0xFFFF;
}
/**
* byte数组到int的转换(大端)
*
* @param bytes
* @return
*/
public static int bytes2IntBig(byte[] bytes) {
int int1 = bytes[3] & 0xff;
int int2 = (bytes[2] & 0xff) << 8;
int int3 = (bytes[1] & 0xff) << 16;
int int4 = (bytes[0] & 0xff) << 24;
return int1 | int2 | int3 | int4;
}
/**
* 将short转为高字节在前,低字节在后的byte数组(大端)
*
* @param n short
* @return byte[]
*/
public static byte[] short2BytesBig(short n) {
byte[] b = new byte[2];
b[1] = (byte) (n & 0xff);
b[0] = (byte) (n >> 8 & 0xff);
return b;
}
/**
* 将short转为低字节在前,高字节在后的byte数组(小端)
*
* @param n short
* @return byte[]
*/
public static byte[] short2BytesLittle(short n) {
byte[] b = new byte[2];
b[0] = (byte) (n & 0xff);
b[1] = (byte) (n >> 8 & 0xff);
return b;
}
/**
* 读取小端byte数组为short
*
* @param b
* @return
*/
public static short bytes2ShortLittle(byte[] b) {
return (short) (((b[1] << 8) | b[0] & 0xff));
}
/**
* 读取小端byte数组为short
*
* @param
* @return
*/
public static short bytes2ShortLittle(byte[] bytes, int position, int length) {
byte[] temp = new byte[length];
System.arraycopy(bytes, position, temp, 0, length);
return (short) (((temp[1] << 8) | temp[0] & 0xff));
}
/**
* 读取小端byte数组为short
*
* @param b
* @return
*/
public static int bytes2UnsignedShortLittle(byte[] b) {
return (((b[1] << 8) | b[0] & 0xff)) & 0xFFFF;
}
/**
* 读取大端byte数组为short
*
* @param b
* @return
*/
public static short bytes2ShortBig(byte[] b) {
return (short) (((b[0] << 8) | b[1] & 0xff));
}
/**
* long类型转byte[] (大端)
*
* @param n
* @return
*/
public static byte[] long2BytesBig(long n) {
byte[] b = new byte[8];
b[7] = (byte) (n & 0xff);
b[6] = (byte) (n >> 8 & 0xff);
b[5] = (byte) (n >> 16 & 0xff);
b[4] = (byte) (n >> 24 & 0xff);
b[3] = (byte) (n >> 32 & 0xff);
b[2] = (byte) (n >> 40 & 0xff);
b[1] = (byte) (n >> 48 & 0xff);
b[0] = (byte) (n >> 56 & 0xff);
return b;
}
/**
* long类型转byte[] (小端)
*
* @param n
* @return
*/
public static byte[] long2BytesLittle(long n) {
byte[] b = new byte[8];
b[0] = (byte) (n & 0xff);
b[1] = (byte) (n >> 8 & 0xff);
b[2] = (byte) (n >> 16 & 0xff);
b[3] = (byte) (n >> 24 & 0xff);
b[4] = (byte) (n >> 32 & 0xff);
b[5] = (byte) (n >> 40 & 0xff);
b[6] = (byte) (n >> 48 & 0xff);
b[7] = (byte) (n >> 56 & 0xff);
return b;
}
/**
* byte[]转long类型(小端)
*
* @param array
* @return
*/
public static long bytes2LongLittle(byte[] array) {
return ((((long) array[0] & 0xff))
| (((long) array[1] & 0xff) << 8)
| (((long) array[2] & 0xff) << 16)
| (((long) array[3] & 0xff) << 24)
| (((long) array[4] & 0xff) << 32)
| (((long) array[5] & 0xff) << 40)
| (((long) array[6] & 0xff) << 48)
| (((long) array[7] & 0xff) << 56));
}
/**
* byte[]转long类型(大端)
*
* @param array
* @return
*/
public static long bytes2LongBig(byte[] array) {
return ((((long) array[0] & 0xff) << 56)
| (((long) array[1] & 0xff) << 48)
| (((long) array[2] & 0xff) << 40)
| (((long) array[3] & 0xff) << 32)
| (((long) array[4] & 0xff) << 24)
| (((long) array[5] & 0xff) << 16)
| (((long) array[6] & 0xff) << 8)
| (((long) array[7] & 0xff)));
}
/**
* long类型转byte[] (大端),通过ByteArrayOutputStream实现
*
* @param l
* @return
* @throws IOException
*/
public static byte[] long2BytesBOS(long l) throws IOException {
ByteArrayOutputStream bao = new ByteArrayOutputStream();
DataOutputStream dos = new DataOutputStream(bao);
dos.writeLong(l);
byte[] buf = bao.toByteArray();
return buf;
}
/**
* byte[]转long类型(大端),通过ByteArrayOutputStream实现
*
* @param data
* @return
* @throws IOException
*/
public long bytes2LongBOS(byte[] data) throws IOException {
ByteArrayInputStream bai = new ByteArrayInputStream(data);
DataInputStream dis = new DataInputStream(bai);
return dis.readLong();
}
/**
* long类型转byte[] (大端),通过ByteBuffer实现
*
* @param value
* @return
*/
public static byte[] long2BytesByteBuffer(long value) {
return ByteBuffer.allocate(Long.SIZE / Byte.SIZE).putLong(value).array();
}
/**
* byte[]转long类型(大端), 通过ByteBuffer实现
*
* @param bytes
* @return
*/
public static long bytes2LongByteBuffer(byte[] bytes) {
ByteBuffer buffer = ByteBuffer.allocate(8);
buffer.put(bytes, 0, bytes.length);
buffer.flip();
return buffer.getLong();
}
/**
* 将字节数组转为long<br>
* 如果input为null,或offset指定的剩余数组长度不足8字节则抛出异常
*
* @param input byte[]
* @param offset 起始偏移量 0
* @param littleEndian 输入数组是否小端模式
* @return
*/
public static long bytes2Long(byte[] input, int offset, boolean littleEndian) {
long value = 0;
// 循环读取每个字节通过移位运算完成long的8个字节拼装
for (int count = 0; count < 8; ++count) {
int shift = (littleEndian ? count : (7 - count)) << 3;
value |= ((long) 0xff << shift) & ((long) input[offset + count] << shift);
}
return value;
}
/**
* 利用 {@link java.nio.ByteBuffer}实现byte[]转long
*
* @param input byte[]
* @param offset 0
* @param littleEndian 输入数组是否小端模式
* @return
*/
public static long bytes2LongByteBuffer(byte[] input, int offset, boolean littleEndian) {
// 将byte[] 封装为 ByteBuffer
ByteBuffer buffer = ByteBuffer.wrap(input, offset, 8);
if (littleEndian) {
// ByteBuffer.order(ByteOrder) 方法指定字节序,即大小端模式(BIG_ENDIAN/LITTLE_ENDIAN)
// ByteBuffer 默认为大端(BIG_ENDIAN)模式
buffer.order(ByteOrder.LITTLE_ENDIAN);
}
return buffer.getLong();
}
/**
* int 转 byte
*
* @param t
* @return
*/
public static byte int2Byte(int t) {
return (byte) t;
}
/**
* byte 转 int,解决java中byte输出可能为负数的问题
*
* @param b
* @return
*/
public static int byte2Int(byte b) {
return b & 0xFF;
}
/**
* 将 object --> byte 数组
*
* @param obj
* @return
*/
public static byte[] object2Bytes(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 Object bytes2Object(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 | ClassNotFoundException ex) {
ex.printStackTrace();
}
return obj;
}
/**
* 两个byte[]是否相同
*
* @param data1
* @param data2
* @return
*/
public static boolean bytesEquals(byte[] data1, byte[] data2) {
return Arrays.equals(data1, data2);
}
/**
* 截取byte[]
*
* @param data
* @param position
* @param length
* @return
*/
public static byte[] subBytes(byte[] data, int position, int length) {
byte[] temp = new byte[length];
System.arraycopy(data, position, temp, 0, length);
return temp;
}
/**
* 拼接byte[] 和 byte[]
*
* @param bytes1
* @param bytes2
* @return
*/
public static byte[] bytesMerger(byte[] bytes1, byte[] bytes2) {
byte[] bytes3 = new byte[bytes1.length + bytes2.length];
System.arraycopy(bytes1, 0, bytes3, 0, bytes1.length);
System.arraycopy(bytes2, 0, bytes3, bytes1.length, bytes2.length);
return bytes3;
}
/**
* 拼接byte 和 byte[]
*
* @param byte1
* @param bytes2
* @return
*/
public static byte[] bytesMerger(byte byte1, byte[] bytes2) {
byte[] bytes3 = new byte[1 + bytes2.length];
bytes3[0] = byte1;
System.arraycopy(bytes2, 0, bytes3, 1, bytes2.length);
return bytes3;
}
/**
* 拼接byte[] 和 byte
*
* @param bytes1
* @param byte2
* @return
*/
public static byte[] bytesMerger(byte[] bytes1, byte byte2) {
byte[] bytes3 = new byte[1 + bytes1.length];
System.arraycopy(bytes1, 0, bytes3, 0, bytes1.length);
bytes3[bytes3.length - 1] = byte2;
return bytes3;
}
/**
* 拼接三个数组
*
* @param bt1
* @param bt2
* @param bt3
* @return
*/
public static byte[] bytesMerger(byte[] bt1, byte[] bt2, byte[] bt3) {
byte[] data = new byte[bt1.length + bt2.length + bt3.length];
System.arraycopy(bt1, 0, data, 0, bt1.length);
System.arraycopy(bt2, 0, data, bt1.length, bt2.length);
System.arraycopy(bt3, 0, data, bt1.length + bt2.length, bt3.length);
return data;
}
/**
* byte转Hex 16 进制字符串
*/
public static String byte2Hex(byte b) {
String hex = Integer.toHexString(b & 0xFF);
if (hex.length() < 2) {
hex = "0" + hex;
}
return hex;
}
/**
* byte[]转Hex
*/
public static String bytes2Hex(byte[] b) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < b.length; i++) {
String hex = Integer.toHexString(b[i] & 0xFF);
if (hex.length() < 2) {
hex = "0" + hex;
}
sb.append(hex.toUpperCase());
}
return sb.toString();
}
/**
* 字节数组转为16进制字符串
*/
public static String bytes2Hex2(byte[] bytes) {
String strHex = "";
StringBuilder stringBuilder = new StringBuilder();
for (int n = 0; n < bytes.length; n++) {
strHex = Integer.toHexString(bytes[n] & 0xFF);
stringBuilder.append((strHex.length() == 1) ? "0" + strHex : strHex);
}
return stringBuilder.toString().trim();
}
/**
* Hex转byte,hex只能含两个字符,如果是一个字符byte高位会是0
*/
public static byte hex2Byte(String hex) {
return (byte) Integer.parseInt(hex, 16);
}
/**
* Hex转byte[],两种情况,Hex长度为奇数最后一个字符会被舍去
*/
public static byte[] hex2Bytes(String hex) {
if (hex.length() < 1) {
return null;
} else {
byte[] result = new byte[hex.length() / 2];
int j = 0;
for (int i = 0; i < hex.length(); i += 2) {
result[j++] = (byte) Integer.parseInt(hex.substring(i, i + 2), 16);
}
return result;
}
}
/**
* 字符串转为16进制字符串,推荐
*/
public static String str2HexStr(String str) {
char[] chars = "0123456789ABCDEF".toCharArray();
StringBuilder sb = new StringBuilder("");
byte[] bs = str.getBytes();
int bit;
for (byte b : bs) {
bit = (b & 0x0f0) >> 4;
sb.append(chars[bit]);
bit = b & 0x0f;
sb.append(chars[bit]);
}
return sb.toString().trim();
}
/**
* 16进制直接转换成为字符串(无需Unicode解码),推荐
*
* @param hexStr
* @return
*/
public static String hexStr2Str(String hexStr) {
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);
}
public static byte[] hexString2Bytes(String src) {
int l = src.length() / 2;
byte[] ret = new byte[l];
for (int i = 0; i < l; i++) {
ret[i] = (byte) Integer.valueOf(src.substring(i * 2, i * 2 + 2), 16).byteValue();
}
return ret;
}
/**
* 16进制字符串大端转小端
* @param bigEndianHex
* @return
*/
public static String convertToLittleEndian(String bigEndianHex) {
// 检查输入是否为偶数长度
if (bigEndianHex.length() % 2 != 0) {
throw new IllegalArgumentException("Input must have an even number of characters.");
}
// 将16进制字符串分割为每两个字符
String[] bytePairs = bigEndianHex.split("(?<=\\G..)");
// 反转字符对并重新连接
StringBuilder littleEndianHex = new StringBuilder();
for (int i = bytePairs.length - 1; i >= 0; i--) {
littleEndianHex.append(bytePairs[i]);
}
return littleEndianHex.toString().toUpperCase();
}
/**
* 16进制转Ascii
* @param hexStr
* @return
*/
public static String hexToAscii(String hexStr) {
StringBuilder output = new StringBuilder("");
for (int i = 0; i < hexStr.length(); i += 2) {
String str = hexStr.substring(i, i + 2);
output.append((char) Integer.parseInt(str, 16));
}
return output.toString();
}
}
字节,16进制大端小端模式,字符串转换工具类(超全)
最新推荐文章于 2024-06-29 15:21:27 发布