package com.dy.common.util;
|
|
public class ByteUtilUnsigned {
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* 无符号int类型转换成4位byte数组
|
* java没有无符号整型数据，只有有符号整数，取值范围是-2147483648~2147483647
|
* C有无符号整型数据，取值范围是0到4294967295，已经超出了java的有符号整数上限，所以只能用java的long型表示无符号整数
|
* @value bs byte[]
|
* @value value int int类型的参数
|
* @value from int
|
* @throws Exception 异常
|
*/
|
public static void int2Bytes_BE(byte[] bs, long value, int from)throws Exception {
|
int len = 4 ;
|
Long maxIntUnsigned = Long.valueOf(Integer.MAX_VALUE * 2 + 1) ;
|
Long minIntUnsigned = Long.valueOf(Integer.MIN_VALUE * 2) ;
|
if(value < minIntUnsigned || value > maxIntUnsigned ){
|
throw new Exception("数据" + value + "超出了无符号Int型的取值范围(" + minIntUnsigned + "~" + maxIntUnsigned + ")") ;
|
}
|
|
int temp ;
|
if(value > Integer.MAX_VALUE){
|
temp = (Long.valueOf(value - (Integer.MAX_VALUE * 2 + 1) - 1)).intValue() ;
|
}else{
|
temp = Long.valueOf(value).intValue() ;
|
}
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + len);
|
if (!b) {
|
for (int i = (len - 1); i >= 0; i--) {
|
bs[from + i] = Integer.valueOf(temp & 0xff).byteValue();//将最低位保存在高字节
|
temp = temp >> 8; // 向右移8位
|
}
|
} else {
|
throw new Exception("int2Bytes时数组越界");
|
}
|
}
|
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* 与方法int2Bytes算法一样，只是把顺序反过来
|
* @value bs byte[]
|
* @value value int int类型的参数
|
* @value from int
|
*/
|
public static void int2Bytes_LE(byte[] bs, long value, int from)throws Exception {
|
int len = 4 ;
|
Long maxIntUnsigned = Long.valueOf(Integer.MAX_VALUE) * 2 + 1;
|
Long minIntUnsigned = Long.valueOf(Integer.MIN_VALUE) * 2 ;
|
if(value < minIntUnsigned || value > maxIntUnsigned ){
|
throw new Exception("数据" + value + "超出了无符号Int型的取值范围(" + minIntUnsigned + "~" + maxIntUnsigned + ")") ;
|
}
|
|
int temp ;
|
if(value > Integer.MAX_VALUE){
|
temp = (Long.valueOf(value - (Integer.MAX_VALUE * 2 + 1) - 1)).intValue() ;
|
}else{
|
temp = Long.valueOf(value).intValue() ;
|
}
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + len);
|
if (!b) {
|
for (int i = 0; i <= len ; i++) {
|
bs[from + i] = Integer.valueOf(temp & 0xff).byteValue();// 将最低位保存在低字节
|
temp = temp >> 8; // 向右移8位
|
}
|
} else {
|
throw new Exception("int2Bytes时数组越界");
|
}
|
}
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* 4位字节数组转换为整型
|
* @param bs 字节数组
|
* @param from 起始位置
|
* @return 结果
|
*/
|
public static long bytes2Int_BE(byte[] bs, int from) throws Exception {
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + 4);
|
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 ;
|
|
// 最低位S3不变
|
s0 <<= 24;
|
s1 <<= 16;
|
s2 <<= 8;
|
s = s0 | s1 | s2 | s3;
|
if(s < 0){
|
//s = Integer.MAX_VALUE -s ;
|
s = Integer.MAX_VALUE * 2 + 1 + s + 1 ;
|
}
|
return s;
|
} else {
|
throw new Exception("byte2Int时数组越界");
|
}
|
}
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* 与方法bytes2Int算法一样，只是把顺序反过来
|
* @param bs 字节数组
|
* @param from 字节数组起始位置
|
* @return
|
*/
|
public static long bytes2Int_LE(byte[] bs, int from) throws Exception {
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + 4);
|
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 ;
|
|
// S0不变
|
s1 <<= 8;
|
s2 <<= 16;
|
s3 <<= 24;
|
s = s0 | s1 | s2 | s3;
|
if(s < 0){
|
//s = Integer.MAX_VALUE -s ;
|
s = Integer.MAX_VALUE * 2 + 1 + s + 1 ;
|
}
|
return s;
|
} else {
|
throw new Exception("byte2Int时数组越界");
|
}
|
}
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* 与方法bytes2Int算法一样，只是把顺序反过来
|
* @param bs 字节数组
|
* @param from 字节数组起始位置
|
* @param has3Byte 是否包含数据下标为3的字节，如果不包含实际处理的是3字节的整数
|
* @return
|
*/
|
public static long bytes2Int_LE(byte[] bs, int from, boolean has3Byte) throws Exception {
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + 4);
|
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 = 0L ;
|
if(!has3Byte){
|
s3 = bs[from + 3] & 0xFF ;
|
}
|
|
|
// S0不变
|
s1 <<= 8;
|
s2 <<= 16;
|
s3 <<= 24;
|
s = s0 | s1 | s2 | s3;
|
if(s < 0){
|
//s = Integer.MAX_VALUE -s ;
|
s = Integer.MAX_VALUE * 2 + 1 + s + 1 ;
|
}
|
return s;
|
} else {
|
throw new Exception("byte2Int时数组越界");
|
}
|
}
|
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* 与方法bytes2Int算法一样，只是把顺序反过来
|
* @param bs
|
* @return
|
*/
|
public static long bytes2Long_LE(byte[] bs, int startIndex, int endIndex) throws Exception {
|
boolean b = isOutOfArrLength(bs.length, endIndex);
|
if (!b) {
|
byte count = 0 ;
|
long s = 0;
|
long temp = 0 ;
|
for(int i = startIndex ; i <= endIndex; i++){
|
temp = bs[i] & 0xFF ;// 数据的最低位在低字节
|
if(temp < 0){
|
temp = Byte.MAX_VALUE * 2 + 1 + temp + 1 ;
|
}
|
if(count > 0){
|
temp <<= count * 8;
|
}
|
count++ ;
|
s = s | temp ;
|
}
|
return s;
|
} else {
|
throw new Exception("bytes2Long_LE时数组越界");
|
}
|
}
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* 无符号short类型转换成2位byte数组
|
* java没有无符号短整型数据，只有有符号短整数，取值范围是-32768~32767
|
* 若模拟无符号短整型数据，取值范围是0到65535 ，已经超出了java的有符号整数上限，所以只能用java的Int型表示无符号整数
|
* @value bs byte[]
|
*/
|
public static long bytes2Long_BE(byte[] bs, int startIndex, int endIndex) throws Exception {
|
boolean b = isOutOfArrLength(bs.length, endIndex);
|
if (!b) {
|
int count = endIndex - startIndex ;
|
long s = 0;
|
long temp = 0 ;
|
for(int i = startIndex ; i <= endIndex ; i++){
|
temp = bs[i] & 0xFF ;// 数据的最低位在低字节
|
if(temp < 0){
|
temp = Byte.MAX_VALUE * 2 + 1 + temp + 1 ;
|
}
|
if(count > 0){
|
temp <<= count * 8;
|
}
|
count-- ;
|
s = s | temp ;
|
}
|
return s;
|
} else {
|
throw new Exception("bytes2Long_LE时数组越界");
|
}
|
}
|
|
// public static long bytes2Int_BE(byte[] bs, int from) throws Exception {
|
// boolean b = isOutOfArrLength(bs.length, (from - 1) + 4);
|
// 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 ;
|
//
|
// // 最低位S3不变
|
// s0 <<= 24;
|
// s1 <<= 16;
|
// s2 <<= 8;
|
// s = s0 | s1 | s2 | s3;
|
// if(s < 0){
|
// //s = Integer.MAX_VALUE -s ;
|
// s = Integer.MAX_VALUE * 2 + 1 + s + 1 ;
|
// }
|
// return s;
|
// } else {
|
// throw new Exception("byte2Int时数组越界");
|
// }
|
// }
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* 无符号short类型转换成2位byte数组
|
* java没有无符号短整型数据，只有有符号短整数，取值范围是-32768~32767
|
* 若模拟无符号短整型数据，取值范围是0到65535 ，已经超出了java的有符号整数上限，所以只能用java的Int型表示无符号整数
|
* @value bs byte[]
|
* @value value int int类型的参数
|
* @value from int
|
*/
|
public static void short2Bytes_BE(byte[] bs, int value, int from)throws Exception {
|
int maxShortUnsigned = Integer.valueOf(Short.MAX_VALUE) * 2 + 1;
|
int minShortUnsigned = Integer.valueOf(Short.MIN_VALUE) * 2 ;
|
if(value < minShortUnsigned || value > maxShortUnsigned ){
|
throw new Exception("数据" + value + "超出了无符号short型的取值范围(" + minShortUnsigned + "~" + maxShortUnsigned + ")") ;
|
}
|
short temp = 0 ;
|
if(value > Short.MAX_VALUE){
|
temp = (Integer.valueOf(value - (Short.MAX_VALUE * 2 + 1) - 1)).shortValue() ;//(Integer.valueOf(Short.MAX_VALUE - value)).shortValue() ;
|
}else{
|
temp = Integer.valueOf(value).shortValue() ;
|
}
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + 2);
|
if (!b) {
|
for (int i = 1; i >= 0; i--) {
|
bs[from + i] = Integer.valueOf(temp & 0xff).byteValue();//将最低位保存在高字节
|
temp = (short)(temp >> 8); // 向右移8位
|
}
|
} else {
|
throw new Exception("short2Bytes时数组越界");
|
}
|
}
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* 与方法short2Bytes算法一样，只是把顺序反过来
|
* @value bs byte[]
|
* @value value int int类型的参数
|
* @value from int
|
*/
|
public static void short2Bytes_LE(byte[] bs, int value, int from)throws Exception {
|
int len = 2 ;
|
int maxShortUnsigned = Integer.valueOf(Short.MAX_VALUE) * 2 + 1;
|
int minShortUnsigned = Integer.valueOf(Short.MIN_VALUE) * 2 ;
|
if(value < minShortUnsigned || value > maxShortUnsigned ){
|
throw new Exception("数据" + value + "超出了无符号short型的取值范围(" + minShortUnsigned + "~" + maxShortUnsigned + ")") ;
|
}
|
short temp = 0 ;
|
if(value > Short.MAX_VALUE){
|
temp = (Integer.valueOf(value - (Short.MAX_VALUE * 2 + 1) - 1)).shortValue() ;//(Integer.valueOf(Short.MAX_VALUE - value)).shortValue() ;
|
}else{
|
temp = Integer.valueOf(value).shortValue() ;
|
}
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + len);
|
if (!b) {
|
for (int i = 0; i < len; i++) {
|
bs[from + i] = Integer.valueOf(temp & 0xff).byteValue();//将数据低位保存在数据低字节
|
temp = (short)(temp >> 8); // 向右移8位
|
}
|
} else {
|
throw new Exception("short2Bytes时数组越界");
|
}
|
}
|
|
/**
|
* 大端模式《数据低位在数组高字节》
|
* 2位字节数组转换为短整型
|
* @param bs 字节数组
|
* @param from 字节数组起始位置
|
* @return 结果
|
*/
|
public static int bytes2Short_BE(byte[] bs, int from) throws Exception {
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + 2);
|
if (!b) {
|
int s = 0;
|
int s0 = Integer.valueOf(bs[from + 0] & 0xff).shortValue();// 最低位
|
int s1 = Integer.valueOf(bs[from + 1] & 0xff).shortValue();
|
|
// 最低位S1不变
|
s0 <<= 8;
|
s = s0 | s1 ;
|
if(s < 0){
|
s = (Short.MAX_VALUE * 2 + 1) + s + 1;
|
}
|
return s;
|
} else {
|
throw new Exception("bytes2Short时数组越界");
|
}
|
}
|
|
/**
|
* 小端模式《数据低位在数组低字节》
|
* 与方法bytes2Short算法一样，只是把顺序反过来
|
* @param bs 字节数组
|
* @param from 字节数组起始位置
|
* @return 结果
|
*/
|
public static int bytes2Short_LE(byte[] bs, int from) throws Exception {
|
boolean b = isOutOfArrLength(bs.length, (from - 1) + 2);
|
if (!b) {
|
int s = 0;
|
int s0 = Integer.valueOf(bs[from + 0] & 0xff).shortValue();// 小下标字节转数据低位
|
int s1 = Integer.valueOf(bs[from + 1] & 0xff).shortValue();// 大下标字节转数据高位
|
|
// 最低位S0不变
|
s1 <<= 8;
|
s = s1 | s0 ;
|
if(s < 0){
|
s = (Short.MAX_VALUE * 2 + 1) + s + 1;
|
}
|
return s;
|
} else {
|
throw new Exception("bytes2Short时数组越界");
|
}
|
}
|
|
|
/**
|
* 1位字节数组转换为短整型
|
* @param bs 字节数组
|
* @param index 字节数组起始位置
|
* @return 结果
|
*/
|
public static short byte2Byte(byte[] bs, int index) throws Exception {
|
if (bs.length - 1 < index) {
|
throw new Exception("byte2Short(byte[] bs, int index)时数组越界");
|
} else {
|
byte bv = (byte)(bs[index] & 0xff) ;
|
short s = 0 ;
|
if(bv < 0){
|
s = (short)(Byte.MAX_VALUE * 2 + 1 + bv + 1) ;
|
}else{
|
s = bv ;
|
}
|
return s ;
|
}
|
}
|
/**
|
* 无符号short类型转换成1位byte
|
* java没有无符号短整型数据，只有有符号短整数，取值范围是-128~127
|
* 若模拟无符号短整型数据，取值范围是0到255 ，已经超出了java的有符号整数上限，所以只能用java的short型表示无符号整数
|
* @value bs byte[] 字节数组
|
* @value value short short类型的参数
|
* @value index 起始位置
|
*/
|
public static void byte2Byte(byte[] bs, short value, int index)throws Exception {
|
int maxShortUnsigned = Integer.valueOf(Byte.MAX_VALUE) * 2 + 1;
|
int minShortUnsigned = Integer.valueOf(Byte.MIN_VALUE) * 2 ;
|
if(value < minShortUnsigned || value > maxShortUnsigned ){
|
throw new Exception("数据" + value + "超出了无符号byte型的取值范围(" + minShortUnsigned + "~" + maxShortUnsigned + ")") ;
|
}
|
if (bs.length - 1 < index) {
|
throw new Exception("byte2Byte(byte[] bs, short value, int index)时数组越界");
|
} else {
|
bs[index] = Integer.valueOf(value & 0xff).byteValue() ;
|
}
|
}
|
|
/**
|
* 判断所有字节是否为0xFF
|
* @param bs 字节数组
|
* @param index 起始位置
|
* @param len 长度
|
* @return 结果
|
* @throws Exception
|
*/
|
public static boolean bytesIsAll0xFF(byte[] bs, int index, int len)throws Exception {
|
int count = 0 ;
|
for(int i = index; i < index + len; i++){
|
if(bs[i] == (byte)0xFF){
|
count++ ;
|
}
|
}
|
return count==len?true:false ;
|
}
|
|
/**
|
* 判断数组下标是否越界
|
*
|
* @value bsLength 数组总长度
|
* @value toSite 数组偏移量
|
* @return 结果
|
*/
|
private static boolean isOutOfArrLength(int bsLength, int toSite) {
|
if (bsLength > toSite) {
|
return false;
|
} else {
|
return true;
|
}
|
}
|
public static void main(String[] args) throws Exception{
|
byte[] bs = new byte[]{(byte)0x38,(byte)0x1d,(byte)0x00,(byte)0x00,(byte)0x00} ;
|
Long lg1 = ByteUtilUnsigned.bytes2Long_LE(bs, 0, 4) ;
|
Long lg2 = ByteUtilUnsigned.bytes2Long_BE(bs, 0, 4) ;
|
System.out.println(lg1);
|
System.out.println(lg2);
|
}
|
|
// public static void main(String[] args) throws Exception{
|
//// int d = 123456;
|
//// byte[] bs = new byte[4] ;
|
//// int2Bytes_BE(bs, d, 0) ;
|
//// System.out.println(ByteUtil.bytes2Hex(bs, false));
|
//// long dd = bytes2Int_BE(bs, 0) ;
|
//// System.out.println(dd);
|
////
|
//// byte[] bb = new byte[1] ;
|
//// bb[0] = (byte)255 ;
|
//// short s = byte2Byte(bb, 0);
|
//// System.out.println(s);
|
//
|
// byte[] bs = new byte[]{(byte)0x00, (byte)0x00, (byte)0x3A, (byte)0x88} ;
|
// //byte[] bs = new byte[]{(byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff} ;
|
// boolean flag = ByteUtilUnsigned.bytesIsAll0xFF(bs, 0, 4) ;
|
// System.out.println(flag);
|
// Long s = ByteUtilUnsigned.bytes2Int_BE(bs, 0);
|
// System.out.println(s);
|
//
|
//
|
// }
|
}
|
