在Java中添加两个二进制字符串（包括填充）的有效方法？

我正在编写当两个二进制文件相加时返回二进制字符串的代码。 第一步是检查两个二进制字符串的长度是否相同，如果不相同，请在左侧用“0”填充它们；例如：

00101+011001

应给出

000101+011001

作为填充

我已经为这部分编写了代码。它工作得很好，但是想知道是否有有效的方法来达到同样的效果

public class Common{

    public static void main(String[] args){


                //calling the addBinary will only print the padded binaries correctly   
        String result=addBinary("00101", "001010");
    }


public static String addBinary(String binary1, String binary2){

               String result - "";

        char[] bin1= binary1.toCharArray();
        char[] bin2=binary2.toCharArray();
        int[] bin1int=null;
        int[] bin2int=null;



        System.out.println("---------------before-----------------");

        System.out.println(Arrays.toString(bin1));
        System.out.println(Arrays.toString(bin2));

        System.out.println("-----------------After---------------------");
        int bin1_len=bin1.length;
        int bin2_len=bin2.length;
        if (bin1_len<bin2_len){
            bin1int=new int[bin2_len];
            bin2int=new int[bin2_len];
            int j=bin2_len-bin1_len;
            for (char c: binary1.toCharArray()){    
                bin1int[j]=c-'0';
                j++;
                }   
        int k=0;
        for (char c: bin2 ){
            bin2int[k]=c-'0';
            k++;
        }
        }
        System.out.println(Arrays.toString(bin1int));
        System.out.println(Arrays.toString(bin2int));

        //if (bin2_len<bin1_len)
        //reverse implementation of above;

                //yet to implement the addition calculation.

        return result;

    }
}

公共类公共类{
公共静态void main（字符串[]args）{
//调用addBinary只能正确打印填充的二进制文件
字符串结果=addBinary（“00101”、“001010”）；
}
公共静态字符串addBinary（字符串binary1、字符串binary2）{
字符串结果-“”；
char[]bin1=binary1.toCharArray（）；
char[]bin2=binary2.toCharArray（）；
int[]bin1int=null；
int[]bin2int=null；
System.out.println（“--------------在----------之前”）；
System.out.println（Arrays.toString（bin1））；
System.out.println（Arrays.toString（bin2））；
System.out.println（“------------------------后-----------------”；
int bin1_len=bin1.length；
int bin2_len=bin2.length；
如果（bin1_len只需执行以下操作：

 // Read the binary string to integer and add the two together
 int total = Integer.parseInt(binary1, 2) + Integer.parseInt(binary2, 2);
 // Convert the resulting integer back to a binary string
 String str = new Integer(total).toBinaryString();

如果超过32位，则需要使用Long

如果您真的想填充字符串，只需查看这两个大小，然后将较短的一个填充为长的一个长度的零

String shorter, String longer;
if (binary1.length() < binary2.length) {
   shorter = binary1;
   longer = binary2;
} else {
   shorter = binary2;
   longer = binary1;
}
// Or any of the other multitude of ways to left pad a String.
shorter = org.apache.commons.lang.StringUtils.leftPad(smaller, larger.length(), '0')

字符串越短，字符串越长；
if（binary1.length（）
只要做：

 // Read the binary string to integer and add the two together
 int total = Integer.parseInt(binary1, 2) + Integer.parseInt(binary2, 2);
 // Convert the resulting integer back to a binary string
 String str = new Integer(total).toBinaryString();

如果超过32位，则需要使用Long

如果您真的想填充字符串，只需查看这两个大小，然后将较短的一个填充为长的一个长度的零

String shorter, String longer;
if (binary1.length() < binary2.length) {
   shorter = binary1;
   longer = binary2;
} else {
   shorter = binary2;
   longer = binary1;
}
// Or any of the other multitude of ways to left pad a String.
shorter = org.apache.commons.lang.StringUtils.leftPad(smaller, larger.length(), '0')

字符串越短，字符串越长；
if（binary1.length（）
只要做：

 // Read the binary string to integer and add the two together
 int total = Integer.parseInt(binary1, 2) + Integer.parseInt(binary2, 2);
 // Convert the resulting integer back to a binary string
 String str = new Integer(total).toBinaryString();

如果超过32位，则需要使用Long

如果您真的想填充字符串，只需查看这两个大小，然后将较短的一个填充为长的一个长度的零

String shorter, String longer;
if (binary1.length() < binary2.length) {
   shorter = binary1;
   longer = binary2;
} else {
   shorter = binary2;
   longer = binary1;
}
// Or any of the other multitude of ways to left pad a String.
shorter = org.apache.commons.lang.StringUtils.leftPad(smaller, larger.length(), '0')

字符串越短，字符串越长；
if（binary1.length（）
只要做：

 // Read the binary string to integer and add the two together
 int total = Integer.parseInt(binary1, 2) + Integer.parseInt(binary2, 2);
 // Convert the resulting integer back to a binary string
 String str = new Integer(total).toBinaryString();

如果超过32位，则需要使用Long

如果您真的想填充字符串，只需查看这两个大小，然后将较短的一个填充为长的一个长度的零

String shorter, String longer;
if (binary1.length() < binary2.length) {
   shorter = binary1;
   longer = binary2;
} else {
   shorter = binary2;
   longer = binary1;
}
// Or any of the other multitude of ways to left pad a String.
shorter = org.apache.commons.lang.StringUtils.leftPad(smaller, larger.length(), '0')

字符串越短，字符串越长；
if（binary1.length（）
如果您只是在寻找一种有效的pad方法，我认为下面的方法会更简单、更有效

    if (bin1_len<bin2_len){
        int j=bin2_len-bin1_len;
        StringBuilder s = new StringBuilder();
        for(int i = 0;i<j;i++){
            s.append('0');
        }
        s.append(binary1); //s now contains the 0 padded binary string
    }

if（bin1_len如果您只是在寻找一种有效的pad方法，我认为下面的方法会更简单、更有效

    if (bin1_len<bin2_len){
        int j=bin2_len-bin1_len;
        StringBuilder s = new StringBuilder();
        for(int i = 0;i<j;i++){
            s.append('0');
        }
        s.append(binary1); //s now contains the 0 padded binary string
    }

if（bin1_len如果您只是在寻找一种有效的pad方法，我认为下面的方法会更简单、更有效

    if (bin1_len<bin2_len){
        int j=bin2_len-bin1_len;
        StringBuilder s = new StringBuilder();
        for(int i = 0;i<j;i++){
            s.append('0');
        }
        s.append(binary1); //s now contains the 0 padded binary string
    }

if（bin1_len如果您只是在寻找一种有效的pad方法，我认为下面的方法会更简单、更有效

    if (bin1_len<bin2_len){
        int j=bin2_len-bin1_len;
        StringBuilder s = new StringBuilder();
        for(int i = 0;i<j;i++){
            s.append('0');
        }
        s.append(binary1); //s now contains the 0 padded binary string
    }

if（bin1_Len这个问题更适合。其中还有一个问题不是关于代码审查…@SotiriosDelimanolis:我不是要审查我的代码，而是要找出正确的方法来填充长度相等的字符串。@user1988876因为你的解决方案有效，这是一个正确的方法。
codereview
可以提出改进建议。这个问题stion更适合于。其中还有一个问题不是关于代码审查…@SotiriosDelimanolis:我不是要求审查我的代码，而是要找到正确的方法来等长填充字符串。@user1988876因为您的解决方案有效，所以这是一个正确的方法。
codereview
可以提出改进建议。这个问题更好适用于。其中还有一个问题与代码审查无关…@SotiriosDelimanolis:我不是要审查我的代码，而是要找出正确的方法来等长填充字符串。@user1988876因为您的解决方案有效，所以这是一个正确的方法。
codereview
可以提出改进建议。这个问题更适合于。在那里还有一个问题不是关于代码检查…@SotiriosDelimanolis:我不是要检查我的代码，而是要找出正确的方法来填充等长字符串。@user1988876既然你的解决方案有效，这是一个正确的方法。
codereview
可以提出改进建议。谢谢，我知道这个方法。但我对填充感兴趣用0表示长度相等。@user1988876不用担心，因为最低有效位仍然是最右边的一位，所以结果是相同的，有无填充…除非你更感兴趣的是两个数字，有填充的，而不是实际的和。为什么要用复杂的方式来做呢？即使你真的必须做加法self只需从右边扫描就可以了，但仍然不需要填充…谢谢，我知道这个方法。但是我对填充0感兴趣，这样我就可以