Binary Conversion
package io.programming.bodh;
/**
* @Author Labu
* @Description 二进制转换
*/
public class BinaryConversion {
/**
* 二进制字符串转成八进制字符串
*
* @param inputBin 二进制字符串
* @return java.lang.String
* @author Labu
*/
public static String binaryToOctal(String inputBin) {
if (!Bodh.isLegalBin(inputBin))
return "无效的二进制字符串";
String[] baseArray = getBaseArray(inputBin, Bodh.OCTAL);
String result = "";
for (String s : baseArray) {
result += binaryToDecimal(s);
}
return result;
}
/**
* 二进制字符串转成十进制字符串
*
* @param inputBin 二进制字符串
* @return java.lang.String
* @author Labu
*/
public static String binaryToDecimal(String inputBin) {
if (!Bodh.isLegalBin(inputBin))
return "无效的二进制字符串";
return Bodh.convertToDecimal(inputBin, Bodh.BINARY);
}
/**
* 二进制字符串转成十六进制字符串
*
* @param inputBin 二进制字符串
* @return java.lang.String
* @author Labu
*/
public static String binaryToHexadecimal(String inputBin) {
if (!Bodh.isLegalBin(inputBin))
return "无效的二进制字符串";
String[] baseArray = getBaseArray(inputBin, Bodh.HEXADECIMAL);
String result = "";
for (String s : baseArray) {
result += Bodh.toHexChar(Integer.parseInt(binaryToDecimal(s)));
}
return result;
}
/**
* 将二进制字符串分割成3个一组（八进制）的字符串数组或者4个一组（十六进制）的字符串数组
*
* @param input 输入字符串
* @param targetBase 目标进制基数
* @return 字符串数组
*/
private static String[] getBaseArray(String input, byte targetBase) {
byte divideBase = targetBase == Bodh.OCTAL ? Bodh.OCTAL_DIVIDE_BASE : Bodh.HEXADECIMAL_DIVIDE_BASE;
int length = input.length();
int count = length / divideBase + (length % divideBase == 0 ? 0 : 1);
String[] result = new String[count];
for (int i = 0; i < count && length >= 0; i++, length -= divideBase) {
int index = length - divideBase;
if (length < divideBase) {
index = 0;
}
String substring = input.substring(index, length);
result[count - i - 1] = substring;
}
return result;
}
}
Octal Conversion
package io.programming.bodh;
/**
* @Author Labu
* @Description 八进制转换
*/
public class OctalConversion {
/**
* 八进制转二进制
*
* @param inputOct 输入的八进制数
* @return java.lang.String
* @author Labu
*/
public static String octalToBinary(String inputOct) {
if (!Bodh.isLegalOct(inputOct))
return "无效的八进制字符串";
return Bodh.convertToBinary(inputOct, Bodh.OCTAL_DIVIDE_BASE);
}
/**
* 八进制转十进制
*
* @param inputOct 输入的八进制数
* @return java.lang.String
* @author Labu
*/
public static String octalToDecimal(String inputOct) {
if (!Bodh.isLegalOct(inputOct))
return "无效的八进制字符串";
return Bodh.convertToDecimal(inputOct, Bodh.OCTAL);
}
/**
* 八进制转十六进制
*
* @param inputOct 输入的八进制数
* @return java.lang.String
* @author Labu
*/
public static String octalToHexadecimal(String inputOct) {
if (!Bodh.isLegalOct(inputOct))
return "无效的八进制字符串";
return BinaryConversion.binaryToHexadecimal(octalToBinary(inputOct));
}
}
Decimal Conversion
package io.programming.bodh;
/**
* @Author Labu
* @Description 十进制转换
*/
public class DecimalConversion {
/**
* 十进制转换的基本算法，对进制基数进行长除法，然后所得余数倒序输出
*
* @param input 输入的字符
* @param base 需要转换的进制基数，在算法中也是除数
* @return java.lang.String
* @author Labu
*/
private static String convert(String input, byte base) {
/*
定义商为第一次的被除数，base为除数，remainder为余数，在商为0的余数字符倒序输出就是对应的二进制数
*/
String result = "";
int quotient = Integer.parseInt(input);
int remainder;
do {
remainder = quotient % base;
quotient = quotient / base;
if (base == Bodh.HEXADECIMAL) { // 如果是转十六进制需要用的转换
char c = Bodh.toHexChar(remainder);
result += c;
} else {
result += remainder;
}
} while (quotient != 0);
return new StringBuffer(result).reverse().toString();
}
/**
* 十进制数字符串转换成二进制数字符串
*
* @param inputDec 输入的十进制字符串
* @return java.lang.String
* @author Labu
*/
public static String decimalToBinary(String inputDec) {
if (!Bodh.isLegalDec(inputDec))
return "无效的十进制字符串";
return convert(inputDec, Bodh.BINARY);
}
/**
* 十进制整数转换成二进制数字符串
*
* @param inputDec 输入的十进制整数
* @return java.lang.String
* @author Labu
*/
public static String decimalToBinary(int inputDec) {
if (inputDec < 0)
return "这里不做补码转换，想要负数，直接在数字前加负号，请谅解！";
return decimalToBinary("" + inputDec);
}
public static String decimalToOctal(int inputDec) {
if (inputDec < 0)
return "这里不做补码转换，想要负数，直接在数字前加负号，请谅解！";
return decimalToOctal("" + inputDec);
}
public static String decimalToHexadecimal(int inputDec) {
if (inputDec < 0)
return "这里不做补码转换，想要负数，直接在数字前加负号，请谅解！";
return decimalToHexadecimal("" + inputDec);
}
/**
* 十进制数字符串转换成八进制数字符串
*
* @param inputDec 输入的十进制数字符串
* @return java.lang.String
* @author Labu
*/
public static String decimalToOctal(String inputDec) {
if (!Bodh.isLegalDec(inputDec))
return "无效的十进制字符串";
return convert(inputDec, Bodh.OCTAL);
}
/**
* 十进制数字符串转换成十六进制数字符串
*
* @param inputDec 输入的十进制数字符串
* @return java.lang.String
* @author Labu
*/
public static String decimalToHexadecimal(String inputDec) {
if (!Bodh.isLegalDec(inputDec))
return "无效的十进制字符串";
return convert(inputDec, Bodh.HEXADECIMAL);
}
}
Hexadecimal Conversion
package io.programming.bodh;
/**
* @Author Labu
* @Description 十六进制转换
*/
public class HexadecimalConversion {
/**
* 16 to 2
*
* @param inputHex 输入十六进制字符串
* @return java.lang.String
* @author Labu
*/
public static String hexToBinary(String inputHex) {
if (!Bodh.isLegalHex(inputHex))
return "无效的十六进制字符串";
return Bodh.convertToBinary(inputHex, Bodh.HEXADECIMAL_DIVIDE_BASE);
}
/**
* 16 to 8
*
* @param inputHex 输入十六进制字符串
* @return java.lang.String
* @author Labu
*/
public static String hexToOctal(String inputHex) {
if (!Bodh.isLegalHex(inputHex))
return "无效的十六进制字符串";
return BinaryConversion.binaryToOctal(hexToBinary(inputHex));
}
/**
* 16 to 10
*
* @param inputHex 输入十六进制字符串
* @return java.lang.String
* @author Labu
*/
public static String hexToDecimal(String inputHex) {
if (!Bodh.isLegalHex(inputHex))
return "无效的十六进制字符串";
return Bodh.convertToDecimal(inputHex, Bodh.HEXADECIMAL);
}
}
工具类
package io.programming.bodh;
import java.util.*;
/**
* @Author Labu
* @Description 进制转换工具类
*/
public class Bodh {
/*
二进制标识符
*/
public static final byte BINARY = 2;
/*
八进制标识符
*/
public static final byte OCTAL = 8;
public static final byte OCTAL_DIVIDE_BASE = 3;
/*
十进制标识符
*/
public static final byte DECIMAL = 10;
/*
十六进制标识符
*/
public static final byte HEXADECIMAL = 16;
public static final byte HEXADECIMAL_DIVIDE_BASE = 4;
final static char[] digits = {
'0', '1', '2', '3', '4', '5',
'6', '7', '8', '9', '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'
};
// 十六进制需要的额外字符
final static char[] exHex = {'A', 'B', 'C', 'D', 'E', 'F'};
// 十六进制字符与值的映射
public static final Map<String, String> hexMap = hexMap();
static List<Character> binaryList = toList(digits, BINARY);
static List<Character> octalList = toList(digits, OCTAL);
static List<Character> decimalList = toList(digits, DECIMAL);
static List<Character> hexList = toList(digits, HEXADECIMAL);
// public static void main(String[] args) {
// System.out.println(octalList);
// }
/**
* 将digits中的字符前n个字符转换为List
*
* @param chars 字符数组，包含进制基数的字符数组
* @param base 进制基数
* @return java.util.List<java.lang.Character>
* @author Labu
*/
public static List<Character> toList(char[] chars, byte base) {
List<Character> characters = new ArrayList<>();
for (int i = 0; i < base; i++) {
characters.add(chars[i]);
}
if (base == HEXADECIMAL) {
for (char hex : exHex) {
characters.add(hex);
}
}
return characters;
}
// 二进制数字符串的数据校验
public static boolean isLegalBin(String inputBin) {
for (int i = 0; i < inputBin.length(); i++) {
char c = inputBin.charAt(i);
if (c != '0' && c != '1')
return false;
}
return true;
}
// 八进制数字符串的数据校验
public static boolean isLegalOct(String inputOct) {
for (int i = 0; i < inputOct.length(); i++) {
char c = inputOct.charAt(i);
if (!octalList.contains(c))
return false;
}
return true;
}
// 十进制数字符串的数据校验
public static boolean isLegalDec(String inputDec) {
for (int i = 0; i < inputDec.length(); i++) {
char c = inputDec.charAt(i);
if (!decimalList.contains(c))
return false;
}
return true;
}
// 十六进制数字符串的数据校验
public static boolean isLegalHex(String inputHex) {
for (int i = 0; i < inputHex.length(); i++) {
char c = inputHex.charAt(i);
if (!hexList.contains(c))
return false;
}
return true;
}
/**
* 其他进制转成二进制
*
* @param input 输入的字符串
* @param divideBase 被分割的基数
* @return java.lang.String
* @author Labu
*/
public static String convertToBinary(String input, int divideBase) {
String result = "";
// 每个数字单独提出来转成相应位数的二进制数，不够的补零
for (int i = 0; i < input.length(); i++) {
String c = input.charAt(i) + "";
if (divideBase == Bodh.HEXADECIMAL_DIVIDE_BASE)
c = hexToDec(c);
result += Bodh.addZero(DecimalConversion.decimalToBinary(c), divideBase);
}
return cutZero(result);
}
/**
* 其他进制转换成十进制的统一算法
*
* @param input 输入字符串
* @return java.lang.String
* @author Labu
*/
public static String convertToDecimal(String input, byte base) {
int length = input.length();
int sum = 0;
for (int i = 0; i < length; i++) {
String s = "" + input.charAt(length - 1 - i);
if (base == Bodh.HEXADECIMAL)
s = hexToDec(s);
int c = Integer.parseInt(s);
sum += c * Math.pow(base, i);
}
return "" + sum;
}
/**
* 剪切掉字符前多余的0
*
* @param str 字符串
* @return java.lang.String
* @author Labu
*/
public static String cutZero(String str) {
int i = 0;
while (str.charAt(i) == '0') {
i++;
}
return str.substring(i);
}
/**
* 根据需要的num，在字符串前补相差个数的零
*
* @param str 需要补零的字符串
* @param num 需要的长度
* @return java.lang.String
* @author Labu
*/
public static String addZero(String str, int num) {
for (int i = str.length(); i < num; i++) {
str = "0" + str;
}
return str;
}
/**
* 将数字转换为十六进制表示的字符
*
* @param inputHex 输入一般是十进制数
* @return char
* @author Labu
*/
public static char toHexChar(int inputHex) {
return hexList.get(inputHex);
}
/**
* 十六进制的单个字符串转换成十进制字符串
*
* @param inputHex 十六进制字符串
* @return java.lang.String
* @author Labu
*/
public static String hexToDec(String inputHex) {
return hexMap.get(inputHex);
}
/**
* 生成一个存放十六进制字符对应十进制数值字符串的map
*
* @return java.util.Map<java.lang.String, java.lang.String>
* @author Labu
*/
public static Map<String, String> hexMap() {
Map<String, String> hexMap = new HashMap<>();
for (int i = 0; i < HEXADECIMAL; i++) {
hexMap.put("" + digits[i], "" + i);
}
for (int i = 0, j = 10; i < exHex.length; i++, j++) {
hexMap.put("" + exHex[i], "" + j);
}
return hexMap;
}
}
