/** 
*  
* @param bytes 
* @return 将二进制转换为十六进制字符输出 
*/ </span>    private static String hexStr = "0123456789ABCDEF"; //全局
    public static String BinaryToHexString(byte[] bytes){  
   
  String result = "";  
  String hex = "";  
  for(int i=0;i<bytes.length;i++){  
    //字节高4位  
    <strong>hex = String.valueOf(hexStr.charAt((bytes[i]&0xF0)>>4)); </strong>
    //字节低4位  
   <strong>hex += String.valueOf(hexStr.charAt(bytes[i]&0x0F)); </strong> 
    result +=hex;  
  }  
  return result;  
    }  
    /** 
*  
* @param hexString 
* @return 将十六进制转换为字节数组 
*/ 
    public static byte[] HexStringToBinary(String hexString){  
  //hexString的长度对2取整，作为bytes的长度  
  int len = hexString.length()/2;  
  byte[] bytes = new byte[len];  
  byte high = 0;//字节高四位  
  byte low = 0;//字节低四位  
   
  for(int i=0;i<len;i++){  
    //右移四位得到高位  
    high = (byte)((hexStr.indexOf(hexString.charAt(2*i)))<<4);  
    low = (byte)hexStr.indexOf(hexString.charAt(2*i+1));  
    bytes[i] = (byte) (high|low);//高地位做或运算  
  }  
  return bytes;  
    }  
  } 

* @param src byte[] data 
 * @return hex string 
 */   
public static String bytesToHexString(byte[] src){ 
  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 hv = Integer.toHexString(v); 
    if (hv.length() < 2) { 
      stringBuilder.append(0); 
    } 
    stringBuilder.append(hv); 
  } 
  return stringBuilder.toString(); 
} 
/** 
 * Convert hex string to byte[] 
 * @param hexString the hex string 
 * @return byte[] 
 */ 
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; 
} 
/** 
 * Convert char to byte 
 * @param c char 
 * @return byte 
 */ 
 private byte charToByte(char c) { 
  return (byte) "0123456789ABCDEF".indexOf(c); 
} </span>

/** 
   * 字符串转换成十六进制字符串
   */ 
  public static String str2HexStr(String str) { 
    char[] chars = "0123456789ABCDEF".toCharArray(); 
    StringBuilder sb = new StringBuilder("");
    byte[] bs = str.getBytes(); 
    int bit; 
    for (int i = 0; i < bs.length; i++) { 
      bit = (bs[i] & 0x0f0) >> 4; 
      sb.append(chars[bit]); 
      bit = bs[i] & 0x0f; 
      sb.append(chars[bit]); 
    } 
    return sb.toString(); 
  } 

/**
  * 把16进制字符串转换成字节数组
  * @param hexString
  * @return byte[]
  */
 public static byte[] hexStringToByte(String hex) {
  int len = (hex.length() / 2);
  byte[] result = new byte[len];
  char[] achar = hex.toCharArray();
  for (int i = 0; i < len; i++) {
  int pos = i * 2;
  result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));
  }
  return result;
 }
 
 private static int toByte(char c) {
  byte b = (byte) "0123456789ABCDEF".indexOf(c);
  return b;
 }

/**
 * 数组转换成十六进制字符串
 * @param byte[]
 * @return HexString
 */
 public static final String bytesToHexString(byte[] bArray) {
 StringBuffer sb = new StringBuffer(bArray.length);
 String sTemp;
 for (int i = 0; i < bArray.length; i++) {
  sTemp = Integer.toHexString(0xFF & bArray[i]);
  if (sTemp.length() < 2)
  sb.append(0);
  sb.append(sTemp.toUpperCase());
 }
 return sb.toString();
 }

/**
   * 数组转成十六进制字符串
   * @param byte[]
   * @return HexString
   */
  public static String toHexString1(byte[] b){
    StringBuffer buffer = new StringBuffer();
    for (int i = 0; i < b.length; ++i){
      buffer.append(toHexString1(b[i]));
    }
    return buffer.toString();
  }
  public static String toHexString1(byte b){
    String s = Integer.toHexString(b & 0xFF);
    if (s.length() == 1){
      return "0" + s;
    }else{
      return s;
    }
  }

/**
 * 十六进制字符串转换成字符串
 * @param hexString
 * @return String
 */
  public static String hexStr2Str(String hexStr) { 

    String str = "0123456789ABCDEF"; 
    char[] hexs = hexStr.toCharArray(); 
    byte[] bytes = new byte[hexStr.length() / 2]; 
    int n; 
    for (int i = 0; i < bytes.length; i++) { 
      n = str.indexOf(hexs[2 * i]) * 16; 
      n += str.indexOf(hexs[2 * i + 1]); 
      bytes[i] = (byte) (n & 0xff); 
    } 
    return new String(bytes); 
  }

/**
   * 十六进制字符串转换字符串
   * @param HexString
   * @return String
   */
 public static String toStringHex(String s) {
 byte[] baKeyword = new byte[s.length() / 2];
 for (int i = 0; i < baKeyword.length; i++) {
  try {
  baKeyword[i] = (byte) (0xff & Integer.parseInt(s.substring(
   i * 2, i * 2 + 2), 16));
  } catch (Exception e) {
  e.printStackTrace();
  }
 }
 try {
  s = new String(baKeyword, "utf-8");// UTF-16le:Not
 } catch (Exception e1) {
  e1.printStackTrace();
 }
 return s;
 }