Java 将十六进制字符串（十六进制）转换为二进制字符串

我找到了以下十六进制到二进制转换的方法：

String binAddr = Integer.toBinaryString(Integer.parseInt(hexAddr, 16)); 

虽然这种方法适用于小的十六进制数，但十六进制数如下

A14AA1DBDB818F9759

抛出一个

NumberFormatException。

因此，我编写了以下似乎有效的方法：

private String hexToBin(String hex){
    String bin = "";
    String binFragment = "";
    int iHex;
    hex = hex.trim();
    hex = hex.replaceFirst("0x", "");

    for(int i = 0; i < hex.length(); i++){
        iHex = Integer.parseInt(""+hex.charAt(i),16);
        binFragment = Integer.toBinaryString(iHex);

        while(binFragment.length() < 4){
            binFragment = "0" + binFragment;
        }
        bin += binFragment;
    }
    return bin;
}

私有字符串hexToBin（字符串hex）{
字符串bin=“”；
字符串binFragment=“”；
int iHex；
十六进制=十六进制修剪（）；
hex=hex.replaceFirst（“0x”，即“）；
对于（int i=0；i

上面的方法基本上接受十六进制字符串中的每个字符，并将其转换为二进制等效字符。如果需要，将其填充为零，然后将其与返回值联接。 这是执行转换的正确方式吗？还是我忽略了一些可能导致我的方法失败的东西

提前感谢您的帮助。

将为您提供所需的帮助。只需输入基数2

static String hexToBin(String s) {
  return new BigInteger(s, 16).toString(2);
}

将十六进制（字符串）解析为以16为基数的整数，然后使用toBinaryString（int）方法将其转换为二进制字符串

范例

int num = (Integer.parseInt("A2B", 16));
System.out.print(Integer.toBinaryString(num));

将打印

101000101011

int处理的最大十六进制值为FFFFFFF

i、 e.如果通过FFFFF 0，则ti将给出带有全零的错误

：

static String hexToBin(String s) {
    String preBin = new BigInteger(s, 16).toString(2);
    Integer length = preBin.length();
    if (length < 8) {
        for (int i = 0; i < 8 - length; i++) {
            preBin = "0" + preBin;
        }
    }
    return preBin;
}

静态字符串hexToBin（字符串s）{
字符串preBin=新的BigInteger（s，16）.toString（2）；
整数长度=preBin.length（）；
如果（长度<8）{
对于（int i=0；i<8-长度；i++）{
preBin=“0”+preBin；
}
}
返回预箱；
}

公共静态字节[]hexToBin（字符串str）
{
int len=str.length（）；
字节[]输出=新字节[len/2]；
int-endIndx；
对于（int i=0；ilen）
endIndx=len-1；
out[i/2]=（字节）Integer.parseInt（str.substring（i，endIndx），16）；
}
返回；
}

导入java.util.*；
公共类十六进制二进制
{
公共静态void main（）
{
扫描仪sc=新的扫描仪（System.in）；
System.out.println（“输入十六进制数”）；
字符串s=sc.nextLine（）；
字符串p=“”；
长n=0；
int c=0；
对于（int i=s.length（）-1；i>=0；i--）
{
如果（s.charAt（i）='A'）
{
n=n+（长）（数学功率（16，c）*10）；
C++；
}
如果（s.charAt（i）='B'）
{
n=n+（长）（数学功率（16，c）*11）；
C++；
}
如果（s.charAt（i）='C'）
{
n=n+（长）（数学功率（16，c）*12）；
C++；
}
如果（s.charAt（i）='D'）
{
n=n+（长）（数学功率（16，c）*13）；
C++；
}
如果（s.charAt（i）='E'）
{
n=n+（长）（数学功率（16，c）*14）；
C++；
}
如果（s.charAt（i）='F'）
{
n=n+（长）（数学功率（16，c）*15）；
C++；
}
其他的
{
n=n+（长）数学功率（16，c）*（长）s.charAt（i）；
C++；
}
}
字符串s1=“”，k=“”；
如果（n>1）
{
而（n>0）
{
如果（n%2==0）
{
k=k+“0”；
n=n/2；
}
其他的
{
k=k+“1”；
n=n/2；
}
}
对于（int i=0；i
publicstaticbyte[]hexToBytes（字符串）{
int length=string.length（）；
字节[]数据=新字节[长度/2]；
对于（int i=0；i数据[i/2]=（字节）（（Character.digit（string.charAt（i），16））快速，适用于大字符串：

    private String hexToBin(String hex){
        hex = hex.replaceAll("0", "0000");
        hex = hex.replaceAll("1", "0001");
        hex = hex.replaceAll("2", "0010");
        hex = hex.replaceAll("3", "0011");
        hex = hex.replaceAll("4", "0100");
        hex = hex.replaceAll("5", "0101");
        hex = hex.replaceAll("6", "0110");
        hex = hex.replaceAll("7", "0111");
        hex = hex.replaceAll("8", "1000");
        hex = hex.replaceAll("9", "1001");
        hex = hex.replaceAll("A", "1010");
        hex = hex.replaceAll("B", "1011");
        hex = hex.replaceAll("C", "1100");
        hex = hex.replaceAll("D", "1101");
        hex = hex.replaceAll("E", "1110");
        hex = hex.replaceAll("F", "1111");
        return hex;
    }

长时间的睡眠对你想要的东西不起作用吗？它还有tobinarysting（）的功能。这将支持…范围从-9223372036854775808到9223372036854775807。如果这符合您的要求，请让我知道，以便我可以作为答案发布。您的代码对我来说很好。您也可以查看以下链接：的确。这里唯一的问题是，数字太大，无法放入
int
。这就是问题所在，抱歉.Overflow是OP代码的问题，此解决方案解决了它。谢谢，这正是我所缺少的。不幸的是，toString（2）没有在8位的宽度上填充零：
String.format（“%8s”，Integer.toBinaryString（s））.replace（“'0'）；
public static byte[] hexToBin(String str)
    {
        int len = str.length();
        byte[] out = new byte[len / 2];
        int endIndx;

        for (int i = 0; i < len; i = i + 2)
        {
            endIndx = i + 2;
            if (endIndx > len)
                endIndx = len - 1;
            out[i / 2] = (byte) Integer.parseInt(str.substring(i, endIndx), 16);
        }
        return out;
    }

import java.util.*;
public class HexadeciamlToBinary
{
   public static void main()
   {
       Scanner sc=new Scanner(System.in);
       System.out.println("enter the hexadecimal number");
       String s=sc.nextLine();
       String p="";
       long n=0;
       int c=0;
       for(int i=s.length()-1;i>=0;i--)
       {
          if(s.charAt(i)=='A')
          {
             n=n+(long)(Math.pow(16,c)*10);
             c++;
          }
         else if(s.charAt(i)=='B')
         {
            n=n+(long)(Math.pow(16,c)*11);
            c++;
         }
        else if(s.charAt(i)=='C')
        {
            n=n+(long)(Math.pow(16,c)*12);
            c++;
        }
        else if(s.charAt(i)=='D')
        {
           n=n+(long)(Math.pow(16,c)*13);
           c++;
        }
        else if(s.charAt(i)=='E')
        {
            n=n+(long)(Math.pow(16,c)*14);
            c++;
        }
        else if(s.charAt(i)=='F')
        {
            n=n+(long)(Math.pow(16,c)*15);
            c++;
        }
        else
        {
            n=n+(long)Math.pow(16,c)*(long)s.charAt(i);
            c++;
        }
    }
    String s1="",k="";
    if(n>1)
    {
    while(n>0)
    {
        if(n%2==0)
        {
            k=k+"0";
            n=n/2;
        }
        else
        {
            k=k+"1";
            n=n/2;
        }
    }
    for(int i=0;i<k.length();i++)
    {
        s1=k.charAt(i)+s1;
    }
    System.out.println("The respective binary number is : "+s1);
    }
    else
    {
        System.out.println("The respective binary number is : "+n);
    }
  }
}

public static byte[] hexToBytes(String string) {
 int length = string.length();
 byte[] data = new byte[length / 2];
 for (int i = 0; i < length; i += 2) {
  data[i / 2] = (byte)((Character.digit(string.charAt(i), 16) << 4) + Character.digit(string.charAt(i + 1), 16));
 }
 return data;
}

    private String hexToBin(String hex){
        hex = hex.replaceAll("0", "0000");
        hex = hex.replaceAll("1", "0001");
        hex = hex.replaceAll("2", "0010");
        hex = hex.replaceAll("3", "0011");
        hex = hex.replaceAll("4", "0100");
        hex = hex.replaceAll("5", "0101");
        hex = hex.replaceAll("6", "0110");
        hex = hex.replaceAll("7", "0111");
        hex = hex.replaceAll("8", "1000");
        hex = hex.replaceAll("9", "1001");
        hex = hex.replaceAll("A", "1010");
        hex = hex.replaceAll("B", "1011");
        hex = hex.replaceAll("C", "1100");
        hex = hex.replaceAll("D", "1101");
        hex = hex.replaceAll("E", "1110");
        hex = hex.replaceAll("F", "1111");
        return hex;
    }