package com.dy.common.util;
|
|
import java.util.Locale;
|
|
|
public class ByteUtil {
|
|
/**
|
* 将字节数组合并到字节数组上
|
* @param bGroup1 被合并数组
|
* @param bGroup2 合并数组
|
* @return 返回 合并后数组
|
*/
|
public static byte[] bytesMerge(byte[] bGroup1, byte[] bGroup2){
|
if(bGroup1 == null && bGroup2 == null){
|
return null ;
|
}else if(bGroup1 == null && bGroup2 != null){
|
return bGroup2 ;
|
}else if(bGroup1 != null && bGroup2 == null){
|
return bGroup1 ;
|
}else{
|
//dest != null && append != null
|
byte[] bs = new byte[bGroup1.length + bGroup2.length] ;
|
System.arraycopy(bGroup1, 0, bs, 0, bGroup1.length) ;
|
System.arraycopy(bGroup2, 0, bs, bGroup1.length, bGroup2.length) ;
|
return bs ;
|
}
|
}
|
|
/**
|
* 判断所有字节是否为0xFF
|
* @param bs 字节数组
|
* @param index 下标位
|
* @param len 长度
|
* @return 返回 返回
|
*/
|
public static boolean bytesIsAll0xFF(byte[] bs, int index, int len){
|
int count = 0 ;
|
for(int i = index; i < index + len; i++){
|
if(bs[i] == (byte)0xFF){
|
count++ ;
|
}
|
}
|
return count == len;
|
}
|
|
/**
|
* 二进制转十进制数
|
* @param str 二进制字符串
|
* @return 返回
|
*/
|
public static int binary2Int(String str) {
|
return Integer.parseInt(str, 2);
|
}
|
|
|
/**
|
* 字节转存二进制
|
*
|
* @param b byte
|
* @return 返回 String
|
*/
|
public static String byte2Binary(byte b) {
|
return Integer.toBinaryString(b & 0xFF) ;
|
}
|
/**
|
* 字节转存8位二进制
|
*
|
* @param b byte
|
* @return 返回 String
|
*/
|
public static String byte2bit8Binary(byte b) {
|
String s = byte2Binary(b);
|
int len = s.length();
|
for (int i = 0; i < 8 - len; i++) {
|
s = "0" + s;
|
}
|
return s;
|
}
|
|
/**
|
* 字节数 取出8个bit
|
* @param b 字节数
|
* @return 返回 String
|
*/
|
public static byte[] getBit(byte b) {
|
byte[] bs = new byte[8] ;
|
bs[0] = (byte)(b & 1) ;
|
bs[1] = (byte)((b & 2) >> 1) ;
|
bs[2] = (byte)((b & 4) >> 2) ;
|
bs[3] = (byte)((b & 8) >> 3) ;
|
bs[4] = (byte)((b & 16) >> 4) ;
|
bs[5] = (byte)((b & 32) >> 5) ;
|
bs[6] = (byte)((b & 64) >> 6) ;
|
bs[7] = (byte)((b & 128) >> 7) ;
|
return bs;
|
}
|
|
/**
|
* 字节数 取出bit
|
* @param b 字节数
|
* @param index 下标位
|
* @throws Exception 异常
|
* @return 返回 String
|
*/
|
public static byte getBit(byte b, byte index) throws Exception {
|
if(index == 0){
|
return (byte)(b & 1) ;
|
}else if(index == 1){
|
return (byte)((b & 2) >> 1) ;
|
}else if(index == 2){
|
return (byte)((b & 4) >> 2) ;
|
}else if(index == 3){
|
return (byte)((b & 8) >> 3) ;
|
}else if(index == 4){
|
return (byte)((b & 16) >> 4) ;
|
}else if(index == 5){
|
return (byte)((b & 32) >> 5) ;
|
}else if(index == 6){
|
return (byte)((b & 64) >> 6) ;
|
}else if(index == 7){
|
return (byte)((b & 128) >> 7) ;
|
}
|
return 0;
|
}
|
|
|
/**
|
* 一个字节转正整数
|
*
|
* @param b
|
* byte
|
* @throws Exception 异常
|
* @return 返回 String
|
*/
|
public static Short byte2PlusInt(byte b) throws Exception {
|
short v = b ;
|
if(v < 0){
|
v = (short)(255 + v + 1) ;
|
}
|
return v ;
|
}
|
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* double转换byte
|
* @param bs 字节数组 byte[]
|
* @param value double double类型的参数
|
* @param from 开始位 int
|
*/
|
public static void double2Bytes_BE(byte[] bs, double value, int from)throws Exception {
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + 8);
|
if (b) {
|
long2Bytes_BE(bs, Double.doubleToLongBits(value), from);
|
} else {
|
throw new Exception("double2Bytes时数组越界");
|
}
|
}
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* double转换byte，字节顺序是倒的
|
* @param bs 字节数组 byte[]
|
* @param value double double类型的参数
|
* @param from 开始位 int
|
*/
|
public static void double2Bytes_LE(byte[] bs, double value, int from)throws Exception {
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + 8);
|
if (b) {
|
long2Bytes_LE(bs, Double.doubleToLongBits(value), from);
|
} else {
|
throw new Exception("double2Bytes时数组越界");
|
}
|
}
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* byte转换double
|
* @param bs 字节数组 byte[]
|
* @param from 开始位 int
|
*/
|
public static double bytes2Double_BE(byte[] bs, int from) throws Exception {
|
long l = bytes2Long_BE(bs, from);
|
return Double.longBitsToDouble(l);
|
}
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* byte转换double，字节顺序是倒的
|
* @param bs 字节数组 byte[]
|
* @param from 开始位 int
|
*/
|
public static double bytes2Double_LE(byte[] bs, int from) throws Exception {
|
long l = bytes2Long_LE(bs, from);
|
return Double.longBitsToDouble(l);
|
}
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* float转换byte
|
* @value bs byte[]
|
* @value value float float类型的参数
|
* @value from int
|
*/
|
public static void float2Bytes_BE(byte[] bs, float value, int from)
|
throws Exception {
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + 4);
|
if (b) {
|
Integer it = Float.floatToIntBits(value);
|
int2Bytes_BE(bs, it, from);
|
} else {
|
throw new Exception("float2Bytes时数组越界");
|
}
|
}
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* float转换byte，字节顺序是倒的
|
* @value bs byte[]
|
* @value value float float类型的参数
|
* @value from int
|
*/
|
public static void float2Bytes_LE(byte[] bs, float value, int from) throws Exception {
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + 4);
|
if (b) {
|
Integer it = Float.floatToIntBits(value);
|
int2Bytes_LE(bs, it, from);
|
} else {
|
throw new Exception("float2Bytes时数组越界");
|
}
|
}
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* byte转换float
|
* @value bs byte[]
|
* @value from int
|
*/
|
public static float bytes2Float_BE(byte[] bs, int from) throws Exception {
|
int i = bytes2Int_BE(bs, from);
|
return Float.intBitsToFloat(i);
|
}
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* byte转换float，字节顺序是倒的
|
* @value bs byte[]
|
* @value from int
|
*/
|
public static float bytes2Float_LE(byte[] bs, int from) throws Exception {
|
int i = bytes2Int_LE(bs, from);
|
return Float.intBitsToFloat(i);
|
}
|
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* 转换long型为byte数组
|
* @value bs byte[]
|
* @value value long
|
* @value from int
|
*/
|
public static void long2Bytes_BE(byte[] bs, long value, int from)throws Exception {
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + 8);
|
if (b) {
|
for (int i = 7; i >= 0; i--) {
|
bs[from + i] = Long.valueOf(value & 0xff).byteValue();// 将最低位保存在最低位
|
value = value >> 8; // 向右移8位
|
if(value == 0){
|
break ;
|
}
|
}
|
} else {
|
throw new Exception("long2Bytes时数组越界");
|
}
|
}
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* 转换long型为byte数组
|
* @value bs byte[]
|
* @value value long
|
* @value from int
|
*/
|
public static void long2Bytes_LE(byte[] bs, long value, int from)throws Exception {
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + 8);
|
if (b) {
|
for (int i = 0; i < 8; i++) {
|
bs[from + i] = Long.valueOf(value & 0xff).byteValue();
|
value = value >> 8;
|
if(value == 0){
|
break ;
|
}
|
}
|
} else {
|
throw new Exception("long2Bytes时数组越界");
|
}
|
}
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* 8位字节数组转换为长整型
|
* @param bs 字节数组 byte[]
|
* @return 返回
|
*/
|
public static long bytes2Long_BE(byte[] bs) {
|
int len = bs.length ;
|
if (len > 0) {
|
long l = 0;
|
long[] ls = new long[len] ;
|
for(int i = 0 ; i < len; i++){
|
ls[i] = bs[i] & 0xFF ;
|
}
|
for(int i = len-1 ; i >= 0; i--){
|
ls[(len - 1) - i] <<= 8 * i ;
|
}
|
for(int i = 0 ; i < len; i++){
|
l = l | ls[i] ;
|
}
|
return l;
|
}
|
return 0L ;
|
}
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* 8位字节数组转换为长整型
|
* @param bs 字节数组 byte[]
|
* @param from 开始位 int
|
* @return 返回
|
*/
|
public static long bytes2Long_BE(byte[] bs, int from) throws Exception {
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + 8);
|
if (b) {
|
long s = 0;
|
long s0 = bs[from + 0] & 0xFF ;// 最低位
|
long s1 = bs[from + 1] & 0xFF ;
|
long s2 = bs[from + 2] & 0xFF ;
|
long s3 = bs[from + 3] & 0xFF ;
|
long s4 = bs[from + 4] & 0xFF ;
|
long s5 = bs[from + 5] & 0xFF ;
|
long s6 = bs[from + 6] & 0xFF ;
|
long s7 = bs[from + 7] & 0xFF ;
|
|
// s7不变
|
s6 <<= 8;
|
s5 <<= 16;
|
s4 <<= 24;
|
s3 <<= 8 * 4;
|
s2 <<= 8 * 5;
|
s1 <<= 8 * 6;
|
s0 <<= 8 * 7;
|
s = s0 | s1 | s2 | s3 | s4 | s5 | s6 | s7;
|
return s;
|
} else {
|
throw new Exception("byte2Long时数组越界");
|
}
|
}
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* 8位字节数组转换为长整型
|
* @param bs 字节数组 byte[]
|
* @param from 开始位 int
|
* @param end int
|
* @return 返回
|
*/
|
public static long bytes2Long_BE(byte[] bs, int from, int end) throws Exception {
|
boolean b = isOutOfArrLength(bs.length, end);
|
if (b) {
|
short len = (short)(end - from + 1) ;
|
long[] ls = new long[len] ;
|
for(short i = 0 ; i < len; i++){
|
ls[i] = bs[from + i] & 0xFF ;
|
}
|
for(short i = (short)(len-1) ; i >= 0; i--){
|
ls[i] <<= 8 * (len - (i + 1)) ;
|
}
|
long s = 0;
|
for(short i = 0 ; i < len; i++){
|
s = s | ls[i] ;
|
}
|
return s;
|
} else {
|
throw new Exception("byte2Long时数组越界");
|
}
|
}
|
|
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* 8位字节数组转换为长整型
|
* @param bs 字节数组 byte[]
|
* @return 返回
|
*/
|
public static long bytes2Long_LE(byte[] bs) {
|
int len = bs.length ;
|
if (len > 0) {
|
long l = 0;
|
long[] ls = new long[len] ;
|
for(int i = 0 ; i < len; i++){
|
ls[i] = bs[i] & 0xFF ;
|
}
|
for(int i = 0 ; i < len; i++){
|
ls[(len - 1) - i] <<= 8 * i ;
|
}
|
for(int i = 0 ; i < len; i++){
|
l = l | ls[i] ;
|
}
|
return l;
|
}
|
return 0L ;
|
}
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* 8位字节数组转换为长整型
|
* @param bs 字节数组 byte[]
|
* @param from 开始位 int
|
* @return 返回
|
*/
|
public static long bytes2Long_LE(byte[] bs, int from) throws Exception {
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + 8);
|
if (b) {
|
long s = 0;
|
long s0 = bs[from] & 0xFF ;// 最低位
|
long s1 = bs[from + 1] & 0xFF ;
|
long s2 = bs[from + 2] & 0xFF ;
|
long s3 = bs[from + 3] & 0xFF ;
|
long s4 = bs[from + 4] & 0xFF ;
|
long s5 = bs[from + 5] & 0xFF ;
|
long s6 = bs[from + 6] & 0xFF ;
|
long s7 = bs[from + 7] & 0xFF ;
|
|
// s0不变
|
s1 <<= 8;
|
s2 <<= 16;
|
s3 <<= 24;
|
s4 <<= 8 * 4;
|
s5 <<= 8 * 5;
|
s6 <<= 8 * 6;
|
s7 <<= 8 * 7;
|
s = s0 | s1 | s2 | s3 | s4 | s5 | s6 | s7;
|
return s;
|
} else {
|
throw new Exception("byte2Long时数组越界");
|
}
|
}
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* 8位字节数组转换为长整型
|
* @param bs 字节数组 byte[]
|
* @param from 开始位 int
|
* @param end int
|
* @return 返回
|
*/
|
public static long bytes2Long_LE(byte[] bs, int from, int end) throws Exception {
|
boolean b = isOutOfArrLength(bs.length, end);
|
if (b) {
|
short len = (short)(end - from + 1) ;
|
long[] ls = new long[len] ;
|
for(short i = 0 ; i < len; i++){
|
ls[i] = bs[from + i] & 0xFF ;
|
}
|
for(short i = 0 ; i < len; i++){
|
ls[i] <<= 8 * i ;
|
}
|
long s = 0;
|
for(short i = 0 ; i < len; i++){
|
s = s | ls[i] ;
|
}
|
return s;
|
} else {
|
throw new Exception("byte2Long时数组越界");
|
}
|
}
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* int类型转换成4位byte数组
|
* @value bs byte[]
|
* @value value int int类型的参数
|
* @value from int
|
*/
|
public static void int2Bytes_BE(byte[] bs, int value, int from)throws Exception {
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + 4);
|
if (b) {
|
for (int i = 3; i >= 0; i--) {
|
bs[from + i] = Integer.valueOf(value & 0xff).byteValue();// 将最低位保存在高字节
|
value = value >> 8; // 向右移8位
|
if(value == 0){
|
break ;
|
}
|
}
|
} else {
|
throw new Exception("int2Bytes时数组越界");
|
}
|
}
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* int类型转换成4位byte数组，字节顺序是倒的
|
* @value bs byte[]
|
* @value value int int类型的参数
|
* @value from int
|
*/
|
public static void int2Bytes_LE(byte[] bs, int value, int from)throws Exception {
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + 4);
|
if (b) {
|
for (int i = 0; i < 4; i++) {
|
bs[from + i] = Integer.valueOf(value & 0xff).byteValue();// 将最低位保存在低字节
|
value = value >> 8; // 向右移8位
|
if(value == 0){
|
break ;
|
}
|
}
|
} else {
|
throw new Exception("int2Bytes时数组越界");
|
}
|
}
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* 4位字节数组转换为整型
|
* @param bs 字节数组
|
* @param from 开始位
|
* @return 返回
|
*/
|
public static int bytes2Int_BE(byte[] bs, int from) throws Exception {
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + 4);
|
if (b) {
|
int s = 0;
|
int s0 = bs[from + 0] & 0xFF ;// 最低位
|
int s1 = bs[from + 1] & 0xFF ;
|
int s2 = bs[from + 2] & 0xFF ;
|
int s3 = bs[from + 3] & 0xFF ;
|
|
// s3不变
|
s2 <<= 8;
|
s1 <<= 16;
|
s0 <<= 24;
|
s = s0 | s1 | s2 | s3;
|
return s;
|
} else {
|
throw new Exception("byte2Int时数组越界");
|
}
|
}
|
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* 4位字节数组转换为整型，字节顺序是倒的
|
* @param bs 字节数组 字节数组
|
* @return 返回
|
*/
|
public static int bytes2Int_LE(byte[] bs, int from) throws Exception {
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + 4);
|
if (b) {
|
int s = 0;
|
int s0 = bs[from + 0] & 0xFF ;// 最低位
|
int s1 = bs[from + 1] & 0xFF ;
|
int s2 = bs[from + 2] & 0xFF ;
|
int s3 = bs[from + 3] & 0xFF ;
|
|
// s0不变
|
s1 <<= 8;
|
s2 <<= 16;
|
s3 <<= 24;
|
s = s0 | s1 | s2 | s3;
|
return s;
|
} else {
|
throw new Exception("byte2Int时数组越界");
|
}
|
}
|
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* short类型转换成byte数组
|
* @value bs byte[]
|
* @value value short
|
* @value from int
|
*/
|
public static void short2Bytes_BE(byte[] bs, short value, int from)throws Exception {
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + 2);
|
if (b) {
|
for (int i = 1; i >= 0 ; i--) {
|
bs[from + i] = Integer.valueOf(value & 0xff).byteValue();// 将低位保存在高字节
|
value = (short) (value >> 8); // 向右移8位
|
}
|
} else {
|
throw new Exception("short2Bytes时数组越界");
|
}
|
}
|
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* short类型转换成byte数组，字节顺序是倒的
|
* @value bs byte[]
|
* @value value short
|
* @value from int
|
*/
|
public static void short2Bytes_LE(byte[] bs, short value, int from)throws Exception {
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + 2);
|
if (b) {
|
for (int i = 0; i < 2; i++) {
|
bs[from + i] = Integer.valueOf(value & 0xff).byteValue();// 将最低位保存在低字节
|
value = (short) (value >> 8); // 向右移8位
|
}
|
} else {
|
throw new Exception("short2Bytes时数组越界");
|
}
|
}
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* short类型转换成byte数组
|
* @value value short
|
* @value from int
|
*/
|
public static byte[] short2Bytes_BE(short value)throws Exception {
|
byte[] bs = new byte[2] ;
|
for (int i = 1; i >= 0 ; i--) {
|
bs[i] = (byte)(value & 0xff) ;// 将低位保存在高字节
|
value = (short) (value >> 8); // 向右移8位
|
}
|
return bs ;
|
}
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* short类型转换成byte数组，字节顺序是倒的
|
* @value value short
|
* @value from int
|
*/
|
public static byte[] short2Bytes_LE(short value)throws Exception {
|
byte[] bs = new byte[2] ;
|
for (int i = 0; i < 2; i++) {
|
bs[i] = (byte)(value & 0xff) ;// 将最低位保存在低字节
|
value = (short) (value >> 8); // 向右移8位
|
}
|
return bs ;
|
}
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* 2位字节数组转换为短整型
|
* @param bs 字节数组 字节数组
|
* @return 返回
|
*/
|
public static short bytes2Short_BE(byte[] bs, int from) throws Exception {
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + 2);
|
if (b) {
|
int s = 0;
|
int s0 = bs[from + 0] & 0xFF ;
|
int s1 = bs[from + 1] & 0xFF ;
|
|
// s1不变
|
s0 <<= 8;
|
s = s0 | s1;
|
return (short) s;
|
|
} else {
|
throw new Exception("byte2Short时数组越界");
|
}
|
}
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* 2位字节数组转换为短整型，字节顺序是倒的
|
* @param bs 字节数组 字节数组
|
* @return 返回
|
*/
|
public static short bytes2Short_LE(byte[] bs, int from) throws Exception {
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + 2);
|
if (b) {
|
int s = 0;
|
int s0 = bs[from + 0] & 0xFF ;
|
int s1 = bs[from + 1] & 0xFF ;
|
|
// s0不变
|
s1 <<= 8;
|
s = s0 | s1;
|
return (short) s;
|
|
} else {
|
throw new Exception("byte2Short时数组越界");
|
}
|
}
|
/**
|
* 字符到一字节转换
|
*
|
* @value bs byte[]
|
* @value ch char char类型的参数
|
* @value index int
|
* @return 返回
|
*/
|
public static void char2Bytes(byte[] bs, char ch, int index)throws Exception {
|
boolean b = isOutOfArrLength(bs.length, index);
|
if (b) {
|
bs[index] = (byte) ch;
|
} else {
|
throw new Exception("char2Bytes时数组越界");
|
}
|
}
|
|
/**
|
* 一字节转换为字符
|
* @param bs 字节数组 字节数组
|
* @value index int
|
* @return 返回
|
*/
|
public static char bytes2Char(byte[] bs, int index) throws Exception {
|
boolean b = isOutOfArrLength(bs.length, index);
|
if (b) {
|
return (char) bs[index];
|
} else {
|
throw new Exception("byte2Char时数组越界");
|
}
|
}
|
|
/**
|
* 字符串型数字转成byte
|
*
|
* @param s
|
* @return 返回
|
* @throws Exception 异常
|
*/
|
public static byte string2byte(String s) throws Exception {
|
int n ;
|
try {
|
n = Integer.parseInt(s);
|
} catch (Exception e) {
|
throw new Exception("字符串型数字字节时出错，不是合法数字:" + s, null);
|
}
|
return (byte) n;
|
}
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* 字符串转换成byte数组
|
* @value bs byte[]
|
* @value str String
|
* @value from int
|
* @return 返回
|
* @throws java.io.UnsupportedEncodingException
|
*/
|
public static int string2Bytes_BE(byte[] bs, String str, int from, int end)throws Exception {
|
byte[] bb = str.getBytes();
|
boolean b = isOutOfArrLength(bs.length, (from -1 + bb.length));
|
if (b) {
|
if(end - from + 1 < bb.length){
|
throw new Exception("string2Bytes时，字符串转成的字节数组超过的协议定义的长度 ");
|
}else{
|
for (int i = 0; i < bb.length; i++) {
|
bs[from + i] = bb[i];
|
}
|
}
|
} else {
|
throw new Exception("string2Bytes时数组越界");
|
}
|
return bb.length ;
|
}
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* 字符串转换成byte数组
|
* @value bs byte[]
|
* @value str String
|
* @value from int
|
* @return 返回
|
* @throws java.io.UnsupportedEncodingException
|
*/
|
public static int string2Bytes_LE(byte[] bs, String str, int from, int end)throws Exception {
|
byte[] bb = str.getBytes();
|
boolean b = isOutOfArrLength(bs.length, (from -1 + bb.length));
|
if (b) {
|
if(end - from + 1 < bb.length){
|
throw new Exception("string2Bytes时，字符串转成的字节数组超过的协议定义的长度 ");
|
}else{
|
for (int i = bb.length - 1; i >= 0; i--) {
|
bs[from + i] = bb[i];
|
}
|
}
|
} else {
|
throw new Exception("string2Bytes时数组越界");
|
}
|
return bb.length ;
|
}
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* 字符串转换成byte数组
|
* @value bs byte[]
|
* @value str String
|
* @value from int
|
* @return 返回
|
* @throws java.io.UnsupportedEncodingException
|
*/
|
public static int string2Bytes_BE(byte[] bs, String str, int from)throws Exception {
|
byte[] bb = str.getBytes();
|
boolean b = isOutOfArrLength(bs.length, (from -1 + bb.length));
|
if (b) {
|
for (int i = 0; i < bb.length; i++) {
|
bs[from + i] = bb[i];
|
}
|
} else {
|
throw new Exception("string2Bytes时数组越界");
|
}
|
return bb.length ;
|
}
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* 字符串转换成byte数组
|
* @value bs byte[]
|
* @value str String
|
* @value from int
|
* @return 返回
|
* @throws java.io.UnsupportedEncodingException
|
*/
|
public static int string2Bytes_LE(byte[] bs, String str, int from)throws Exception {
|
byte[] bb = str.getBytes();
|
boolean b = isOutOfArrLength(bs.length, (from -1 + bb.length));
|
if (b) {
|
for (int i = bb.length-1; i >= 0; i--) {
|
bs[from + i] = bb[i];
|
}
|
} else {
|
throw new Exception("string2Bytes时数组越界");
|
}
|
return bb.length ;
|
}
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* byte数组转换成字符串
|
* @value bs byte[]
|
* @value str String
|
* @value from int
|
* @throws java.io.UnsupportedEncodingException
|
*/
|
public static String bytes2String_BE(byte[] bs, int from, int end)throws Exception {
|
byte[] bb = new byte[end - from + 1];
|
int count = 0 ;
|
for (int i = from; i <= end; i++) {
|
bb[count++] = bs[i];
|
}
|
return new String(bb);
|
}
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* byte数组转换成字符串
|
* @value bs byte[]
|
* @value str String
|
* @value from int
|
* @throws java.io.UnsupportedEncodingException
|
*/
|
public static String bytes2String_LE(byte[] bs, int from, int end)throws Exception {
|
byte[] bb = new byte[end - from + 1];
|
int count = 0 ;
|
for (int i = end; i >= from; i--) {
|
bb[count++] = bs[i];
|
}
|
return new String(bb);
|
}
|
|
/**
|
* 判断数组下标是否越界
|
*
|
* @value bsLength 数组总长度
|
* @value toSite 数组偏移量
|
* @return 返回
|
*/
|
private static boolean isOutOfArrLength(int bsLength, int toSite) {
|
if (bsLength > toSite) {
|
return true;
|
} else {
|
return false;
|
}
|
}
|
|
|
/**
|
* 字节数组转换成十六进制的字符串
|
*
|
* @param src byte[]
|
* @param hasBlank 16进制是否用空格分隔
|
* @return 返回 String
|
*/
|
public static String bytes2Hex(byte[] src, boolean hasBlank){
|
return bytes2Hex_BE(src, hasBlank) ;
|
}
|
|
/**
|
* 字节数组转换成十六进制的字符串
|
*
|
* @param src byte[]
|
* @param hasBlank 16进制是否用空格分隔
|
* @return 返回 String
|
*/
|
public static String bytes2Hex_BE(byte[] src, boolean hasBlank){
|
StringBuilder stringBuilder = new StringBuilder("");
|
if (src == null || src.length <= 0) {
|
return null;
|
}
|
for (int i = 0; i < src.length; i++) {
|
int v = src[i] & 0xFF;
|
String str = Integer.toHexString(v);
|
if (str.length() < 2) {
|
str = "0" + str;
|
}
|
if (hasBlank) {
|
if (i == 0) {
|
stringBuilder.append(str);
|
} else {
|
stringBuilder.append(" " + str);
|
}
|
} else {
|
stringBuilder.append(str);
|
}
|
}
|
return stringBuilder.toString().toUpperCase(Locale.US);
|
}
|
/**
|
* 字节数组转换成十六进制的字符串
|
*
|
* @param src byte[]
|
* @param hasBlank 16进制是否用空格分隔
|
* @return 返回 String
|
*/
|
public static String bytes2Hex_LE(byte[] src, boolean hasBlank){
|
StringBuilder stringBuilder = new StringBuilder("");
|
if (src == null || src.length <= 0) {
|
return null;
|
}
|
for (int i = src.length - 1 ; i >= 0; i--) {
|
int v = src[i] & 0xFF;
|
String str = Integer.toHexString(v);
|
if (str.length() < 2) {
|
str = "0" + str;
|
}
|
if (hasBlank) {
|
if (i == 0) {
|
stringBuilder.append(str);
|
} else {
|
stringBuilder.append(" " + str);
|
}
|
} else {
|
stringBuilder.append(str);
|
}
|
}
|
return stringBuilder.toString().toUpperCase(Locale.US);
|
}
|
/**
|
* 字节数组转换成十六进制的字符串
|
*
|
* @param bs byte[]
|
* @param hasBlank 16进制是否用空格分隔
|
* @param from 开始位
|
* @param len 长度
|
* @return 返回 String
|
*/
|
public static String bytes2Hex(byte[] bs, boolean hasBlank, int from, int len){
|
if (bs == null || bs.length <= 0 || bs.length < from + len) {
|
return null;
|
}
|
byte[] bb = new byte[len];
|
for (int i = 0 ; i < len; i++) {
|
bb[i] = bs[from + i];
|
}
|
return bytes2Hex(bb, hasBlank) ;
|
}
|
/**
|
* 字节数组转换成十六进制的字符串
|
*
|
* @param bs byte[]
|
* @param hasBlank 16进制是否用空格分隔
|
* @param from 开始位
|
* @param len 长度
|
* @return 返回 String
|
*/
|
public static String bytes2Hex_LE(byte[] bs, boolean hasBlank, int from, int len){
|
if (bs == null || bs.length <= 0 || bs.length < from + len) {
|
return null;
|
}
|
byte[] bb = new byte[len];
|
for (int i = 0 ; i < len; i++) {
|
bb[i] = bs[from + i];
|
}
|
return bytes2Hex_LE(bb, hasBlank) ;
|
}
|
/**
|
* 十六进制转字节数组
|
* @param hex the hex string
|
* @return 返回 byte[]
|
*/
|
public static byte[] hex2Bytes(String hex) {
|
if (hex == null || hex.equals("")) {
|
return null;
|
}
|
hex = hex.toUpperCase(Locale.ENGLISH);
|
int length = hex.length() / 2;
|
char[] hexChars = hex.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;
|
}
|
/**
|
* 十六进制转字节数组
|
* @param hex the hex string
|
* @return 返回 byte[]
|
*/
|
public static int hex2Bytes(String hex, byte[] bs, int fromIndex) {
|
if (hex == null || hex.equals("")) {
|
return fromIndex;
|
}
|
hex = hex.toUpperCase(Locale.ENGLISH);
|
int length = hex.length() / 2;
|
char[] hexChars = hex.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]));
|
}
|
for(int i = 0 ; i < d.length; i++){
|
bs[fromIndex++] = d[i] ;
|
}
|
return fromIndex ;
|
}
|
|
private static final char[] HEX_CHAR = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
|
// /**
|
// * 将byte[]转换为16进制字符串
|
// *
|
// * @param bytes 待转换byte[]
|
// * @return 返回 转换后的字符串
|
// */
|
// public static String bytesToHex(byte[] bytes) {
|
// //一个byte为8位，可用两个十六进制位标识
|
// char[] buf = new char[bytes.length * 2];
|
// int a = 0;
|
// int index = 0;
|
// for (byte b : bytes) { // 使用除与取余进行转换
|
// if (b < 0) {
|
// a = 256 + b;
|
// } else {
|
// a = b;
|
// }
|
//
|
// buf[index++] = HEX_CHAR[a / 16];
|
// buf[index++] = HEX_CHAR[a % 16];
|
// }
|
// return new String(buf);
|
// }
|
// /**
|
// * 将byte[]转换为16进制字符串
|
// *
|
// * @param bytes 待转换byte[]
|
// * @return 返回 转换后的字符串
|
// */
|
// public static String bytesToHex_BE(byte[] bytes, int startIndex, int endIndex) {
|
// byte[] bs = new byte[endIndex - startIndex + 1] ;
|
// byte j = 0 ;
|
// for(int i = startIndex; i <= endIndex; i++){
|
// bs[j++] = bytes[i] ;
|
// }
|
// //一个byte为8位，可用两个十六进制位标识
|
// char[] buf = new char[bs.length * 2];
|
// int a = 0;
|
// int index = 0;
|
// for (byte b : bs) { // 使用除与取余进行转换
|
// if (b < 0) {
|
// a = 256 + b;
|
// } else {
|
// a = b;
|
// }
|
//
|
// buf[index++] = HEX_CHAR[a / 16];
|
// buf[index++] = HEX_CHAR[a % 16];
|
// }
|
// return new String(buf);
|
// }
|
//
|
// /**
|
// * 将byte[]转换为16进制字符串
|
// *
|
// * @param bytes 待转换byte[]
|
// * @return 返回 转换后的字符串
|
// */
|
// public static String bytesToHex_LE(byte[] bytes, int startIndex, int endIndex) {
|
// byte[] bs = new byte[endIndex - startIndex + 1] ;
|
// byte j = 0 ;
|
// for(int i = endIndex; i >= startIndex; i--){
|
// bs[j++] = bytes[i] ;
|
// }
|
// //一个byte为8位，可用两个十六进制位标识
|
// char[] buf = new char[bs.length * 2];
|
// int a = 0;
|
// int index = 0;
|
// for (byte b : bs) { // 使用除与取余进行转换
|
// if (b < 0) {
|
// a = 256 + b;
|
// } else {
|
// a = b;
|
// }
|
//
|
// buf[index++] = HEX_CHAR[a / 16];
|
// buf[index++] = HEX_CHAR[a % 16];
|
// }
|
// return new String(buf);
|
// }
|
//
|
// /**
|
// * 将16进制字符串转换为byte[]
|
// *
|
// * @param str 待转换字符串
|
// * @return 返回 转换后的byte[]
|
// */
|
// public static byte[] hexToBytes(String str) {
|
// if (str == null || "".equals(str.trim())) {
|
// return new byte[0];
|
// }
|
//
|
// byte[] bytes = new byte[str.length() / 2];
|
// for (int i = 0; i < str.length() / 2; i++) {
|
// String subStr = str.substring(i * 2, i * 2 + 2);
|
// bytes[i] = (byte) Integer.parseInt(subStr, 16);
|
// }
|
//
|
// return bytes;
|
// }
|
|
/**
|
* Convert char to byte
|
* @param c char
|
* @return 返回 byte
|
*/
|
private static byte charToByte(char c) {
|
return (byte) "0123456789ABCDEF".indexOf(c);
|
}
|
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* 整形转成BCD编码
|
* @param i
|
* @return 返回
|
*/
|
public static byte[] int2BCD_BE(int i)throws Exception {
|
String str = "" + i;
|
byte[] b = null;
|
if (str.length() % 2 == 0) {
|
b = new byte[str.length() / 2];
|
} else {
|
b = new byte[(str.length() / 2) + 1];
|
}
|
encodeBCD_BE(str, b, 0, b.length);
|
|
return b;
|
}
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* 整形转成BCD编码，字节顺序是倒的
|
* @param i
|
* @return 返回
|
*/
|
public static byte[] int2BCD_LE(int i)throws Exception {
|
String str = "" + i;
|
byte[] b = null;
|
if (str.length() % 2 == 0) {
|
b = new byte[str.length() / 2];
|
} else {
|
b = new byte[(str.length() / 2) + 1];
|
}
|
encodeBCD_LE(str, b, 0, b.length);
|
|
return b;
|
}
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* 长整形转成BCD编码
|
* @param l
|
* @return 返回
|
*/
|
public static byte[] long2BCD_BE(long l)throws Exception {
|
String str = "" + l;
|
byte[] b = null;
|
if (str.length() % 2 == 0) {
|
b = new byte[str.length() / 2];
|
} else {
|
b = new byte[(str.length() / 2) + 1];
|
}
|
encodeBCD_BE(str, b, 0, b.length);
|
|
return b;
|
}
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* 长整形转成BCD编码，字节顺序是倒的
|
* @param l
|
* @return 返回
|
*/
|
public static byte[] long2BCD_LE(long l) throws Exception {
|
String str = "" + l;
|
byte[] b = null;
|
if (str.length() % 2 == 0) {
|
b = new byte[str.length() / 2];
|
} else {
|
b = new byte[(str.length() / 2) + 1];
|
}
|
encodeBCD_LE(str, b, 0, b.length);
|
|
return b;
|
}
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* 字符串型数字转成BCD编码
|
* @param s
|
* @return 返回
|
* @throws Exception 异常
|
*/
|
public static byte[] string2BCD_BE(String s) throws Exception {
|
byte[] b ;
|
if (s.length() % 2 == 0) {
|
b = new byte[s.length() / 2];
|
} else {
|
b = new byte[(s.length() / 2) + 1];
|
}
|
|
encodeBCD_BE(s, b, 0, b.length);
|
|
return b ;
|
}
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* 字符串转换成byte数组
|
* @value bs byte[]
|
* @value str String
|
* @value fromIndex int
|
* @return 返回
|
* @throws Exception 异常 异常
|
*/
|
public static int string2BCD_BE(byte[] bs, String str, int fromIndex)throws Exception {
|
byte[] bb = string2BCD_BE(str);
|
boolean b = isOutOfArrLength(bs.length, (fromIndex -1 + bb.length));
|
if (b) {
|
for (int i = 0; i < bb.length; i++) {
|
bs[fromIndex + i] = bb[i];
|
}
|
} else {
|
throw new Exception("string2BCD时数组越界");
|
}
|
return bb.length ;
|
}
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* 字符串型数字转成BCD编码，字节顺序是倒的
|
* @param s
|
* @return 返回
|
* @throws Exception 异常
|
*/
|
public static byte[] string2BCD_LE(String s) throws Exception {
|
byte[] b = null;
|
if (s.length() % 2 == 0) {
|
b = new byte[s.length() / 2];
|
} else {
|
b = new byte[(s.length() / 2) + 1];
|
}
|
encodeBCD_LE(s, b, 0, b.length);
|
|
return b;
|
}
|
|
/**
|
* 小端模式《数据低位在数组高字节》
|
* 字符串转换成byte数组
|
* @value bs byte[]
|
* @value str String
|
* @value fromIndex int
|
* @return 返回
|
* @throws Exception 异常 异常
|
*/
|
public static int string2BCD_LE(byte[] bs, String str, int fromIndex)throws Exception {
|
byte[] bb = string2BCD_LE(str);
|
boolean b = isOutOfArrLength(bs.length, (fromIndex -1 + bb.length));
|
if (b) {
|
for (int i = bb.length-1; i >= 0 ; i--) {
|
bs[fromIndex + i] = bb[i];
|
}
|
} else {
|
throw new Exception("string2BCD时数组越界");
|
}
|
return bb.length ;
|
}
|
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* BCD编码转成整型
|
* @param b
|
* @return 返回
|
* @throws Exception 异常
|
*/
|
public static int BCD2Int_BE(byte b) throws Exception {
|
String str = "";
|
str = decodeBCD_BE(new byte[] { b }, 0, 1);
|
int n = Integer.parseInt(str);
|
return n;
|
}
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* BCD编码转成整型，字节顺序是倒的
|
* @param b
|
* @return 返回
|
* @throws Exception 异常
|
*/
|
public static int BCD2Int_LE(byte b) throws Exception {
|
String str = "";
|
str = decodeBCD_LE(new byte[] { b }, 0, 1);
|
int n = Integer.parseInt(str);
|
return n;
|
}
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* BCD编码转成整型
|
* @param b
|
* @param startIndex
|
* @param endIndex
|
* @return 返回
|
* @throws Exception 异常
|
*/
|
public static int BCD2Int_BE(byte[] b, int startIndex, int endIndex)throws Exception {
|
String str = "";
|
str = decodeBCD_BE(b, startIndex, endIndex - startIndex + 1);
|
int n = Integer.parseInt(str);
|
return n;
|
}
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* BCD编码转成整型，字节顺序是倒的
|
* @param b
|
* @param startIndex
|
* @param endIndex
|
* @return 返回
|
* @throws Exception 异常
|
*/
|
public static int BCD2Int_LE(byte[] b, int startIndex, int endIndex)throws Exception {
|
String str = "";
|
str = decodeBCD_LE(b, startIndex, endIndex - startIndex + 1);
|
int n = Integer.parseInt(str);
|
return n;
|
}
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* BCD编码转成字符串型
|
* @param b
|
* @param startIndex
|
* @param endIndex
|
* @return 返回
|
* @throws Exception 异常
|
*/
|
public static long BCD2Long_BE(byte[] b, int startIndex, int endIndex)throws Exception {
|
String str = "";
|
str = decodeBCD_BE(b, startIndex, endIndex - startIndex + 1);
|
long n = Long.parseLong(str);
|
return n;
|
}
|
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* BCD编码转成字符串型，字节顺序是倒的
|
* @param b
|
* @param startIndex
|
* @param endIndex
|
* @return 返回
|
* @throws Exception 异常
|
*/
|
public static long BCD2Long_LE(byte[] b, int startIndex, int endIndex)throws Exception {
|
String str = "";
|
str = decodeBCD_LE(b, startIndex, endIndex - startIndex + 1);
|
return Long.parseLong(str);
|
}
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* BCD编码转成字符串型
|
* @param b
|
* @param startIndex
|
* @param endIndex
|
* @return 返回
|
* @throws Exception 异常
|
*/
|
public static String BCD2String_BE(byte[] b, int startIndex, int endIndex) throws Exception {
|
return decodeBCD_BE(b, startIndex, endIndex - startIndex + 1);
|
}
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* BCD编码转成字符串型，字节顺序是倒的
|
* @param b
|
* @param startIndex
|
* @param endIndex
|
* @return 返回
|
* @throws Exception 异常
|
*/
|
public static String BCD2String_LE(byte[] b, int startIndex, int endIndex) throws Exception {
|
return decodeBCD_LE(b, startIndex, endIndex - startIndex + 1);
|
}
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* 编码BCD，例如1387编码成 13 87，顺序是正的
|
* @param value
|
* @param dest
|
* @param startIndex
|
* @param length 长度
|
*/
|
private static void encodeBCD_BE(String value, byte[] dest, int startIndex, int length)throws Exception {
|
if (value == null || !value.matches("\\d*")) {
|
throw new Exception("数字转成BCD编码时出错，不是合法数字:" + value, null);
|
}
|
|
int[] tmpInts = new int[2 * length];
|
int index = value.length() - 1;
|
for (int i = tmpInts.length - 1; i >= 0 && index >= 0; i--, index--) {
|
tmpInts[i] = value.charAt(index) - '0';
|
}
|
for (int i = startIndex, j = 0; i < startIndex + length; i++, j++) {
|
dest[i] = (byte) (tmpInts[2 * j] * 16 + tmpInts[2 * j + 1]);
|
}
|
}
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* 编码BCD，例如1387编码成 87 13，顺序是倒的
|
* @param value
|
* @param dest
|
* @param startIndex
|
* @param length 长度
|
*/
|
private static void encodeBCD_LE(String value, byte[] dest, int startIndex, int length)throws Exception {
|
if (value == null || !value.matches("\\d*")) {
|
throw new Exception("数字转成BCD编码时出错，不是合法数字:" + value, null);
|
}
|
|
int[] tmpInts = new int[2 * length];
|
int index = value.length() - 1;
|
for (int i = 0; i <= tmpInts.length - 1 && index >= 0; i++, index--) {
|
tmpInts[i] = value.charAt(index) - '0';
|
}
|
for (int i = startIndex, j = 0; i < startIndex + length; i++, j++) {
|
dest[i] = (byte) (tmpInts[2 * j + 1] * 16 + tmpInts[2 * j] );
|
}
|
}
|
|
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* 解码BCD，顺序是正的
|
* @param src
|
* @param startIndex
|
* @param length 长度
|
* @return 返回
|
*/
|
private static String decodeBCD_BE(byte[] src, int startIndex, int length)throws Exception {
|
StringBuilder sb = new StringBuilder();
|
for (int i = startIndex; i < startIndex + length ; i++) {
|
int value = (src[i] + 256) % 256;
|
sb.append((char) (value / 16 + '0')).append((char) (value % 16 + '0'));
|
value++;
|
}
|
String result = sb.toString();
|
if (!result.matches("\\d*")) {
|
throw new Exception("解码BCD，但数据（" + result + "[startIndex=" + startIndex + ",length=" + length + "]）非BCD码！");
|
}
|
return result;
|
}
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* 编码BCD，顺序是倒的
|
* @param src
|
* @param startIndex
|
* @param length 长度
|
* @return 返回
|
*/
|
private static String decodeBCD_LE(byte[] src, int startIndex, int length)throws Exception {
|
StringBuilder sb = new StringBuilder();
|
for (int i = (startIndex + length - 1); i >= startIndex; i--) {
|
int value = (src[i] + 256) % 256;
|
sb.append((char) (value / 16 + '0')).append((char) (value % 16 + '0'));
|
}
|
|
String result = sb.toString();
|
if (!result.matches("\\d*")) {
|
throw new Exception("解码BCD，但数据（" + result + "[startIndex=" + startIndex + ",length=" + length + "]）非BCD码！");
|
}
|
return result;
|
}
|
|
// public static void main(String[] args) throws Exception {
|
// // 帧头 + 帧长度 + 终端ID + 功能码 + 数据
|
// int len = 2 + 4 + 4 + 2 + (4 + 4);
|
//
|
// byte[] b = new byte[len];
|
// ByteUtil.int2Bytes(b, 1234567890, 0);
|
// int v1 = ByteUtil.bytes2Int(b, 0);
|
// System.out.println(v1);
|
//
|
// b = new byte[len];
|
// ByteUtil.short2Bytes(b, (short) -1234, 0);
|
// short v2 = ByteUtil.bytes2Short(b, 0);
|
// System.out.println(v2);
|
//
|
// b = new byte[len];
|
// ByteUtil.long2Bytes(b, 4638387438405602509L, 0);
|
// long v3 = ByteUtil.bytes2Long(b, 0);
|
// System.out.println(v3);
|
//
|
// b = new byte[len];
|
// ByteUtil.float2Bytes(b, (float) -123456.45, 0);
|
// float v4 = ByteUtil.bytes2Float(b, 0);
|
// System.out.println(v4);
|
//
|
// b = new byte[len];
|
// ByteUtil.double2Bytes(b, -256.1234567890123D, 0);
|
// double v5 = ByteUtil.bytes2Double(b, 0);
|
// System.out.println(v5);
|
//
|
// }
|
/*
|
public static void main(String[] args) throws Exception {
|
byte[] bs = new byte[]{0x38, 0x36, 0x39, 0x31} ;
|
String s = bytes2String_BE(bs, 0, 3) ;
|
System.out.println(s);
|
|
byte[] bss = new byte[]{(byte)0x8F} ;
|
int v = bss[0] ;
|
System.out.println(v);
|
if(v < 0){
|
v = 255 + v + 1 ;
|
}
|
System.out.println(v);
|
}
|
*/
|
|
}
|
