各种进制转换常用方法

public final class Util {

 /*
  * 16进制字符数组
  */
 private static final char[] HEX_DIGITS = "0123456789ABCDEF".toCharArray();

 /**
  * 字节数组转十六进制字符串
  *
  * @param ba
  *            原数据
  * @param offset
  *            开始位移
  * @param length
  *            长度
  * @return 16进制字符串
  */
 public final static String ba2HexString(byte[] ba, int offset, int length) {
  char[] buf = new char[length << 1];
  for (int i = 0, j = 0, k; i < length;) {
   k = ba[offset + i++];
   buf[j++] = HEX_DIGITS[(k >>> 4) & 0x0F];
   buf[j++] = HEX_DIGITS[k & 0x0F];
  }
  return new String(buf);
 }

 /**
  * 字节数组转十六进制字符串
  *
  * @param ba
  *            原数据
  * @return 16进制字符串
  */
 public final static String ba2HexString(byte[] ba) {
  return ba2HexString(ba, 0, ba.length);
 }

 /**
  * 字符转字节
  *
  * @param c
  * @return
  */
 private static byte char2Byte(char c) {
  if (c >= '0' && c <= '9') {
   return (byte) (c - '0');
  } else if (c >= 'A' && c <= 'F') {
   return (byte) (c - 'A' + 10);
  } else if (c >= 'a' && c <= 'f') {
   return (byte) (c - 'a' + 10);
  } else
   throw new IllegalArgumentException("Invalid hexadecimal digit: " + c);
 }

 /**
  * 16进制字符串转字节数组
  *
  * @param s
  *            16进制字符串
  * @return 字节数组
  */
 public final static byte[] hexString2Ba(String s) {
  if (s == null || s.length() == 0) {
   return null;
  }
  int limit = s.length();
  byte[] result = new byte[((limit + 1) / 2)];
  int i = 0, j = 0;
  if ((limit % 2) == 1) {
   result[j++] = (byte) char2Byte(s.charAt(i++));
  }
  while (i < limit) {
   result[j] = (byte) (char2Byte(s.charAt(i++)) << 4);
   result[j++] |= (byte) char2Byte(s.charAt(i++));
  }
  return result;
 }

 /**
  * 数字型转16进制字符串(可指定16进制串字节数)
  *
  * @param n
  *            数字型数据
  * @param byteNum
  *            转换后的字节数
  * @return 16进制字符串
  */
 public final static String long2HexString(long n, int byteNum) {
  byteNum <<= 1;
  char[] buf = new char[byteNum];
  for (int i = byteNum - 1; i >= 0; i--) {
   buf[i] = HEX_DIGITS[(int) (n & 0x0FL)];
   n >>>= 4;
  }
  return new String(buf);
 }

 /**
  * 数字型转字节数组
  *
  * @param l
  *            转换数据
  * @param len
  *            最大字节数
  * @return 字节数组
  */
 public final static byte[] long2Ba(long l, int len) {
  if (len < 0) {
   return null;
  }
  if (len > 8) {
   len = 8;
  }

  byte[] temp = new byte[len];
  for (int i = len - 1, j = 0; i >= 0; i--, j++) {
   temp[j] = (byte) (l >>> (i << 3));
  }
  return temp;
 }

 /**
  * 字节转LONG类型
  *
  * @param ba
  *            字节数组
  * @return long
  */
 public final static long ba2Long(byte[] ba) {
  if (ba.length <= 0 || ba.length > 8) {
   throw new IllegalArgumentException("ba(length: 1~8bytes).");
  }

  long l = 0;
  for (int i = 0, j = ba.length - 1; i <= j; i++) {
   l = l | ((ba[i] & 0xFFL) << ((j - i) << 3));
  }
  return l;
 }

 /**
  * 字符串转UNICODE编码
  *
  * @param s
  *            数据字符串
  * @return UNICODE码字符串
  * @throws UnsupportedEncodingException
  */
 public final static String toUnicodeString(String s) throws UnsupportedEncodingException {
  if (s == null) {
   throw new NullPointerException("toUnicodeString(): s is null!");
  }
  StringBuilder sb = new StringBuilder();
  byte[] ba = s.getBytes("UnicodeBigUnmarked");
  int i = 0;
  int k, length = ba.length;
  while (i < length) {
   k = ba[i++];
   sb.append(HEX_DIGITS[(k >>> 4) & 0x0F]);
   sb.append(HEX_DIGITS[k & 0x0F]);

   k = ba[i++];
   sb.append(HEX_DIGITS[(k >>> 4) & 0x0F]);
   sb.append(HEX_DIGITS[k & 0x0F]);
  }
  return sb.toString();
 }

 /**
  * Unicode编码转字符串
  *
  * @param s
  *            unicode字符串
  * @return UNICODE码解码后的字符串
  * @throws UnsupportedEncodingException
  */
 public final static String unicode2String(String s) throws UnsupportedEncodingException {
  return new String(hexString2Ba(s), "UTF-16BE");
 }

 /**
  * 字节转16进制
  *
  * @param b
  *            待转字节
  * @return 16进制串
  */
 public final static String b2HexString(byte b) {
  char[] buf = { HEX_DIGITS[b >>> 4 & 0x0F], HEX_DIGITS[b & 0x0F] };
  return new String(buf);
 }

 /**
  * 16进制串转base64编码
  *
  * @param hexString
  * @return
  */
 public final static String hexString2Base64(String hexString) {
  return Base64.encode(hexString2Ba(hexString));
 }

 /**
  * base64编码转16进制
  *
  * @param base64String
  * @return
  * @throws UnsupportedEncodingException
  */
 public final static String base64ToHexString(String base64String) throws UnsupportedEncodingException {
  return ba2HexString(Base64.decode(base64String));
 }

 /**
  * 字节数组转base64编码
  *
  * @param src
  * @return
  */
 public final static String ba2Base64(byte[] src) {
  return Base64.encode(src);
 }

 /**
  * base64编码转16进制
  *
  * @param base64String
  * @return
  * @throws UnsupportedEncodingException
  */
 public final static byte[] base64ToBa(String base64String) throws UnsupportedEncodingException {
  return Base64.decode(base64String);
 }

 /**
  * date转成指定格式的字符串(如yyyyMMdd HHmmss)
  *
  * @param date
  * @param format
  * @return
  */
 public final static String date2String(Date date, String format) {
  SimpleDateFormat sf = new SimpleDateFormat(format);
  return sf.format(date);
 }

 /**
  * 日期字符串转long类型
  *
  * @param dateString
  * @param dateFormat
  * @return
  * @throws ParseException
  */
 public final static long dateStr2Long(String dateString, String dateFormat) throws ParseException {
  SimpleDateFormat sf = new SimpleDateFormat(dateFormat);
  Date d = sf.parse(dateString);
  return d.getTime();
 }

 /**
  * long类型转字符串
  *
  * @param date
  * @param dateFormat
  * @return
  */
 public final static String long2Date(long date, String dateFormat) {
  SimpleDateFormat sf = new SimpleDateFormat(dateFormat);
  return sf.format(new Date(date));
 }

 /**
  * BCD转换
  *
  * @param s
  * @return
  */
 public final static String bcdEncode(String s) {
  char[] c = s.toCharArray();
  char temp;
  for (int i = 0, j = c.length - 1; i < j; i += 2) {
   temp = c[i];
   c[i] = c[i + 1];
   c[i + 1] = temp;
  }
  return new String(c);
 }

 /**
  * 字符串转ASCII码
  *
  * @param str
  * @return
  * @throws UnsupportedEncodingException
  */
 public final static String string2Ascii(String str) throws UnsupportedEncodingException {
  return ba2HexString(str.getBytes("ASCII"));
 }

 /**
  * ASCII码转字符串
  *
  * @param str
  * @return
  */
 public final static String ascii2String(String str) {
  return new String(hexString2Ba(str));
 }

 /**
  * 产生指定字节长度的随机数
  *
  * @param len
  *            要产生随机数字节数
  * @return String
  */
 public static String getRandomHexString(int len) {
  char[] ch = new char[len << 1];
  Random rand = new Random();
  for (int i = 0; i < ch.length; i++) {
   ch[i] = HEX_DIGITS[rand.nextInt(16)];
  }
  return new String(ch);
 }

 /**
  * 数据填充
  *
  * @param data
  *            原始数据
  * @param firstPadByte
  *            第一字节填充值
  * @param nextPadByte
  *            后续的填充值
  * @param padding
  *            当原始数据为8字节整数倍时是否还需填充8字节数据
  * @return
  */
 public final static byte[] padding(byte[] data, byte firstPadByte, byte nextPadByte, boolean padding) {
  int padLen = data.length % 8;
  byte[] temp = null;
  if (padLen == 0) {
   if (padding) {
    temp = new byte[data.length + 8];
    System.arraycopy(data, 0, temp, 0, data.length);
    temp[data.length] = firstPadByte;
    for (int i = 1; i < 8; i++) {
     temp[data.length + i] = nextPadByte;
    }
    return temp;
   }
   return data;
  }

  padLen = 8 - padLen;
  temp = new byte[data.length + padLen];
  System.arraycopy(data, 0, temp, 0, data.length);
  temp[data.length] = firstPadByte;
  for (int i = 1; i < padLen; i++) {
   temp[data.length + i] = nextPadByte;
  }
  return temp;
 }

 /**
  * 将字节右补位到长度len，源数组长度大于len，则自动截取前len个字节。
  *
  * @param src
  *            源字节数组
  * @param len
  *            目标长度
  * @param padding
  *            填充字节
  * @return
  */
 public final static byte[] padding(byte[] src, int len, byte padding) {

  byte[] _rt = new byte[len];
  if (src == null) {
   for (int i = 0; i < len; i++) {
    _rt[i] = padding;
   }
  } else if (src.length >= len) {
   System.arraycopy(src, 0, _rt, 0, len);
  } else {
   System.arraycopy(src, 0, _rt, 0, src.length);
   for (int i = src.length; i < len; i++) {
    _rt[i] = padding;
   }
  }
  return _rt;
 }

 /**
  * 生成BER-TLV格式数据
  *
  * @param data
  *            数据
  * @return
  */
 public final static byte[] convertToBerTlvFormat(byte[] data) {
  if (data == null) {
   throw new NullPointerException("convertToBerTlvFormat: data.");
  }

  byte[] result = null;
  byte[] temp = null;
  int len = data.length;
  if (len >= 0x00 && len < 0x80) {
   result = new byte[1 + len];
   result[0] = (byte) len;
   System.arraycopy(data, 0, result, 1, len);
  } else if (len > 0x7F && len <= 0xFF) {
   result = new byte[2 + len];
   result[0] = (byte) 0x81;
   result[1] = (byte) len;
   System.arraycopy(data, 0, result, 2, len);
  } else if (len > 0xFF && len <= 0xFFFF) {
   result = new byte[3 + len];
   result[0] = (byte) 0x82;
   temp = CrbUtil.long2Ba(len, 2);
   System.arraycopy(temp, 0, result, 1, 2);
   System.arraycopy(data, 0, result, 3, len);
  } else if (len > 0xFFFF && len <= 0xFFFFFF) {
   result = new byte[4 + len];
   result[0] = (byte) 0x83;
   temp = CrbUtil.long2Ba(len, 3);
   System.arraycopy(temp, 0, result, 1, 3);
   System.arraycopy(data, 0, result, 4, len);
  } else if (len > 0xFFFFFF && len <= 0xFFFFFFFFL) {
   result = new byte[5 + len];
   result[0] = (byte) 0x84;
   temp = CrbUtil.long2Ba(len, 4);
   System.arraycopy(temp, 0, result, 1, 4);
   System.arraycopy(data, 0, result, 5, len);
  }
  return result;
 }

 /**
  * 获取BerTlv格式中的数据域
  *
  * @param berTlvData
  * @return
  */
 public final static byte[] filterBerTlv(byte[] berTlvData) {
  if (berTlvData == null) {
   throw new NullPointerException("filterBerTlv(): berTlvData.");
  }

  int n = 0;
  if ((berTlvData[1] & 0x80) == 0x80) {
   n += berTlvData[1] & 0x0F;
  }

  int len = 0;
  int index = 0;
  if (n == 0) {
   len = berTlvData[1];
   index = 2;
  } else {
   for (int i = 1; i <= n; i++) {
    len |= (berTlvData[i + 1] & 0xFF) << ((n - i) * 8);
   }
   index = n + 2;
  }

  byte[] temp = new byte[len];
  System.arraycopy(berTlvData, index, temp, 0, len);
  return temp;
 }

 /**
  * 把接入号转成Ton/Npi格式
  *
  * @param smsGateIp
  * @return
  */
 public static String str2TonNpi(String smsGateIp) {
  StringBuilder sb = new StringBuilder("81");
  if (smsGateIp.length() % 2 != 0) {
   smsGateIp = smsGateIp + "F";
  }
  char[] c = smsGateIp.toCharArray();
  for (int i = 0; i < c.length; i++) {
   if (i % 2 == 0) {
    sb.append(c[i]);
   } else {
    sb.insert(1 + i, c[i]);
   }
  }
  return sb.toString();
 }

 /**
  * 字符串填充
  *
  * @param src
  *            待填充数据
  * @param paddingChar
  *            填充字节
  * @param paddingLen
  *            填充后字符串的长度
  * @param leftPadding
  *            是否左填充
  * @return
  */
 public final static String padding(String src, char paddingChar, int paddingLen, boolean leftPadding) {
  int srcLen = src.length();
  if (srcLen >= paddingLen) {
   return src;
  }

  StringBuilder sb = new StringBuilder();
  for (int i = paddingLen; srcLen < i; i--) {
   sb.append(paddingChar);
  }

  return leftPadding ? sb.append(src).toString() : sb.insert(0, src).toString();
 }

 /**
  * 按指定字节填充16进制串
  *
  * @param hexStr
  *            源16进制字符串
  * @param paddingByte
  *            填充字节
  * @param paddingLen
  *            填充后达到的字节数
  * @param leftPadding
  *            是否左填充
  * @return
  */
 public final static String paddingHexStr(String hexStr, byte paddingByte, int paddingLen, boolean leftPadding) {
  int srcLen = hexStr.length() >> 1;
  if (srcLen >= paddingLen) {
   return hexStr;
  }

  byte[] ba = hexString2Ba(hexStr);
  byte[] result = new byte[paddingLen];
  byte[] temp = new byte[paddingLen - srcLen];
  for (int i = 0; i < temp.length; i++) {
   temp[i] = paddingByte;
  }
  if (leftPadding) {
   System.arraycopy(temp, 0, result, 0, temp.length);
   System.arraycopy(ba, 0, result, temp.length, ba.length);
  } else {
   System.arraycopy(ba, 0, result, 0, ba.length);
   System.arraycopy(temp, 0, result, ba.length, temp.length);
  }
  return ba2HexString(result);
 }

 /**
  * LV格式编码
  *
  * @param lengthSize
  *            长度字节数
  * @param value
  *            原始值
  * @param isHex
  *            是否为十六进制串
  * @return LV格式串
  */
 public static String encodeLV(int lengthSize, String value, boolean isHex) {

  if (value == null) {
   value = "";
  }
  if (!isHex) {
   value = ba2HexString(value.getBytes());
  }
  return CrbUtil.long2HexString(value.length() >> 1, lengthSize) + value;
 }

 /**
  * LV格式解码
  *
  * @param lengthSize
  *            长度字节数
  * @param value
  *            LV格式串
  * @return {当前数据,剩余数据}
  */
 public final static String[] decodeLV(int lengthSize, String value) {
  String[] ret = new String[] { "", "" };
  lengthSize *= 2;
  int length = Integer.parseInt(value.substring(0, lengthSize), 16) << 1;
  ret[0] = value.substring(lengthSize, lengthSize + length);
  ret[1] = value.substring(lengthSize + length);
  return ret;
 }

 /**
  * 字符串扩展(如0x12转换后为0x01 0x02)
  *
  * @param hexStr
  * @return
  */
 public final static String hexStringEx(String hexStr) {
  if (hexStr == null) {
   return null;
  }

  char[] c = hexStr.toCharArray();
  byte[] temp = new byte[c.length];
  for (int i = 0; i < c.length; i++) {
   temp[i] = char2Byte(c[i]);
  }
  return CrbUtil.ba2HexString(temp);
 }

 /**
  * 将字节数组转换成int型整数
  *
  * @param ba
  * @return
  */
 public static int ba2int(byte[] ba, int baOff, int baLen) {
  return Integer.parseInt(ba2HexString(ba, baOff, baLen), 16);
 }
 
 /**
  * 字符串敏感数据填充
  *
  * @param clearTextLen 明文字节数
  * @param plainKey 被填充的十六进制字符串
  * @return
  */
 public static String doMask(int clearTextLen, String plainKeyValue) {
  if (plainKeyValue == null || plainKeyValue.trim().equals(""))
   return null;

  byte[] plainKey = hexString2Ba(plainKeyValue);
  StringBuilder sb = new StringBuilder();
  int i = 0;
  int plainLength = plainKey.length - clearTextLen > 0 ? clearTextLen : plainKey.length;
  for (; i < plainLength; ++i) {
   sb.append(Integer.toHexString((0xF0 & plainKey[i]) >> 4));
   sb.append(Integer.toHexString(0xF & plainKey[i]));
   sb.append(':');
  }
  for (; i < plainKey.length; ++i) {
   sb.append("xx:");
  }

  return sb.toString();
 }

 

/**
  * 定长BCD补0
  * @param len
  * @param val
  * @return
  */
 public static String refFixZreo(int len, String val) {
  char[] strChar = val.toCharArray();
  char[] chars = new char[len];
  if(strChar.length > len) {
   System.out.println("数据长度:"+val+"超出域定义长度位数:" + len);
   return null;
  }
  for(int i=0; i<len; i++) {
   if(i<strChar.length) {
    chars[len - strChar.length + i] = strChar[i];
   }else{
    chars[len - i - 1] = '0';
   }
  }
  return String.valueOf(chars);
 }
 
 public static  char[] getChars (byte[] bytes) {
       Charset cs = Charset.forName ("UTF-8");
       ByteBuffer bb = ByteBuffer.allocate (bytes.length);
       bb.put (bytes);
                  bb.flip ();
        CharBuffer cb = cs.decode (bb);
  
    return cb.array();
 }

 public static String getUUID() {
  String s = UUID.randomUUID().toString();
  // 去掉“-”符号
  return s;
 }

 

/**
  * 16进制转2进制
  * @param hexString
  * @return
  */
 public static String hexString2binaryString(String hexString) 
    { 
        if (hexString == null || hexString.length() % 2 != 0) 
            return null; 
        String bString = "", tmp; 
        for (int i = 0; i < hexString.length(); i++) 
        { 
            tmp = "0000" 
                    + Integer.toBinaryString(Integer.parseInt(hexString 
                            .substring(i, i + 1), 16)); 
            bString += tmp.substring(tmp.length() - 4); 
        } 
        return bString; 
    }
 
 /**
  * 2进制转16进制
  * @param bString
  * @return
  */
 public static String binaryString2hexString(String bString) 
    { 
        if (bString == null || bString.equals("") || bString.length() % 8 != 0) 
            return null; 
        StringBuffer tmp = new StringBuffer(); 
        int iTmp = 0; 
        for (int i = 0; i < bString.length(); i += 4) 
        { 
            iTmp = 0; 
            for (int j = 0; j < 4; j++) 
            { 
                iTmp += Integer.parseInt(bString.substring(i + j, i + j + 1)) << (4 - j - 1); 
            } 
            tmp.append(Integer.toHexString(iTmp)); 
        } 
        return tmp.toString(); 
    }

//  // 十进制转化为十六进制，结果为C8。
//  String b = Integer.toHexString(219);
//  System.out.println(b);
//  // 十六进制转化为十进制
//  int a = Integer.parseInt("db",16);
//  System.out.println(a);

 

 

}