整理版本

zhubaomin

2025-04-07 1a2b07f01ba4616fd9e894dddf474b56d020158c

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

@@ -4,12 +4,55 @@


public class ByteUtil {
	

   /**
    * 将字节数组分割
    * @param bytes 被分割数组
    * @param fromIndex 分割起始位置
    * @param len 分割长度
    * @return 返回 分割出来的数组
    */
   public static byte[] bytesSplit(byte[] bytes, int fromIndex, int len){
      if(bytes == null){
         return null ;
      }else{
         byte[] bs = new byte[len] ;
         if(fromIndex + len > bytes.length){
            System.arraycopy(bytes, fromIndex, bs, 0, bytes.length - fromIndex) ;
         }else{
            System.arraycopy(bytes, fromIndex, bs, 0, len) ;
         }
         return bs ;
      }
   }
   /**
    * 将字节数组分割
    * @param bytes 被分割数组
    * @param fromIndex 分割起始位置
    * @param len 分割长度
    * @return 返回 分割出来的数组
    */
   public static Object[] bytesSplit_(byte[] bytes, int fromIndex, int len){
      if(bytes == null){
         return null ;
      }else{
         int realLen = len ;
         byte[] bs = new byte[len] ;
         if(fromIndex + len > bytes.length){
            System.arraycopy(bytes, fromIndex, bs, 0, bytes.length - fromIndex) ;
            realLen = bytes.length - fromIndex ;
         }else{
            System.arraycopy(bytes, fromIndex, bs, 0, len) ;
         }
         return new Object[]{bs, realLen} ;
      }
   }

   /**
    * 将字节数组合并到字节数组上
    * @param bGroup1 被合并数组
    * @param bGroup2 合并数组
    * @return 合并后数组
    * @return 返回 合并后数组
    */
   public static byte[] bytesMerge(byte[] bGroup1, byte[] bGroup2){
      if(bGroup1 == null && bGroup2 == null){
@@ -29,71 +72,47 @@

   /**
    * 判断所有字节是否为0xFF
    * @param bs
    * @param index
    * @param len
    * @return
    * @throws Exception
    * @param bs 字节数组
    * @param index 下标位
    * @param len 长度
    * @return 返回 返回
    */
   public static boolean bytesIsAll0xFF(byte[] bs, int index, int len)throws Exception {
   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?true:false ;
      return count == len;
   }
	

   /**
    * 二进制转十进制数
    * @param str
    * @return
    * @throws Exception
    * @param str 二进制字符串
    * @return 返回
    */
   public static int binary2Int(String str) throws Exception {
        int cnt=0;
        int sum=0;
        str=new StringBuilder(str).reverse().toString();//反转字符串
        for(int i=0;i<str.length();i++){
            cnt++;
            if (str.charAt(i)=='1'){
                int mul=1;
                for (int j=1;j<cnt;j++){
                    mul*=2;
                }
                sum+=mul;
            }
            else continue;
        }
        return sum;
   public static int binary2Int(String str) {
      return Integer.parseInt(str, 2);
    }

	

   /**
    * 字节转存二进制
    * 
    *
    * @param b byte
    * @throws Exception
    * @return String
    * @return 返回 String
    */
   public static String byte2Binary(byte b) throws Exception {
      int n = (b + 256) % 256 + 256;
      try {
         return Integer.toBinaryString(n).substring(1);
      } catch (Exception e) {
         throw new Exception("字节转换成二进制的字符串出错！", null);
      }
   public static String byte2Binary(byte b) {
      return Integer.toBinaryString(b & 0xFF) ;
   }
   /**
    * 字节转存8位二进制
    * 
    * @param b
    *            byte
    * @throws Exception
    * @return String
    *
    * @param b  byte
    * @return 返回 String
    */
   public static String byte2bit8Binary(byte b) throws Exception {
   public static String byte2bit8Binary(byte b) {
      String s = byte2Binary(b);
      int len = s.length();
      for (int i = 0; i < 8 - len; i++) {
@@ -101,15 +120,13 @@
      }
      return s;
   }
	

   /**
    * 字节取bit
    * @param b
    * @param index
    * @throws Exception
    * @return String
    * 字节数 取出8个bit
    * @param b 字节数
    * @return 返回 String
    */
   public static byte[] getBit(byte b) throws Exception {
   public static byte[] getBit(byte b) {
      byte[] bs = new byte[8] ;
      bs[0] = (byte)(b & 1) ;
      bs[1] = (byte)((b & 2) >> 1) ;
@@ -123,11 +140,11 @@
   }

   /**
    * 字节取bit
    * @param b
    * @param index
    * @throws Exception
    * @return String
    * 字节数 取出bit
    * @param b 字节数
    * @param index 下标位
    * @throws Exception 异常
    * @return 返回 String
    */
   public static byte getBit(byte b, byte index) throws Exception {
      if(index == 0){
@@ -153,11 +170,11 @@

   /**
    * 一个字节转正整数
    * 
    *
    * @param b
    *            byte
    * @throws Exception
    * @return String
    * @throws Exception 异常
    * @return 返回 String
    */
   public static Short byte2PlusInt(byte b) throws Exception {
      short v = b ;
@@ -167,19 +184,18 @@
      return v ;
   }

	

   /**
    * 大端模式《数据低位在数组高字节》
    * double转换byte
    * @param bs byte[]
    * @param bs 字节数组 byte[]
    * @param value double double类型的参数
    * @param from int
    * @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) {
         Long l = Double.doubleToLongBits(value);
         long2Bytes_BE(bs, l, from);
         long2Bytes_BE(bs, Double.doubleToLongBits(value), from);
      } else {
         throw new Exception("double2Bytes时数组越界");
      }
@@ -188,15 +204,14 @@
   /**
    * 小端模式《数据低位在数组低字节》
    * double转换byte，字节顺序是倒的
    * @param bs byte[]
    * @param bs 字节数组 byte[]
    * @param value double double类型的参数
    * @param from int
    * @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) {
         Long l = Double.doubleToLongBits(value);
         long2Bytes_LE(bs, l, from);
         long2Bytes_LE(bs, Double.doubleToLongBits(value), from);
      } else {
         throw new Exception("double2Bytes时数组越界");
      }
@@ -205,8 +220,8 @@
   /**
    * 大端模式《数据低位在数组高字节》
    * byte转换double
    * @param bs byte[]
    * @param from int
    * @param bs 字节数组 byte[]
    * @param from 开始位 int
    */
   public static double bytes2Double_BE(byte[] bs, int from) throws Exception {
      long l = bytes2Long_BE(bs, from);
@@ -216,8 +231,8 @@
   /**
    * 小端模式《数据低位在数组低字节》
    * byte转换double，字节顺序是倒的
    * @param bs byte[]
    * @param from int
    * @param bs 字节数组 byte[]
    * @param from 开始位 int
    */
   public static double bytes2Double_LE(byte[] bs, int from) throws Exception {
      long l = bytes2Long_LE(bs, from);
@@ -306,7 +321,7 @@

   /**
    * 小端模式《数据低位在数组低字节》
    * 转换long型为byte数组 
    * 转换long型为byte数组
    * @value bs byte[]
    * @value value long
    * @value from int
@@ -315,8 +330,8 @@
      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;  
            bs[from + i] = Long.valueOf(value & 0xff).byteValue();
            value = value >> 8;
         if(value == 0){
            break ;
         }
@@ -325,12 +340,12 @@
         throw new Exception("long2Bytes时数组越界");
      }
   }
	

   /**
    * 大端模式《数据低位在数组高字节》
    * 8位字节数组转换为长整型
    * @param bs byte[]
    * @return
    * @param bs 字节数组 byte[]
    * @return 返回
    */
   public static long bytes2Long_BE(byte[] bs) {
      int len = bs.length ;
@@ -338,7 +353,7 @@
         long l = 0;
         long[] ls = new long[len] ;
         for(int i = 0 ; i < len; i++){
            ls[i] = bs[i] ;
            ls[i] = bs[i] & 0xFF ;
         }
         for(int i = len-1 ; i >= 0; i--){
            ls[(len - 1) - i] <<= 8 * i ;
@@ -347,29 +362,29 @@
            l = l | ls[i] ;
         }
         return l;
      } 
      }
      return 0L ;
   }
		

   /**
    * 大端模式《数据低位在数组高字节》
    * 8位字节数组转换为长整型
    * @param bs byte[]
    * @param from int
    * @return
    * @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] ;// 最低位
         long s1 = bs[from + 1] ;
         long s2 = bs[from + 2] ;
         long s3 = bs[from + 3] ;
         long s4 = bs[from + 4] ;
         long s5 = bs[from + 5] ;
         long s6 = bs[from + 6] ;
         long s7 = bs[from + 7] ;
         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;
@@ -388,10 +403,10 @@
   /**
    * 大端模式《数据低位在数组高字节》
    * 8位字节数组转换为长整型
    * @param bs byte[]
    * @param from int
    * @param bs 字节数组 byte[]
    * @param from 开始位 int
    * @param end int
    * @return
    * @return 返回
    */
   public static long bytes2Long_BE(byte[] bs, int from, int end) throws Exception {
      boolean b = isOutOfArrLength(bs.length, end);
@@ -399,7 +414,7 @@
         short len = (short)(end - from + 1) ;
         long[] ls = new long[len] ;
         for(short i = 0 ; i < len; i++){
            ls[i] = bs[from + i] ;
            ls[i] = bs[from + i] & 0xFF ;
         }
         for(short i = (short)(len-1) ; i >= 0; i--){
            ls[i] <<= 8 * (len - (i + 1)) ;
@@ -414,13 +429,13 @@
      }
   }

	
	


   /**
    * 小端模式《数据低位在数组低字节》
    * 8位字节数组转换为长整型
    * @param bs byte[]
    * @return
    * @param bs 字节数组 byte[]
    * @return 返回
    */
   public static long bytes2Long_LE(byte[] bs) {
      int len = bs.length ;
@@ -428,7 +443,7 @@
         long l = 0;
         long[] ls = new long[len] ;
         for(int i = 0 ; i < len; i++){
            ls[i] = bs[i] ;
            ls[i] = bs[i] & 0xFF ;
         }
         for(int i = 0 ; i < len; i++){
            ls[(len - 1) - i] <<= 8 * i ;
@@ -437,29 +452,29 @@
            l = l | ls[i] ;
         }
         return l;
      } 
      }
      return 0L ;
   }

   /**
    * 小端模式《数据低位在数组低字节》
    * 8位字节数组转换为长整型 
    * @param bs byte[]
    * @param from int
    * @return
    * 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 + 0] ;// 最低位
         long s1 = bs[from + 1] ;
         long s2 = bs[from + 2] ;
         long s3 = bs[from + 3] ;
         long s4 = bs[from + 4] ;
         long s5 = bs[from + 5] ;
         long s6 = bs[from + 6] ;
         long s7 = bs[from + 7] ;
         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;
@@ -479,10 +494,10 @@
   /**
    * 小端模式《数据低位在数组低字节》
    * 8位字节数组转换为长整型
    * @param bs byte[]
    * @param from int
    * @param bs 字节数组 byte[]
    * @param from 开始位 int
    * @param end int
    * @return
    * @return 返回
    */
   public static long bytes2Long_LE(byte[] bs, int from, int end) throws Exception {
      boolean b = isOutOfArrLength(bs.length, end);
@@ -490,7 +505,7 @@
         short len = (short)(end - from + 1) ;
         long[] ls = new long[len] ;
         for(short i = 0 ; i < len; i++){
            ls[i] = bs[from + i] ;
            ls[i] = bs[from + i] & 0xFF ;
         }
         for(short i = 0 ; i < len; i++){
            ls[i] <<= 8 * i ;
@@ -539,9 +554,9 @@
         for (int i = 0; i < 4; i++) {
            bs[from + i] = Integer.valueOf(value & 0xff).byteValue();// 将最低位保存在低字节
            value = value >> 8; // 向右移8位
         if(value == 0){
            break ;
         }
            if(value == 0){
               break ;
            }
         }
      } else {
         throw new Exception("int2Bytes时数组越界");
@@ -551,17 +566,18 @@
   /**
    * 大端模式《数据低位在数组高字节》
    * 4位字节数组转换为整型
    * @param b
    * @return
    * @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] ;// 最低位
         int s1 = bs[from + 1] ;
         int s2 = bs[from + 2] ;
         int s3 = bs[from + 3] ;
         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;
@@ -573,22 +589,22 @@
         throw new Exception("byte2Int时数组越界");
      }
   }
	


   /**
    * 小端模式《数据低位在数组低字节》
    * 4位字节数组转换为整型，字节顺序是倒的
    * @param b
    * @return
    * @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] ;// 最低位
         int s1 = bs[from + 1] ;
         int s2 = bs[from + 2] ;
         int s3 = bs[from + 3] ;
         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;
@@ -600,7 +616,7 @@
         throw new Exception("byte2Int时数组越界");
      }
   }
	


   /**
    * 大端模式《数据低位在数组高字节》
@@ -674,21 +690,20 @@
   /**
    * 大端模式《数据低位在数组高字节》
    * 2位字节数组转换为短整型
    * @param b
    * @return
    * @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] ; 
         int s1 = bs[from + 1] ;
         int s0 = bs[from + 0] & 0xFF ;
         int s1 = bs[from + 1] & 0xFF ;

         // s1不变
         s0 <<= 8;
         s = s0 | s1;
         return (short) s;

         return (short)s ;
      } else {
         throw new Exception("byte2Short时数组越界");
      }
@@ -697,15 +712,15 @@
   /**
    * 小端模式《数据低位在数组低字节》
    * 2位字节数组转换为短整型，字节顺序是倒的
    * @param b
    * @return
    * @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] ; 
         int s1 = bs[from + 1] ;
         int s0 = bs[from + 0] & 0xFF ;
         int s1 = bs[from + 1] & 0xFF ;

         // s0不变
         s1 <<= 8;
@@ -718,11 +733,11 @@
   }
   /**
    * 字符到一字节转换
    * 
    *
    * @value bs byte[]
    * @value ch char char类型的参数
    * @value index int
    * @return
    * @return 返回
    */
   public static void char2Bytes(byte[] bs, char ch, int index)throws Exception {
      boolean b = isOutOfArrLength(bs.length, index);
@@ -735,10 +750,9 @@

   /**
    * 一字节转换为字符
    * 
    * @param b
    * @param bs 字节数组 字节数组
    * @value index int
    * @return
    * @return 返回
    */
   public static char bytes2Char(byte[] bs, int index) throws Exception {
      boolean b = isOutOfArrLength(bs.length, index);
@@ -751,13 +765,13 @@

   /**
    * 字符串型数字转成byte
    * 
    *
    * @param s
    * @return
    * @throws Exception
    * @return 返回
    * @throws Exception 异常
    */
   public static byte string2byte(String s) throws Exception {
      int n = 0;
      int n ;
      try {
         n = Integer.parseInt(s);
      } catch (Exception e) {
@@ -772,7 +786,7 @@
    * @value bs byte[]
    * @value str String
    * @value from int
    * @return
    * @return 返回
    * @throws java.io.UnsupportedEncodingException
    */
   public static int string2Bytes_BE(byte[] bs, String str, int from, int end)throws Exception {
@@ -798,7 +812,7 @@
    * @value bs byte[]
    * @value str String
    * @value from int
    * @return
    * @return 返回
    * @throws java.io.UnsupportedEncodingException
    */
   public static int string2Bytes_LE(byte[] bs, String str, int from, int end)throws Exception {
@@ -824,7 +838,7 @@
    * @value bs byte[]
    * @value str String
    * @value from int
    * @return
    * @return 返回
    * @throws java.io.UnsupportedEncodingException
    */
   public static int string2Bytes_BE(byte[] bs, String str, int from)throws Exception {
@@ -846,7 +860,7 @@
    * @value bs byte[]
    * @value str String
    * @value from int
    * @return
    * @return 返回
    * @throws java.io.UnsupportedEncodingException
    */
   public static int string2Bytes_LE(byte[] bs, String str, int from)throws Exception {
@@ -898,10 +912,10 @@

   /**
    * 判断数组下标是否越界
    * 
    *
    * @value bsLength 数组总长度
    * @value toSite 数组偏移量
    * @return
    * @return 返回
    */
   private static boolean isOutOfArrLength(int bsLength, int toSite) {
      if (bsLength > toSite) {
@@ -911,158 +925,197 @@
      }
   }

	

   /**
    * 字节数组转换成十六进制的字符串 
    * 
    * @param b byte[]
    * 字节数组转换成十六进制的字符串
    *
    * @param src byte[]
    * @param hasBlank 16进制是否用空格分隔
    * @return String
    * @return 返回 String
    */
   public static String bytes2Hex(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);
   }  
   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 b byte[]
    * 字节数组转换成十六进制的字符串
    *
    * @param bs byte[]
    * @param hasBlank 16进制是否用空格分隔
    * @param from  
    * @param len 
    * @return String
    * @param from 开始位
    * @param len 长度
    * @return 返回 String
    */
   public static String bytes2Hex(byte[] src, boolean hasBlank, int from, int len){  
       if (src == null || src.length <= 0 || src.length < from + len) {  
           return null;  
       }  
   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] = src[from + 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 hexString 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 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 hexString 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]));  
    * @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);
       return fromIndex ;
   }

   /**
    * 将16进制字符串转换为byte[]
    *
    * @param str 待转换字符串
    * @return 转换后的byte[]
    * 十六进制转字节数组
    * @param hex the hex string
    * @return 返回 byte[]
    */
   public static byte[] hexToBytes(String str) {
      if (str == null || "".equals(str.trim())) {
         return new byte[0];
   public static int hex2Bytes_LE(String hex, byte[] bs, int fromIndex) {
      if (hex == null || hex.equals("")) {
         return fromIndex;
      }

      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);
      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 bytes;
      for(int i = 0 ; i < d.length; i++){
         bs[fromIndex++] = d[(d.length - 1) - i] ;
      }
      return fromIndex ;
   }


   /**
    * Convert char to byte
    * @param c char
    * @return byte
    * @return 返回 byte
    */
   private static byte charToByte(char c) {
      return (byte) "0123456789ABCDEF".indexOf(c);
   }	 
	 
   }


   /**
    * 大端模式《数据低位在数组高字节》
    * 整形转成BCD编码
    * @param l
    * @return
    * @param i
    * @return 返回
    */
   public static byte[] int2BCD_BE(int i)throws Exception {
      String str = "" + i;
@@ -1079,8 +1132,8 @@
   /**
    * 小端模式《数据低位在数组低字节》
    * 整形转成BCD编码，字节顺序是倒的
    * @param l
    * @return
    * @param i
    * @return 返回
    */
   public static byte[] int2BCD_LE(int i)throws Exception {
      String str = "" + i;
@@ -1096,10 +1149,35 @@
   }

   /**
    * 小端模式《数据低位在数组低字节》
    * 整形转成BCD编码，字节顺序是倒的
    * @param i
    * @param bs
    * @param from
    * @return 返回
    */
   public static void int2BCD_LE(int i, byte[] bs, int from)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);

      int len = bs.length ;
      int bLen = b.length ;
      for(int j = 0; (j < len && j < bLen); j++){
         bs[from + j] = b[j] ;
      }
   }

   /**
    * 大端模式《数据低位在数组高字节》
    * 长整形转成BCD编码
    * @param l
    * @return
    * @return 返回
    */
   public static byte[] long2BCD_BE(long l)throws Exception {
      String str = "" + l;
@@ -1118,7 +1196,7 @@
    * 小端模式《数据低位在数组低字节》
    * 长整形转成BCD编码，字节顺序是倒的
    * @param l
    * @return
    * @return 返回
    */
   public static byte[] long2BCD_LE(long l) throws Exception {
      String str = "" + l;
@@ -1137,30 +1215,30 @@
    * 大端模式《数据低位在数组高字节》
    * 字符串型数字转成BCD编码
    * @param s
    * @return
    * @throws Exception
    * @return 返回
    * @throws Exception 异常
    */
   public static byte[] string2BCD_BE(String s) throws Exception {
      byte[] b = null;
      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 java.io.Exception
    * @return 返回
    * @throws Exception 异常 异常
    */
   public static int string2BCD_BE(byte[] bs, String str, int fromIndex)throws Exception {
      byte[] bb = string2BCD_BE(str);
@@ -1179,8 +1257,8 @@
    * 小端模式《数据低位在数组低字节》
    * 字符串型数字转成BCD编码，字节顺序是倒的
    * @param s
    * @return
    * @throws Exception
    * @return 返回
    * @throws Exception 异常
    */
   public static byte[] string2BCD_LE(String s) throws Exception {
      byte[] b = null;
@@ -1193,15 +1271,15 @@

      return b;
   }
	

   /**
    * 大端模式《数据低位在数组高字节》
    * 小端模式《数据低位在数组高字节》
    * 字符串转换成byte数组
    * @value bs byte[]
    * @value str String
    * @value fromIndex int
    * @return
    * @throws java.io.Exception
    * @return 返回
    * @throws Exception 异常 异常
    */
   public static int string2BCD_LE(byte[] bs, String str, int fromIndex)throws Exception {
      byte[] bb = string2BCD_LE(str);
@@ -1221,10 +1299,8 @@
    * 大端模式《数据低位在数组高字节》
    * BCD编码转成整型
    * @param b
    * @param startIndex
    * @param endIndex
    * @return
    * @throws Exception
    * @return 返回
    * @throws Exception 异常
    */
   public static int BCD2Int_BE(byte b) throws Exception {
      String str = "";
@@ -1237,10 +1313,8 @@
    * 小端模式《数据低位在数组低字节》
    * BCD编码转成整型，字节顺序是倒的
    * @param b
    * @param startIndex
    * @param endIndex
    * @return
    * @throws Exception
    * @return 返回
    * @throws Exception 异常
    */
   public static int BCD2Int_LE(byte b) throws Exception {
      String str = "";
@@ -1255,8 +1329,8 @@
    * @param b
    * @param startIndex
    * @param endIndex
    * @return
    * @throws Exception
    * @return 返回
    * @throws Exception 异常
    */
   public static int BCD2Int_BE(byte[] b, int startIndex, int endIndex)throws Exception {
      String str = "";
@@ -1271,8 +1345,8 @@
    * @param b
    * @param startIndex
    * @param endIndex
    * @return
    * @throws Exception
    * @return 返回
    * @throws Exception 异常
    */
   public static int BCD2Int_LE(byte[] b, int startIndex, int endIndex)throws Exception {
      String str = "";
@@ -1287,8 +1361,8 @@
    * @param b
    * @param startIndex
    * @param endIndex
    * @return
    * @throws Exception
    * @return 返回
    * @throws Exception 异常
    */
   public static long BCD2Long_BE(byte[] b, int startIndex, int endIndex)throws Exception {
      String str = "";
@@ -1304,14 +1378,13 @@
    * @param b
    * @param startIndex
    * @param endIndex
    * @return
    * @throws Exception
    * @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);
      long n = Long.parseLong(str);
      return n;
        return Long.parseLong(str);
   }

   /**
@@ -1320,8 +1393,8 @@
    * @param b
    * @param startIndex
    * @param endIndex
    * @return
    * @throws Exception
    * @return 返回
    * @throws Exception 异常
    */
   public static String BCD2String_BE(byte[] b, int startIndex, int endIndex) throws Exception {
      return decodeBCD_BE(b, startIndex, endIndex - startIndex + 1);
@@ -1333,8 +1406,8 @@
    * @param b
    * @param startIndex
    * @param endIndex
    * @return
    * @throws Exception
    * @return 返回
    * @throws Exception 异常
    */
   public static String BCD2String_LE(byte[] b, int startIndex, int endIndex) throws Exception {
      return decodeBCD_LE(b, startIndex, endIndex - startIndex + 1);
@@ -1342,17 +1415,17 @@

   /**
    * 大端模式《数据低位在数组高字节》
    * 编码BCD，例如1387编码成  13  87，顺序是正的 
    * 编码BCD，例如1387编码成  13  87，顺序是正的
    * @param value
    * @param dest
    * @param startIndex
    * @param length
    * @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--) {
@@ -1362,20 +1435,20 @@
         dest[i] = (byte) (tmpInts[2 * j] * 16 + tmpInts[2 * j + 1]);
      }
   }
	

   /**
    * 小端模式《数据低位在数组低字节》
    * 编码BCD，例如1387编码成  87  13，顺序是倒的 
    * 编码BCD，例如1387编码成  87  13，顺序是倒的
    * @param value
    * @param dest
    * @param startIndex
    * @param length
    * @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--) {
@@ -1393,8 +1466,8 @@
    * 解码BCD，顺序是正的
    * @param src
    * @param startIndex
    * @param length
    * @return
    * @param length 长度
    * @return 返回
    */
   private static String decodeBCD_BE(byte[] src, int startIndex, int length)throws Exception {
      StringBuilder sb = new StringBuilder();
@@ -1415,8 +1488,8 @@
     * 编码BCD，顺序是倒的
    * @param src
    * @param startIndex
    * @param length
    * @return
    * @param length 长度
    * @return 返回
    */
   private static String decodeBCD_LE(byte[] src, int startIndex, int length)throws Exception {
      StringBuilder sb = new StringBuilder();
@@ -1462,6 +1535,7 @@
//      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) ;
@@ -1475,5 +1549,6 @@
      }
      System.out.println(v);
   }
	
   */

}