package main;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
/**
* 处理进制的工具类
**/
public class RadixUtil {
private final static String NAME = RadixUtil.class.getName();
/**
* 产生进制的数字
**/
public final static char[] DIGIT = {
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
'8', '9'
};
public final static Map<Character, Integer> digitMap = new HashMap<Character, Integer>();
static {
for (int i = 0; i < DIGIT.length; i++) {
digitMap.put(Character.valueOf(DIGIT[i]), Integer.valueOf(i));
}
}
/**
* 支持的最大进制数
*/
public static final int MAX_RADIX = DIGIT.length;
/**
* 支持的最小进制数
*/
public static final int MIN_RADIX = 2;
/**
* 最多一次返回32个字符
**/
public static final int SIZE = 32;
public static final long MAX_4_LETTER = letterToLong("ZZZZ");
public static final long MAX_3_LETTER = letterToLong("ZZZ");
/**
* 获得0的个数
**/
public static String obtainZero(int num) {
return obtainChar(num, DIGIT[0]);
}
/**
* 获得0的个数
**/
public static String obtainZero0(int num) {
return obtainChar(num, '0');
}
/**
* 获得特殊字符的个数
**/
public static String obtainChar(int num, char c) {
if (num < 0) {
return "";
}
StringBuilder sb = new StringBuilder();
while (num-- > 0) {
sb.append(c);
}
return sb.toString();
}
/**
* 获得long型数据的最大长度
**/
public static int obtainMaxLengOfLong() {
return longToString(Long.MAX_VALUE).length();
}
/**
* 只用26个大写字母
**/
public static String longToLetter(long i) {
return longToLetter(i, 0);
}
public static String longToLetter(long i, int length) {
return longToString(i, 26, length);
}
/**
* 用系统提供的字段长度
**/
public static String longToString(long i) {
return longToString(i, 0);
}
public static String longToString(long i, int length) {
return longToString(i, MAX_RADIX, length);
}
/**
* 将长整型数值转换为指定的进制数(最大支持62进制)
*/
public static String longToString(long i, int radix, int length) {
if (radix < MIN_RADIX || radix > MAX_RADIX) {
radix = 10;
}
if (radix == 10) {
return Long.toString(i);
}
StringBuilder sb = new StringBuilder(SIZE);
boolean negative = (i < 0);
if (negative) {
i = -i;
}
while (i >= radix) {
sb.append(DIGIT[(int) (i % radix)]);
i = i / radix;
}
sb.append(DIGIT[(int) (i)]);
if (negative) {
sb.append("-");
}
if (length <= 0 || sb.length() >= length) {
return sb.reverse().toString();
} else {
return obtainZero(length - sb.length()) + sb.reverse().toString();
}
}
/**
* 将字符串转换为长整型数字
*/
public static long stringToLong(String s) {
return stringToLong(s, MAX_RADIX);
}
public static long letterToLong(String s) {
return stringToLong(s, 26);
}
/**
* 将字符串转换为长整型数字
*/
public static long stringToLong(String s, int radix) {
if (s == null) {
throw new NumberFormatException("null");
}
if (radix < MIN_RADIX) {
throw new NumberFormatException("radix " + radix + " less than " + NAME + ".MIN_RADIX");
}
if (radix > MAX_RADIX) {
throw new NumberFormatException("radix " + radix + " greater than " + NAME + ".MAX_RADIX");
}
long result = 0;
char[] ss = s.toCharArray();
long factorial = 1;
for (int i = (ss.length - 1); i >= 0; i--) {
char c = ss[i];
Integer v = digitMap.get(Character.valueOf(c));
if (v != null) {
result += v.intValue() * factorial;
factorial *= radix;
} else if (c == '-') {
result = -result;
} else {
throw new NumberFormatException("char " + c + " not in " + NAME + ".DIGIT");
}
}
return result;
}
public static byte[] stringToBytes(String s) {
return stringToBytes(s, MAX_RADIX);
}
/**
* 将string转换成byte数组
*/
public static byte[] stringToBytes(String s, int radix) {
if (s == null) {
throw new NullPointerException(NAME + "parameter s is null");
}
StringBuilder binary = new StringBuilder(s.getBytes().length * 8);
long t;
String te = null;
int llength = obtainMaxLengOfLong();
int length = s.length() - 1;
int lastLength = (int) stringToLong(s.substring(length, s.length()), radix);
int start = 0;
int end = llength;
while (end < length) {
t = stringToLong(s.substring(start, end), radix);
te = Long.toBinaryString(t);
te = obtainZero0(radix - te.length()) + te;
binary.append(te);
start = end;
end = start + llength;
}
if (start < length) {
t = stringToLong(s.substring(start, length), radix);
te = Long.toBinaryString(t);
te = obtainZero0(lastLength - te.length()) + te;
binary.append(te);
}
length = binary.length();
byte[] result = new byte[length / Byte.SIZE];
int i = 0;
start = 0;
end = Byte.SIZE;
while (end < length) {
result[i++] = parseByte(binary.substring(start, end), 2);
start = end;
end = start + Byte.SIZE;
}
if (start < length) {
result[i++] = parseByte(binary.substring(start, length), 2);
}
return result;
}
public static String bytesToString(byte[] bs) {
return bytesToString(bs, MAX_RADIX);
}
/**
* 将byte数组转换成string
*/
public static String bytesToString(byte[] bs, int radix) {
StringBuilder result = new StringBuilder(bs.length);
StringBuilder binary = new StringBuilder(bs.length * 8);
String t = null;
for (int n = 0; n < bs.length; n++) {
byte b = bs[n];
t = Integer.toBinaryString(Byte.toUnsignedInt(b));
binary.append(obtainZero0(Byte.SIZE - t.length()) + t);
}
int length = binary.length();
int start = 0;
int end = radix;
while (end < length) {
t = longToString(Long.valueOf(binary.substring(start, end), 2), radix);
result.append(obtainZero(obtainMaxLengOfLong() - t.length()) + t);
start = end;
end = start + radix;
}
if (start < length) {
t = longToString(Long.valueOf(binary.substring(start, length), 2), radix);
result.append(t);
result.append(longToString(length - start, radix));
} else {
result.append(longToString(0, radix));
}
return result.toString();
}
public static byte parseByte(String s, int radix) throws NumberFormatException {
if (s == null) {
throw new NumberFormatException("s is null");
}
if (s.length() < 8) {
return Byte.parseByte(s, radix);
}
boolean nagetive = false;
if (s.charAt(0) == '1') {
s = '0' + s.substring(1, s.length());
nagetive = true;
}
int i = Integer.parseInt(s, radix);
if (nagetive) {
i = -i;
}
if (i < Byte.MIN_VALUE || i > Byte.MAX_VALUE)
throw new NumberFormatException("Value out of range. Value:\"" + s + "\" Radix:" + radix);
return (byte) i;
}
public static void main(String[] args) {
System.out.println(MAX_3_LETTER);
System.out.println(MAX_4_LETTER);
System.out.println(letterToLong("ZZZZZ"));
System.out.println(letterToLong("ZZZZZZ"));
System.out.println(letterToLong("ZZZZZZZ"));
System.out.println(letterToLong("ZZZZZZZZ"));
System.out.println(letterToLong("ZZZZZZZZZ"));
for (long j = 0L; j < 1000L; j++) {
String r = longToLetter(new Random().nextInt((int) MAX_4_LETTER), 4);
String s = r + longToLetter(j);
long b = letterToLong(s.substring(4, s.length()));
System.out.println(j + " " + r + " " + s + " " + b);
}
}
}