整理版本

zhubaomin

2025-04-07 1a2b07f01ba4616fd9e894dddf474b56d020158c

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/util/ByteUtilUnsigned.java

New file
@@ -0,0 +1,474 @@
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{
      byte[] bs = new byte[]{0x02, 0x0C} ;
      int s = ByteUtilUnsigned.bytes2Short_BE(bs, 0) ;
      System.out.println(s);
////      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);
//
//
   }
}