如何在java中添加任意长度的两个数字？

How to add two numbers of any length in java?

提问by Manoj

How to add two numbers of any length in java?

如何在java中添加任意长度的两个数字？

Say for example, in java long size is 64 bit. So the maximum range is -9223372036854775808 to 9223372036854775807. Am i right?

比如说，在 java 中 long size 是 64 位。所以最大范围是 -9223372036854775808 到 9223372036854775807。我说得对吗？

So if we want to add a number which is greater than this like below, i got a error

所以如果我们想添加一个比这个更大的数字，如下所示，我得到一个错误

" Integer Number too large"

“整数太大”

long a = 9223372036854775807L;
long b = 9223372036854775808L;

长 a = 9223372036854775807L；
长 b = 9223372036854775808L；

In C, we can take those numbers as char array, by traversing through the address of each char and use some data structure, we can add two numbers of any size.

在 C 中，我们可以将这些数字作为字符数组，通过遍历每个字符的地址并使用某种数据结构，我们可以将两个任意大小的数字相加。

How to do it java. Can we traverse through the address of each character in String.

如何做到这一点java. 我们可以遍历String中每个字符的地址吗？

---

---

Thanks for your responses.

感谢您的回复。

I have tried to code by passing the numbers as string and add each character from the end. It works fine for me.

我试图通过将数字作为字符串传递并从末尾添加每个字符来进行编码。这对我来说可以。

Is there any big difference between the addition of two very large numbers using BigInteger and the method, i specified above (add each character from end and store remainder in temporary variable and goes on). Is the underlying mechanism of BigInteger is same as my code(add each character from end)?

使用 BigInteger 将两个非常大的数字相加与我上面指定的方法（从末尾添加每个字符并将余数存储在临时变量中并继续）之间有什么大的区别。BigInteger 的底层机制是否与我的代码相同（从末尾添加每个字符）？

Thanks.

谢谢。

回答by Sam Day

Check out the BigIntegerclass. It will be able to perform the operations you are looking for on really large numbers.

看看BigInteger班级。它将能够在非常大的数字上执行您正在寻找的操作。

http://download.oracle.com/javase/1.4.2/docs/api/java/math/BigInteger.html

http://download.oracle.com/javase/1.4.2/docs/api/java/math/BigInteger.html

回答by Gopi

Use BigInteger. Hereis an example.

使用BigInteger。 这是一个例子。

Example code (based on above link) -

示例代码（基于上面的链接） -

BigInteger reallyBig1 = new BigInteger("1234567890123456890");
BigInteger reallyBig2 = new BigInteger("2743534343434361234");
reallyBig = reallyBig.add(reallyBig2);

回答by jjnguy

You can use a BigInteger.

您可以使用一个BigInteger.

BigInteger a = new BigInteger("9223372036854775807");
BigInteger b = new BigInteger("9223372036854775808");
BigInteger result = a.add(b);

The BigIntegerwill let you work with numbers of any size, but you lose a considerable amount of performance over longor int.

将BigInteger让你与任何尺寸的数字工作，但你失去了相当数量的性能long或int。

回答by SPIRiT_1984

The BigIntegerwill let you work with numbers of any size, but you lose a considerable amount of performance over longor int.

将BigInteger让你与任何尺寸的数字工作，但你失去了相当数量的性能long或int。

Actually, if you just need to run this operation once (user enters two numbers, and gets the result back), using BigIntegeris fine. But if you need to perform the addition operation many times, you could use really your own implementation of big integer. When I was competing in ACM matches, we often used our own implementations based on char arrays (in C++). I suggest the following code. It is assumed that there are two arrays of integers, A and B. A[0]and B[0]store the lens of the corresponding numbers. A[i]and B[i]stores the digits themselves. A[1]and B[1]are the least significant digits. Therefore the number 1234 would correspond to such an array: {4,4,3,2,1}.

其实，如果你只需要运行一次这个操作（用户输入两个数字，然后返回结果），使用BigInteger就可以了。但是如果你需要多次执行加法运算，你可以使用你自己的大整数实现。当我参加 ACM 比赛时，我们经常使用我们自己的基于字符数组的实现（在 C++ 中）。我建议使用以下代码。假设有两个整数数组，A和B。A [0]和B[0]存储对应数字的透镜。A[i]和B[i]存储数字本身。A[1]和B[1]是最低有效数字。因此，数字 1234 将对应于这样一个数组：{4,4,3,2,1}。

Now, suppose we want to sum these numbers and store them in array C in the same format. Here is an example of code, that you could use:

现在，假设我们要对这些数字求和并以相同的格式将它们存储在数组 C 中。这是您可以使用的代码示例：

int len1 = A[0],  len2 = B[0], divisor = 0;
int len = len1 >= len2 ? len1 : len2;
for (int i=1;i<=len;i++) {
  if (i>len1) C[i] = B[i]+divisor;
  else if (i>len2) C[i] = A[i]+divisor;
  else C[i] = A[i]+B[i]+divisor;
  divisor = C[i]/10;
  C[i] %= 10;
}
while (divisor>0) {
  C[++len] = divisor%10;
  divisor /= 10;
}
C[0] = len;

That code uses the simple rules of arithmetic addition and should work significantly faster than the BigIntegergeneral implementation. Have fun with using that.

该代码使用简单的算术加法规则，应该比BigInteger一般实现快得多。玩得开心。

回答by SPIRiT_1984

Is there any big difference between the addition of two very large numbers using BigInteger and the method, i specified above (add each character from end and store remainder in temporary variable and goes on).

使用 BigInteger 将两个非常大的数字相加与我上面指定的方法（从末尾添加每个字符并将余数存储在临时变量中并继续）之间有什么大的区别。

The difference is that you could use a larger radix, for example. Suppose the radix is 10000, not just 10. When the code of my previous answer would be modified like this:

例如，不同之处在于您可以使用更大的基数。假设基数是 10000，而不仅仅是 10。当我之前的答案的代码会像这样修改时：

int len1 = A[0],  len2 = B[0], divisor = 0;
int len = len1 >= len2 ? len1 : len2;

for (int i=1;i<=len;i++) {
  if (i>len1) C[i] = B[i]+divisor;
  else if (i>len2) C[i] = A[i]+divisor;
  else C[i] = A[i]+B[i]+divisor;
  divisor = C[i]/10000;
  C[i] %= 10000;
}
while (divisor>0) {
  C[++len] = divisor%10000;
  divisor /= 10000;
}
C[0] = len;

In that case the code runs 4 time faster (since there is no difference for the virtual machine in arithmetic operations, since they depend on the constant only). Also, this means, that the array of integers will be 4 times smaller. The only problem this causes is how to format the output.

在这种情况下，代码运行速度提高了 4 倍（因为虚拟机在算术运算中没有区别，因为它们仅依赖于常量）。此外，这意味着整数数组将小 4 倍。这导致的唯一问题是如何格式化输出。

回答by neethan

Create a stack class and get numbers as string from user and convert them into string and push them into stacks. Here I've written the full code for the addition of two large numbers. stack class also included. Just type in cmd javac mystack.java then java mystack

创建一个堆栈类并从用户处获取数字作为字符串并将它们转换为字符串并将它们推送到堆栈中。在这里，我编写了两个大数相加的完整代码。堆栈类也包括在内。只需输入 cmd javac mystack.java 然后输入 java mystack

import java.util.*;
public class mystack {
int maxsize=0;
int top=-1;
int array []=new int [0];


public mystack (int size)
{
    maxsize=size;
    array=new int [maxsize];
}

public void push (int x)
{   
    top=top+1;
    array[top]=x;
}

public int pop ()
{
    int elt=array[top];
    top--;
    return elt;

}

public boolean stackisfull()
{
    return(top==maxsize-1);
}

public boolean stackisempty()
{
    return(top==-1);
}

public int peak ()
{
    int peak =array[top];
    return peak;
}

public static void main (String args[]){
Scanner in=new Scanner (System.in);

System.out.println("Enter the 1st number");
String number1 = in.nextLine();
System.out.println();
System.out.println("Enter the 2nd number");
String number2 = in.nextLine();
System.out.println();

String temp="";




 if(number1.length()>number2.length())
 {
    temp=number1;
    number1=number2;
    number2=temp;
 }

    int k=0;


 mystack S1 = new mystack (number1.length());

      for(int i=0;i<number1.length();i++)
       {
            String str=Character.toString(number1.charAt(i));
            S1.push(Integer.parseInt(str));
       } 

 mystack S2 = new mystack (number2.length());

     for(int i=0;i<number2.length();i++)
        {
            String str=Character.toString(number2.charAt(i));
            S2.push(Integer.parseInt(str));
        } 

 mystack S3 =new mystack (number2.length());

 while(!S1.stackisempty())
 {
     int x=S1.pop();
     int y=S2.pop();

     int times=(x+y+k)/10; int remainder =(x+y+k)%10;
     k=0;

     if(times==0)
     {
        S3.push(remainder);
     }

     else
     {
         S3.push(remainder);
         k=1;
     }
 }
    while(!S2.stackisempty())
    {
        if(k==1)
        {
            S3.push(k+S2.pop());
            k=0; 
        }
       else
        S3.push(S2.pop());
    }

    System.out.print("Addition is ");

    while(!S3.stackisempty())
    {
        System.out.print(S3.pop());
    }

}
}

回答by Keshav Gera

    import java.math.BigInteger;
    import java.util.Scanner;

    public class BigIntergerSumExample {

        public static void main(String args[]) {

            BigInteger number1;
            BigInteger number2;
            BigInteger sum;
            Scanner sc = new Scanner(System.in);
            System.out.println("Enter the value of number 1");
            number1 = sc.nextBigInteger();
            System.out.println("Enter the value of number 2");
            number2 = sc.nextBigInteger();


            BigInteger a = new BigInteger(""+number1);
            BigInteger b = new BigInteger(""+number2);
            BigInteger result = a.add(b);

            System.out.println("Sum is Two numbers : -> " + result);
        }

    }

**OUTPUT IS** 

Enter the value of number 1
1111111111111111111111111111111111111111111111111
Enter the value of number 2
2222222222222222222222222222222222222222222222222
Sum is Two numbers : -> 
3333333333333333333333333333333333333333333333333

import java.math.BigInteger will let you work with numbers of any size,

import java.math.BigInteger 可以让你处理任意大小的数字，