content: /*
   * Copyright  2017 [AllenCoder]
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package com.allen.apputils;
   
  import java.io.ByteArrayOutputStream;
  import java.io.InputStream;
  
  /**
   * 数据转换工具类
   * @author AllenCoder
   * */
  public class DataUtil {
  
      /**
       * The high digits lookup table.
       */
      private static final byte[] highDigits;
  
      /**
       * The low digits lookup table.
       */
      private static final byte[] lowDigits;
  
      /**
       * Initialize lookup tables.
       */
      static {
          final byte[] digits = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
  
          int i;
          byte[] high = new byte[256];
          byte[] low = new byte[256];
  
          for (i = 0; i < 256; i++) {
              high[i] = digits[i >>> 4];
              low[i] = digits[i & 0x0F];
          }
  
          highDigits = high;
          lowDigits = low;
      }
      public static String getHexdump(int data, int lengthLimit) {
          if (lengthLimit == 0) {
              throw new IllegalArgumentException("lengthLimit: " + lengthLimit + " (expected: 1+)");
          }
  
          int size;
          size = lengthLimit;
  
          if (size == 0) {
              return "empty";
          }
  
          StringBuilder out = new StringBuilder(size * 3 + 3);
  
  
          // fill the first
          int byteValue = data& 0xFF;
          out.append((char) highDigits[byteValue]);
          out.append((char) lowDigits[byteValue]);
          size--;
  
          // and the others, too
          for (; size > 0; size--) {
              out.append(' ');
              byteValue = data & 0xFF;
              out.append((char) highDigits[byteValue]);
              out.append((char) lowDigits[byteValue]);
          }
  
  
  
          return out.toString();
      }
   
      /**
       * 十六进制 2 字符串
       * @param b
       * @return
       */
      public static String toHex(byte b) {
          return ("" + "0123456789ABCDEF".charAt(0xf & b >>  4) + "0123456789ABCDEF".charAt(b & 0xf)); 
      }
      /**
       * 字符串   to 字节数组
       * */
      public static byte[] getHexBytes(String message) {
          int len = message.length() /  2;
          char[] chars = message.toCharArray();
          String[] hexStr = new String[len];
          byte[] bytes = new byte[len];
          for (int i =  0, j =  0; j < len; i +=  2, j++) {
              hexStr[j] = "" + chars[i] + chars[i +  1];
              bytes[j] = (byte) Integer.parseInt(hexStr[j], 16);
          }
          return bytes;
      }
      public static byte[] hexStringToBytes(String hexString) {
           if (hexString == null || hexString.equals("")) {   
                  return null;   
           }   
           hexString = hexString.toUpperCase();   
           int length = hexString.length() /  2;   
           char[] hexChars = hexString.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;   
        }  
   
       private static byte charToByte(char c) {   
          return (byte) "0123456789ABCDEF".indexOf(c);   
       }  
   
       
   
      /**
       * 从输入流以字节形式读取数据
       * @param inStream
       * @return
       * @throws Exception
       */
      public static byte[] readInputStream(InputStream inStream) throws Exception {
          ByteArrayOutputStream outSteam = new ByteArrayOutputStream();
          byte[] buffer = new byte[1024];
          int len =  0;
          while( (len = inStream.read(buffer)) !=- 1 ){
              outSteam.write(buffer,  0, len);
          }
          outSteam.close();
          inStream.close();
          return outSteam.toByteArray();
      }
  }
  