Binary Conversion
package io.programming.bodh;
public class BinaryConversion {
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;
}
public static String binaryToDecimal(String inputBin) {
if (!Bodh.isLegalBin(inputBin))
return "无效的二进制字符串";
return Bodh.convertToDecimal(inputBin, Bodh.BINARY);
}
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;
}
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;
public class OctalConversion {
public static String octalToBinary(String inputOct) {
if (!Bodh.isLegalOct(inputOct))
return "无效的八进制字符串";
return Bodh.convertToBinary(inputOct, Bodh.OCTAL_DIVIDE_BASE);
}
public static String octalToDecimal(String inputOct) {
if (!Bodh.isLegalOct(inputOct))
return "无效的八进制字符串";
return Bodh.convertToDecimal(inputOct, Bodh.OCTAL);
}
public static String octalToHexadecimal(String inputOct) {
if (!Bodh.isLegalOct(inputOct))
return "无效的八进制字符串";
return BinaryConversion.binaryToHexadecimal(octalToBinary(inputOct));
}
}
Decimal Conversion
package io.programming.bodh;
public class DecimalConversion {
private static String convert(String input, byte base) {
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();
}
public static String decimalToBinary(String inputDec) {
if (!Bodh.isLegalDec(inputDec))
return "无效的十进制字符串";
return convert(inputDec, Bodh.BINARY);
}
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);
}
public static String decimalToOctal(String inputDec) {
if (!Bodh.isLegalDec(inputDec))
return "无效的十进制字符串";
return convert(inputDec, Bodh.OCTAL);
}
public static String decimalToHexadecimal(String inputDec) {
if (!Bodh.isLegalDec(inputDec))
return "无效的十进制字符串";
return convert(inputDec, Bodh.HEXADECIMAL);
}
}
Hexadecimal Conversion
package io.programming.bodh;
public class HexadecimalConversion {
public static String hexToBinary(String inputHex) {
if (!Bodh.isLegalHex(inputHex))
return "无效的十六进制字符串";
return Bodh.convertToBinary(inputHex, Bodh.HEXADECIMAL_DIVIDE_BASE);
}
public static String hexToOctal(String inputHex) {
if (!Bodh.isLegalHex(inputHex))
return "无效的十六进制字符串";
return BinaryConversion.binaryToOctal(hexToBinary(inputHex));
}
public static String hexToDecimal(String inputHex) {
if (!Bodh.isLegalHex(inputHex))
return "无效的十六进制字符串";
return Bodh.convertToDecimal(inputHex, Bodh.HEXADECIMAL);
}
}
工具类
package io.programming.bodh;
import java.util.*;
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 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;
}
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);
}
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;
}
public static String cutZero(String str) {
int i = 0;
while (str.charAt(i) == '0') {
i++;
}
return str.substring(i);
}
public static String addZero(String str, int num) {
for (int i = str.length(); i < num; i++) {
str = "0" + str;
}
return str;
}
public static char toHexChar(int inputHex) {
return hexList.get(inputHex);
}
public static String hexToDec(String inputHex) {
return hexMap.get(inputHex);
}
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;
}
}