Java 二进制到十六进制

大家好，我已经实现了一个将值从二进制转换为十六进制的解决方案。所以我想知道是否有比我更优雅的解决方案（肯定有）。我已经测试了这个程序，它正在运行。代码如下：

public class BinaryToHex
{
    public static void main(String[] args) 
    {
        String binary = "1110001101";
        binaryToHex(binary);
        //38d
    }

    public static void binaryToHex(String binaryValue)
    {
        StringBuilder sb = new StringBuilder(binaryValue);

        System.out.println("Original StringBuilder: " + sb);
        sb.reverse();

        System.out.println("reversed StringBuilder: " + sb);

        int convert = binaryValue.length();
        System.out.println("Legth of the binary: " +  convert);

        if(convert % 4 != 0)
        {
            while(convert % 4 != 0)
            {


                sb.append(0);
                convert ++;

                System.out.println("StringBuilder in loop: " + sb);
                System.out.println("Convert in loop: " + convert);
            }
        }
        sb.reverse();
        System.out.println("Ready StringBuilder for use? " + sb);
        String test = null;
//      String test = sb.toString();
        for(int i=0; i<sb.length(); i ++)
        {
            if(i % 4 == 0)
            {
                test = sb.substring(i, (i+4));
                System.out.print(getChar(test));
            }
        }
    }

    public static String getChar(String num)
    {
        String number = "";
        switch(num)
        {
            case "0000" : number = "0"; break;
            case "0001" : number = "1"; break;
            case "0010" : number = "2"; break;
            case "0011" : number = "3"; break;
            case "0100" : number = "4"; break;
            case "0101" : number = "5"; break;
            case "0110" : number = "6"; break;
            case "0111" : number = "7"; break;
            case "1000" : number = "8"; break;
            case "1001" : number = "9"; break;
            case "1010" : number = "A"; break;
            case "1011" : number = "B"; break;
            case "1100" : number = "C"; break;
            case "1101" : number = "D"; break;
            case "1110" : number = "E"; break;
            case "1111" : number = "F"; break;

        }
        return number;
    }

}

公共类二进制十六进制
{
公共静态void main（字符串[]args）
{
字符串binary=“1110001101”；
二进制十六进制（二进制）；
//38d
}
公共静态void binaryToHex（字符串binaryValue）
{
StringBuilder sb=新的StringBuilder（二进制值）；
System.out.println（“原始StringBuilder:+sb”）；
使某人倒转；
System.out.println（“反向StringBuilder:+sb”）；
int convert=binaryValue.length（）；
System.out.println（“二进制长度：“+convert”）；
如果（转换为%4！=0）
{
while（转换为%4！=0）
{
某人追加（0）；
转换++；
System.out.println（“StringBuilder在循环中：“+sb”）；
System.out.println（“在循环中转换：“+Convert”）；
}
}
使某人倒转；
System.out.println（“StringBuilder是否准备好使用？”+sb）；
字符串测试=null；
//字符串测试=sb.toString（）；
对于（inti=0；i这个怎么样：
Integer.toHexString（Integer.valueOf（binary，2））
这个怎么样：
Integer.toHexString（Integer.valueOf（binary，2））

如果二进制字符串长度超过63位（
long
在Java中是有符号的）：

如果二进制字符串长度超过63位（
long
在Java中是有符号的）：

使用
Integer.toString（Integer.parseInt（binaryValue，2），16）；
？
使用
Integer.toString（Integer.parseInt（binaryValue，2），16）；
？
显然，为了简洁起见，我跳过了任何错误检查

int numInDec = Integer.parseInt(binaryString, 2);
String hexString = Integer.toHexString(numInDec);


编辑：我知道你想避开库，为什么？这是你正在寻找的“更优雅”的解决方案。
显然，为了简洁起见，我跳过了任何错误检查

int numInDec = Integer.parseInt(binaryString, 2);
String hexString = Integer.toHexString(numInDec);


编辑：我知道你想避开库，为什么？这是你正在寻找的“更优雅”的解决方案。
在库实现中做我们认为理所当然的事情是一个有趣的练习。
你可以通过使用计数器来跟踪你所在的位置并防止反向操作，从而大大改进你的算法。此外，开关块也相当不优雅

这是我的想法。我不是说它的性能很好，但我认为这是对你的建议的改进

public class BinToHex {

    static char[] HEX = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
    static int[] POW_2 = {1,2,4,8};
    public static String toHex(String bin) {
        int len = bin.length();
        char[] result = new char[(int)Math.ceil(len*1D/4)];
        int pos = result.length-1;
        int hexval = 0;
        for (int i=0; i<len;i++ ){
            hexval += (bin.charAt(len-i-1)-HEX[0]) * POW_2[i%4];
            if ((i+1)%4==0) {
                result[pos--] = HEX[hexval];
                hexval = 0;
            }
        }
        if (pos==0) {
            result[0] = HEX[hexval];
        }
        return new String(result);
    }

    public static void main(String [] param) {
        System.out.println(BinToHex.toHex("1")); // border case 1 char => 0x1
        System.out.println(BinToHex.toHex("101")); // testcase less than 4 chars => 0x5
        System.out.println(BinToHex.toHex("1011")); // testcase eq 4 chars => 0xB
        System.out.println(BinToHex.toHex("101101011011")); // testcase lenght % 4  = 0
        System.out.println(BinToHex.toHex("11101101011011")); // testcase lenght % 4  != 0
        System.out.println(BinToHex.toHex("000101101011011")); // testcase leading 0
    }

}

公共类BinToHex{
静态字符[]十六进制={0'，'1'，'2'，'3'，'4'，'5'，'6'，'7'，'8'，'9'，'A'，'B'，'C'，'D'，'E'，'F'}；
静态int[]POW_2={1,2,4,8}；
公共静态字符串toHex（字符串bin）{
int len=bin.length（）；
char[]result=new char[（int）Math.ceil（len*1D/4）]；
int pos=结果长度-1；
int-hexval=0；
对于（int i=0；i 0x1
System.out.println（BinToHex.toHex（“101”）；//测试用例小于4个字符=>0x5
System.out.println（BinToHex.toHex（“1011”）；//testcase eq 4 chars=>0xB
System.out.println（BinToHex.toHex（“101101011011”）；//测试用例长度%4=0
System.out.println（BinToHex.toHex（“11101101101101”）；//测试用例长度%4！=0
System.out.println（BinToHex.toHex（“0001011011”）；//测试用例前导0
}
}
在库实现中做我们认为理所当然的事情是一个有趣的练习。
你可以通过使用计数器来跟踪你所在的位置并防止反向操作，从而大大改进你的算法。此外，开关块也相当不优雅

这是我的想法。我不是说它的性能很好，但我认为这是对你的建议的改进

public class BinToHex {

    static char[] HEX = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
    static int[] POW_2 = {1,2,4,8};
    public static String toHex(String bin) {
        int len = bin.length();
        char[] result = new char[(int)Math.ceil(len*1D/4)];
        int pos = result.length-1;
        int hexval = 0;
        for (int i=0; i<len;i++ ){
            hexval += (bin.charAt(len-i-1)-HEX[0]) * POW_2[i%4];
            if ((i+1)%4==0) {
                result[pos--] = HEX[hexval];
                hexval = 0;
            }
        }
        if (pos==0) {
            result[0] = HEX[hexval];
        }
        return new String(result);
    }

    public static void main(String [] param) {
        System.out.println(BinToHex.toHex("1")); // border case 1 char => 0x1
        System.out.println(BinToHex.toHex("101")); // testcase less than 4 chars => 0x5
        System.out.println(BinToHex.toHex("1011")); // testcase eq 4 chars => 0xB
        System.out.println(BinToHex.toHex("101101011011")); // testcase lenght % 4  = 0
        System.out.println(BinToHex.toHex("11101101011011")); // testcase lenght % 4  != 0
        System.out.println(BinToHex.toHex("000101101011011")); // testcase leading 0
    }

}

公共类BinToHex{
静态字符[]十六进制={0'，'1'，'2'，'3'，'4'，'5'，'6'，'7'，'8'，'9'，'A'，'B'，'C'，'D'，'E'，'F'}；
静态int[]POW_2={1,2,4,8}；
公共静态字符串toHex（字符串bin）{
int len=bin.length（）；
char[]result=new char[（int）Math.ceil（len*1D/4）]；
int pos=结果长度-1；
int-hexval=0；
对于（int i=0；i 0x1
System.out.println（BinToHex.toHex（“101”）；//测试用例小于4个字符=>0x5
System.out.println（BinToHex.toHex（“1011”）；//testcase eq 4 chars=>0xB
System.out.println（BinToHex.toHex（“101101011011”）；//测试用例长度%4=0
System.out.println（BinToHex.toHex（“11101101101101”）；//测试用例长度%4！=0
System.out.println（BinToHex.toHex（“0001011011”）；//测试用例前导0
}
}
您是在寻找一个更优雅的实现，还是仅仅是一个实现同样功能的库函数？我知道解决这个问题的库函数，我想要的是一个更好的实现。您应该处理少于4个字符的二进制格式字符串。另外（和相关），而不是您的
switch
语句，“解析”将更优雅如果你不想转换成二进制和十六进制之间的整数，考虑把<代码>开关语句改为<代码> map < /COD>查找。这是家庭作业吗？如果是的话，你应该把它记下来。如果是作业，我会在完成后把它放在这里吗？为什么不？你没有给出任何东西。r解释为什么使用完全适合的库函数是不可接受的。您是在寻找一个更优雅的实现，还是仅仅是一个实现同样功能的库函数？我知道解决这个问题的库函数，我想要的是一个更好的实现。您应该处理少于4的二进制格式字符串另外，（和相关的），而不是你的代码>开关< /Cord>语句，它将更优雅地“解析”每一个IMO，并随着你的移动而移动。如果你不想转换成二进制和十六进制之间的整数，考虑把<代码>开关< /C> >语句改为<代码> map < /Cord>查找。这是家庭作业吗？如果是的话，你应该标记它。