package kernel.util;
|
|
/**
|
|
* 一些字节处理的工具函数，用于一些比较底层的基于字节的协议转换
|
|
*/
|
public abstract class ByteUtils {
|
/**
|
* 初始化内存字节
|
*
|
* @param src
|
* byte[]
|
* @param c
|
* byte
|
* @param pos
|
* int
|
* @param count
|
* int
|
* @return byte[]
|
*/
|
public static byte[] memset(byte[] src, byte c, int pos, int count) {
|
if (src == null)
|
return src;
|
|
if (pos < 0 || pos > src.length || count <= 0) {
|
return src;
|
}
|
|
for (int i = 0; i < count && pos + i < src.length; i++) {
|
src[pos + i] = c;
|
}
|
|
return src;
|
}
|
|
/**
|
* 内存字节拷贝
|
*
|
* @param dest
|
* byte[]
|
* @param pos
|
* int
|
* @param src
|
* byte[]
|
* @param size
|
* int
|
* @return byte[]
|
*/
|
public static byte[] memcpy(byte[] dest, int pos, byte[] src, int size) {
|
if (size >= 0) {
|
size = size > dest.length ? dest.length : size;
|
System.arraycopy(src, 0, dest, pos, size);
|
}
|
return dest;
|
}
|
|
/**
|
* 字节头部填充
|
*
|
* @param src
|
* byte[]
|
* @param length
|
* int
|
* @param fill
|
* byte
|
* @return byte[]
|
*/
|
public static byte[] fillHead(byte[] src, int length, byte fill) {
|
if (src.length >= length) {
|
return src;
|
}
|
|
byte[] dest = new byte[length];
|
ByteUtils.memset(dest, fill, 0, length);
|
ByteUtils.memcpy(dest, length > src.length ? length - src.length : 0,
|
src, src.length);
|
return dest;
|
}
|
|
/**
|
* 字节尾部填充
|
*
|
* @param src
|
* byte[]
|
* @param length
|
* int
|
* @param fill
|
* byte
|
* @return byte[]
|
*/
|
public static byte[] fillTail(byte[] src, int length, byte fill) {
|
if (src.length >= length) {
|
return src;
|
}
|
|
byte[] dest = new byte[length];
|
ByteUtils.memset(dest, fill, 0, length);
|
ByteUtils.memcpy(dest, 0, src, src.length);
|
return dest;
|
}
|
|
/**
|
* 插入字节到目标字节数组，使用者须保证目标空间足够，后面的字节被覆盖
|
*
|
* @param dest
|
* byte[]
|
* @param src
|
* byte[]
|
* @param pos
|
* int
|
* @param length
|
* int
|
* @return byte[]
|
*/
|
public static byte[] insert(byte[] dest, byte[] src, int pos, int length) {
|
if (length > dest.length) {
|
length = dest.length;
|
}
|
|
for (int i = 0; i < pos + length; i++) {
|
if (i >= pos && i < pos + length) {
|
if (i + length < dest.length) {
|
dest[i + length] = dest[i];
|
}
|
if (i - pos < src.length) {
|
dest[i] = src[i - pos];
|
}
|
}
|
}
|
|
return dest;
|
}
|
|
/**
|
* 复制字节到目标字节数组，使用者须保证目标空间足够
|
*
|
* @param dest
|
* byte[]
|
* @param src
|
* byte[]
|
* @param pos
|
* int
|
* @param length
|
* int
|
* @return byte[]
|
*/
|
public static byte[] copyto(byte[] dest, byte[] src, int pos, int length) {
|
if (length > src.length) {
|
length = src.length;
|
}
|
|
if (dest == null || dest.length < pos + length) {
|
byte[] buf = new byte[pos + length];
|
memcpy(buf, 0, dest, pos);
|
dest = buf;
|
}
|
|
for (int i = 0; i < length; i++) {
|
dest[pos + i] = src[i];
|
}
|
|
return dest;
|
}
|
|
/**
|
* 从源字节数组指定位置复制字节到目标字节数组，使用者须保证目标空间足够
|
*
|
* @param dest
|
* byte[]
|
* @param src
|
* byte[]
|
* @param pos
|
* int
|
* @param length
|
* int
|
* @return byte[]
|
*/
|
public static byte[] copyfrom(byte[] dest, byte[] src, int pos, int length) {
|
if (length > src.length) {
|
length = src.length;
|
}
|
|
if (dest == null || dest.length < length) { // 只能通过返回参数返回，无法通过入参返回，与C语言不同。
|
dest = new byte[length];
|
}
|
|
for (int i = 0; i < length; i++) {
|
dest[i] = src[pos + i];
|
}
|
|
return copy(dest, 0, length); // 返回一个新建数组
|
}
|
|
/**
|
* 删除字节内容，返回删除后的内容
|
*
|
* @param src
|
* byte[]
|
* @param pos
|
* int
|
* @param length
|
* int
|
* @return byte[] 删除一些字节的新数组
|
*/
|
public static byte[] delete(byte src[], int pos, int length) {
|
if (src == null) {
|
return null;
|
}
|
|
if (pos > src.length || pos < 0 || length < 0) { // 非法参数
|
return src;
|
}
|
|
if (pos + length > src.length) {
|
length = src.length - pos;
|
}
|
|
byte[] dest = new byte[src.length - length];
|
for (int i = 0; i < src.length; i++) {
|
if (i - pos >= 0 && i - pos < length) {
|
continue;
|
}
|
dest[i] = src[i];
|
}
|
return dest;
|
}
|
|
/**
|
* 字节拷贝，返回拷贝内容
|
*
|
* @param src
|
* byte[]
|
* @param pos
|
* int
|
* @param size
|
* int
|
* @return byte[]
|
*/
|
public static byte[] copy(byte[] src, int pos, int size) {
|
if (pos < 0 || pos > src.length || size <= 0) { // 非法参数
|
return null;
|
}
|
|
byte[] dest = new byte[src.length - pos < size ? src.length - pos
|
: size];
|
for (int i = 0; i < size && pos + i < src.length; i++) {
|
dest[i] = src[pos + i];
|
}
|
|
return dest;
|
}
|
|
/**
|
* 转换成16进制的格式
|
*
|
* @param length
|
* int
|
* @param hexlen
|
* int
|
* @param fillhead
|
* byte
|
* @return byte[]
|
*/
|
public static byte[] toHexBytes(int length, int hexlen, byte fillhead) {
|
if (hexlen <= 0) {
|
return null;
|
}
|
|
byte dest[] = new byte[hexlen];
|
ByteUtils.memset(dest, fillhead, 0, hexlen);
|
byte[] src = Integer.toHexString(length).getBytes();
|
System.arraycopy(src, 0, dest, hexlen - src.length > 0 ? hexlen
|
- src.length : 0, src.length);
|
|
return dest;
|
}
|
|
/**
|
*
|
* @param b
|
* byte[]
|
* @return int
|
*/
|
public static int bytes2int(byte[] b) {
|
// byte[] b=new byte[]{1,2,3,4};
|
int mask = 0xff;
|
int temp = 0;
|
int res = 0;
|
for (int i = 0; i < 4; i++) {
|
res <<= 8;
|
temp = b[i] & mask;
|
res |= temp;
|
}
|
return res;
|
}
|
|
/**
|
*
|
* @param b
|
* byte
|
* @return String
|
*/
|
public static String byte2hex(byte b) {
|
String hex = Integer.toHexString((int) b & 0xff);
|
if (hex.length() == 1) {
|
hex = "0" + hex;
|
}
|
return hex;
|
}
|
|
/**
|
*
|
* @param hex
|
* String
|
* @return byte
|
*/
|
public static byte hex2byte(String hex) {
|
return (byte) (Integer.parseInt(hex, 16) & 0xff);
|
}
|
|
/**
|
*
|
* @param hex
|
* String
|
* @return byte[]
|
*/
|
public static byte[] hex2bytes(String hex) {
|
if (hex == null || hex.trim().length() == 0) {
|
return null;
|
}
|
|
byte[] dest = new byte[hex.length() / 2];
|
for (int i = 0; i < hex.length() / 2; i++) {
|
String h = hex.substring(2 * i, 2 * i + 2);
|
dest[i] = hex2byte(h);
|
}
|
|
return dest;
|
}
|
|
/**
|
*
|
* @param bytes
|
* byte[]
|
* @return String
|
*/
|
public static String bytes2hex(byte[] bytes) {
|
StringBuffer sb = null;
|
if (bytes == null || bytes.length == 0) {
|
return null;
|
}
|
|
sb = new StringBuffer();
|
for (int i = 0; i < bytes.length; i++) {
|
sb.append(byte2hex(bytes[i]));
|
}
|
|
return sb.toString();
|
}
|
|
/**
|
*
|
* @param num
|
* int
|
* @return byte[]
|
*/
|
public static byte[] int2bytes(int num) {
|
byte[] b = new byte[4];
|
// int mask=0xff;
|
for (int i = 0; i < 4; i++) {
|
b[i] = (byte) (num >>> (24 - i * 8));
|
// System.out.print(Integer.toHexString((int)b[i]));
|
}
|
return b;
|
}
|
|
/**
|
*
|
* @param num
|
* int
|
* @return byte[]
|
*/
|
public static byte[] short2bytes(int num) {
|
num &= 0xffff;
|
byte[] b = new byte[2];
|
// int mask=0xff;
|
for (int i = 0; i < 2; i++) {
|
b[i] = (byte) (num >>> (8 - i * 8));
|
// System.out.print(Integer.toHexString((int)b[i]));
|
}
|
return b;
|
}
|
|
/**
|
* byte2short
|
*
|
* @param len
|
* byte[]
|
* @return int
|
*/
|
// public static int byte2short(byte[] b) {
|
// int mask = 0xff;
|
// int temp = 0;
|
// int res = 0;
|
// for (int i = 0; i < 2; i++) {
|
// res <<= 8;
|
// temp = b[i] & mask;
|
// res |= temp;
|
// }
|
// return res;
|
// }
|
public static int byte2short(byte[] b) {
|
int mask = 0xff;
|
int temp = 0;
|
int res = 0;
|
for (int i = 0; i < 2; i++) {
|
res = ((res << 8) & 0xffff);
|
temp = b[i] & mask;
|
res |= temp;
|
}
|
return res & 0xffff;
|
}
|
|
/**
|
*
|
* @param h
|
* int
|
* @return int
|
*/
|
public static int htonl(int h) {
|
int nl = 0;
|
int b = 0;
|
|
for (int i = 0; i < 4; i++) {
|
b = (h << (24 - i * 8)) & 0xff000000;
|
// System.out.println(Integer.toHexString(b));
|
// System.out.println(Integer.toHexString(b >> (i * 8)));
|
nl = nl + (b >> (i * 8));
|
}
|
|
// /System.out.println(Integer.toHexString(nl));
|
return nl;
|
}
|
|
public static byte[] htonlbytes(int h) {
|
// return int2bytes(htonl(h));
|
return int2bytes(h);
|
}
|
|
/**
|
*
|
* @param h
|
* int
|
* @return int
|
*/
|
public static int htons(int h) {
|
int ns = 0;
|
int b = 0;
|
for (int i = 0; i < 2; i++) {
|
b = (h << (8 - i * 8)) & 0xff00;
|
// System.out.println(Integer.toHexString(b));
|
// System.out.println(Integer.toHexString(b >> 8));
|
ns = ns + (b >> (i * 8));
|
}
|
|
// System.out.println(Integer.toHexString(ns));
|
return ns;
|
}
|
|
public static byte[] htonsbytes(int h) {
|
// return short2bytes(htons(h));
|
return short2bytes(h);
|
}
|
|
/**
|
*
|
* @param n
|
* int
|
* @return int
|
*/
|
public static int ntohl(int n) {
|
return htonl(n);
|
}
|
|
public static int nbytestohl(byte[] n) {
|
// return ntohl(bytes2int(n));
|
return bytes2int(n);
|
}
|
|
public static int ntohs(int n) {
|
return htons(n);
|
}
|
|
public static int nbytestohs(byte[] n) {
|
// return ntohs(byte2short(n));
|
return byte2short(n);
|
}
|
|
// /**
|
// * getZteIHLRChecksum
|
// * @param msg char[]
|
// * @return char[]
|
// */
|
// public static char[] getZteIHLRChecksum(char[] msg) {
|
// int i = 0, j = 0;
|
// char[] checksum = new char[4];
|
//
|
// for (i = 0; i < msg.length / 4; i++) {
|
// for (j = 0; j < 4; j++) {
|
// checksum[j] ^= msg[i * 4 + j];
|
// }
|
// }
|
//
|
// for (j = 0; j < msg.length % 4; j++) {
|
// checksum[j] ^= msg[i * 4 + j];
|
// }
|
//
|
// for (i = 0; i < 4; i++) {
|
// int k = ~checksum[i] & 0xff;
|
// checksum[i] = (char) k;
|
// }
|
//
|
// StringBuffer sb = new StringBuffer();
|
// for (i = 0; i < 4; i++) {
|
// String s = Integer.toHexString(checksum[i] & 0xff).toUpperCase();
|
// if (s.length() < 2) {
|
// sb.append("0").append(s);
|
// }
|
// else {
|
// sb.append(s);
|
// }
|
// }
|
//
|
// return sb.toString().toCharArray();
|
// }
|
|
// /**
|
// * getZtePCSChecksum
|
// * @param msg char[]
|
// * @return char[]
|
// */
|
// public static char[] getZtePCSChecksum(char[] msg) {
|
// int i = 0, j = 0;
|
// char[] checksum = new char[4];
|
//
|
// for (i = 2; i < (msg.length - 8) / 4; i++) {
|
// for (j = 0; j < 4; j++) {
|
// checksum[j] ^= msg[i * 4 + j];
|
// }
|
// }
|
//
|
// for (i = 0; i < 4; i++) {
|
// int k = ~checksum[i] & 0xff;
|
// checksum[i] = (char) k;
|
// }
|
//
|
// StringBuffer sb = new StringBuffer();
|
// for (i = 0; i < 4; i++) {
|
// String s = Integer.toHexString(checksum[i] & 0xff).toUpperCase();
|
// if (s.length() < 2) {
|
// sb.append("0").append(s);
|
// }
|
// else {
|
// sb.append(s);
|
// }
|
// }
|
//
|
// return sb.toString().toCharArray();
|
// }
|
|
/**
|
* 为比对字节好用，显示输出格尺
|
*/
|
public static void showGrid() {
|
for (int i = 0; i < 10; i++) {
|
System.out.print("0123456789");
|
}
|
System.out.println();
|
}
|
|
/**
|
*
|
* @param buf
|
* byte[]
|
*/
|
public static void showBytes(byte[] buf) {
|
if (buf == null) {
|
buf = new byte[0];
|
}
|
String hex = "";
|
byte[] s = new byte[16];
|
System.out.println("[BYTES INFO] : LENGTH = " + buf.length + "(0x"
|
+ Integer.toHexString(buf.length) + ")");
|
for (int i = 0; i < buf.length; i++) {
|
if (i % 16 == 0) { // 行号
|
hex = Integer.toHexString((i & 0xff) / 16); // hex 字符
|
if (hex.length() == 1) {
|
hex = "0" + hex;
|
}
|
System.out.print("[" + hex + "] ");
|
}
|
|
hex = Integer.toHexString(((byte) buf[i]) & 0xff); // hex 字符
|
if (hex.length() == 1) {
|
hex = "0" + hex;
|
}
|
System.out.print(hex + " "); // 输出HEX
|
s[i % 16] = buf[i];
|
|
if (i != 0 && i % 8 == 7 && i % 16 != 15) { // 8 字节
|
System.out.print(" ");
|
}
|
|
if (i != 0 && (i % 16 == 15 || i == buf.length - 1)) { // 16字节或结束
|
if (i % 16 != 15) { // 补空格
|
for (int k = i % 16; k < 16; k++) {
|
if (k == 7) {
|
System.out.print(" ");
|
} else {
|
System.out.print(" ");
|
}
|
}
|
}
|
|
System.out.print(" "); // 输出可打印字符
|
byte c = 126;
|
for (int j = 0; j < i % 16 + 1; j++) {
|
if (s[j] == 0 || s[j] <= ' ' || s[j] > c) {
|
s[j] = '.';
|
}
|
System.out.print((char) s[j]);
|
}
|
|
System.out.print("\n"); // 输出换行
|
}
|
}
|
|
System.out.println("");
|
}
|
|
/**
|
*
|
* @param args
|
* String[]
|
*/
|
// @SuppressWarnings("unused")
|
// public static void main(String[] args) {
|
// // /byte[] hex = hex2bytes("013233");
|
// // /String hhh = bytes2hex(hex);
|
//
|
// String dd =
|
// "SCSC003C1.00JS123456UASUAS 00000000DLGCON 00000001TXBEG HBHB";
|
// // C5F6F7B2
|
// // /char[] s = dd.toCharArray();
|
// showBytes(dd.getBytes());
|
// //
|
// System.out.println(ByteUtils.getZteIHLRChecksum("HBHB".toCharArray()));
|
// // // it
|
// // is ok. B7BDB7BD
|
// // System.out.println(ByteUtils.getZteIHLRChecksum(s)); // it is ok.
|
// // System.out.println(ByteUtils.getZtePCSChecksum(s));
|
//
|
// byte[] length = new byte[20];
|
// byte[] to = new byte[10];
|
// ByteUtils.memset(length, (byte) '0', 0, 20);
|
// ByteUtils.memcpy(to, 0, length, 20);
|
// System.out.println(new String(ByteUtils.toHexBytes(255, 2, (byte) '0')));
|
// System.out.println(new String(ByteUtils.fillHead(to, 20, (byte) '1')));
|
// System.out.println(new String(ByteUtils.fillTail(to, 15, (byte) '9')));
|
// System.out.println(new String(ByteUtils.copyto(to, "hello!".getBytes(),
|
// 0, 10)));
|
// System.out.println(new String(ByteUtils.copyto(to,
|
// "Hello world!".getBytes(), 2, 15)));
|
//
|
// System.out.println(new String(ByteUtils.copy(to, 5, 6)));
|
// System.out.println(new String(ByteUtils.delete("Hello world".getBytes(),
|
// 5, 6)));
|
// System.out.println(new String(ByteUtils.insert(to, "Gogogo!".getBytes(),
|
// 5, 5)));
|
// ByteUtils.memset(length, (byte) '5', 10, 10);
|
// System.out.println(new String(length));
|
// System.out.println(new String(ByteUtils.insert(length,
|
// "Gogogo!".getBytes(), 8, 8)));
|
//
|
// ByteUtils.showGrid();
|
//
|
// System.out.println(new String(int2bytes(0x1c1d1e1f)));
|
//
|
// int n = htonl(0x12345678);
|
// System.out.println(Integer.toHexString(n));
|
// n = ntohl(n);
|
// System.out.println(Integer.toHexString(n));
|
//
|
// n = htons(0x1234);
|
// System.out.println(Integer.toHexString(n));
|
// n = htons(n);
|
// System.out.println(Integer.toHexString(n));
|
//
|
// byte[] z = htonlbytes(0x12345678);
|
// System.out.println(new String(z));
|
// z = htonsbytes(0x1234);
|
// System.out.println(new String(z));
|
//
|
// byte[] j = ByteUtils.short2bytes(0x94d8);
|
// System.out.println(Integer.toHexString(0x94d8));
|
//
|
// int ddd = ByteUtils.byte2short(j);
|
// }
|
}
|
