各种进制转换常用方法
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);
}
各种进制转换常用方法相关推荐
- python中不同进制的整数之间可以直接运算_Python 进制转换、位运算
一.进制转换 编程用十进制,十进制转换为二进制.八进制.十六进制 In [135]: bin(23) Out[135]: '0b10111' In [136]: oct(23) Out[136]: ' ...
- c语言进制转换pdf下载,C语言实现任意进制转换.doc
C语言实现任意进制转换.doc includestdio.h#includemath.h#includestring.hvoid dtox(double num,int jz)char xnum100 ...
- 进制转换converse
栈和队列是在软件设计中常用的两种数据结构,它们的逻辑结构和线性表相同. 其特点在于运算受到了限制:栈按"后进先出"的规则进行操作,队按"先进先出"的规则进行操作 ...
- 进制转换 位运算（包括补码、原码、反码、~0等一些零碎东西一次说清）
我发现网上关于标题上的内容介绍的都很零碎,因此为了方便查找.也为了本人对这一部分的充分理解,就想着写一篇这样的博客(我分成了几个部分,以便查找): 一.进制转换 让我们先来看看各个进制的定义: 十进制 ...
- 每日一题（进制转换）
前言:为了让小伙伴更方便的学习编程语言,小白每天都会分享一道编程题.小白也创建了一个微信公众号,会同步更新题目和相关的视觉领域的知识,如果小伙伴不方便在网页上阅读文章,可以关注微信公众号"小 ...
- 进制转换数据结构c语言不用栈,急求！！！用数据结构（C语言）利用栈实现十进制向二（八）进制转换，要有注释，谢谢！...
匿名用户 1级 2013-12-05 回答 #include #include #include typedef unsigned int data_type; //结点数62616964757a68 ...
- 计算机中的数制和编码教案,计算机《数制与编码进制转换》公开课教案.doc
<计算机应用基础>教案 新田县职业中学 蒋玲 PAGE PAGE 7 数制与编码--进制转换 [学情分析]本课内容是在学生已经学习了计算机发展与应用.计算机系统的组成等知识的基础上进行,已 ...
- 进制转换（完成Python14作业的背景补充）
来源于小甲鱼进制转换视频 数的认识 数,是一个无形的.抽象的概念,它是人类用来表示数量的一个智力的产物 "一百"是一个抽象概念,用到计数书本有几页就会变成具体的.有形的概念 我们要 ...
- python 进制转换_Python数据结构与算法——递归应用之进制转换
高考加油 在前面的文章中堆栈也用于进制转换(存放余数).而递归也可以用于进制转换,有固定模式循环,并且可以规模越来越小的问题都可以转换成递归 栈与递归之间一定有点联系 整数转换成任意进制 日常运算都是 ...
最新文章
- [学习笔记]矩阵乘法及其优化dp
- Oracle 内存参数设置
- 多线程编程之线程同步主要函数一览
- 详解Linux的压缩解压缩命令
- Qt创建多线程的两种方法
- MVC过滤器详解 面向切面编程（AOP）
- c语言中如何通过二级指针来操作二维数组
- JavaEE 企业级分布式高级架构师（七）MongoDB学习笔记（3）
- pcfg 自然语言处理_自然语言处理：原理简明教程09-句法分析，语义分析和篇章分析...
- 10-Little prince's trip to Java-奇数魔方阵
- 分类模型效果评估指标
- 阿里云盘 WebDAV升级
- python selenium模拟浏览器操作实战（武汉大学原教务系统）
- mysql物理备份恢复搭建从库_RDS FOR MYSQL 各版本利用物理备份搭建从库方法
- uniapp调用c语言方法,使用uniapp开发的app/小程序需要注意：
- 天涯明月刀无法显示服务器,天涯明月刀登录不进去怎么办 pc端手机端服务器已满怎么解决_游戏369...
- SpringMVC(3)
- QQ永不被盗！只需2招！！！！！！！！！！
- “调节阀”发脾气了你怎么办？
- 机架感知(RackAwareness)