基于Java的大整数运算的实现（加法，减法，乘法）学习笔记

大整数，顾名思义就是特别大的整数。

一台64位的机器最大能表示的数字是2的64次方减一：

18446744073709551615

java语言中所能表示的整数（int)最小为-2147483648

public class test {
    public static void main(String[] args) {
      System.out.println(Integer.MIN_VALUE);
    }
}

最大为

2147483647

public class test {
    public static void main(String[] args) {
      System.out.println(Integer.MAX_VALUE);
    }
}

而long所能表示的最大整数为

public class test {
    public static void main(String[] args) {
       System.out.println(Long.MAX_VALUE);
    }

}

9223372036854775807

最小为

public class test {

    public static void main(String[] args) {
       System.out.println(Long.MIN_VALUE);
    }

}

-9223372036854775808

如果超出了这些范围，就会报 out of range的错，所以java提供了BigInteger这个类来进行大整数的运算。其实实现BigInteger的原理也并不困难。下面是加法，减法已经乘法的实现。

类里面需要一个bignum属性

public class MyBigInteger {
  String bignum;
  public MyBigInteger(String bigone) {
       this.bignum = bigone;
}

加法：根据老师课上得指导，大概思路很简单，就是把大整数分成好几个段（每四个数字一段），然后对应的数字段进行加法。

例如12345678987654321与8765432123456789相加。那么将这两个数字分成

1   2345  6789  8765  4321

8765  4321  2345  6789   对应的和则为

2 1111   1111    1111  1110

（分组的主要思路是从后往前，每四个数字一组，到最前面的一组若不够四位数，则自成一组）

// 分块,在加法和减法里面用到
    private String[] getGroup(String number) {
        int length = (int) Math.ceil(number.length() / 4.0);
        String[] group = new String[length];
        for (int i = length; i > 0; i--) {// 注意，substring是从前往后截取字符，不是，从后往前截取字符
            if (number.length() - (length - i) * 4 - 4 < 0) {
                group[length - i] = number.substring(0, number.length() - (length - i) * 4);
            } else {
                group[length - i] = number.substring(number.length() - (length - i) * 4 - 4,
                        number.length() - (length - i) * 4);
            }
        }
        return group;
    }

其中，需要考虑到块与块之间的进位问题。因为每个对应的块相加，可以使用Integer.parseInt(...)转化成数字后相加，但是相应的块相加后可能会超出9999，这样就要向前面的块进位。这就要设置一个属性boolean[] fillThousand 。来判断是否需要进位，这个数组的长度应该比两个数分块后较长的那个块的长度多一（如上面两个数字分块后，块的长度分别是5和4，所以fillThousand的长度应该是6.)

如果，某一个对应块想加大于9999，那就把这个数减去10000（或者转化为字符串后从第二个字符开始截取），并且把前一个块的fillThousand属性变成true。

如果某一个块对于的fillThousand属性为true，则把这个对应块的和加1.。如果，最前面的那个块的fillThousand属性为true（这就是为什么把ffillThousand长度设置为6），则将总结果前面加一个”1“。

（此处，我是将长度较长的数当作第一个数字，注意，只是长度，在减法里，我会将绝对值较大的数当成第一个数）

private String addPN(String bigtwo) {
// 暂时无考虑负数
int a1 = (int) Math.ceil(bignum.length() / 4.0);
int a2 = (int) Math.ceil(bigtwo.length() / 4.0);
String[] group1 = new String[a1];
String[] group2 = new String[a2];

group1 = getGroup(bignum);
group2 = getGroup(bigtwo);

if (bigtwo.length() > bignum.length()) {// 将长的放到a1上
String[] temp = group1;
group1 = group2;
group2 = temp;
a1 = group1.length;
a2 = group2.length;
}
String addAll = "";
boolean[] fillThousand = new boolean[a1 + 1];// 每一块数字是否需要进位
for (int i = 0; i < a1; i++) {
if (i <= a2 - 1) {
Integer i1 = Integer.parseInt(group1[i]);
Integer i2 = Integer.parseInt(group2[i]);
Integer iall = i1 + i2;
if (fillThousand[i]) {
iall += 1;
}
if (iall > 9999 && i != a2 - 1) {
// iall=Integer.parseInt(iall.toString().substring(1,5));如是10000，则此方法不行。。0000=0
String subIall = iall.toString().substring(1, 5);
iall = Integer.parseInt(subIall);
fillThousand[i + 1] = true;
}
if (iall.toString().length() == 3 && i != a2 - 1) {
addAll = "0" + iall + addAll;
} else if (iall.toString().length() == 2 && i != a2 - 1) {
addAll = "00" + iall + addAll;
} else if (iall.toString().length() == 4 && i != a2 - 1) {
addAll = iall + addAll;
} else if (iall.toString().length() == 1 && i != a2 - 1) {
addAll = "000" + iall + addAll;
}
if (i == a2 - 1) {
if (iall > 9999) {
// iall=Integer.parseInt(iall.toString().substring(1,5));如是10000，则此方法不行。。0000=0
String subIall = iall.toString().substring(1, 5);
iall = Integer.parseInt(subIall);
fillThousand[i + 1] = true;
}
if (iall.toString().length() == 3) {
addAll = "0" + iall + addAll;
} else if (iall.toString().length() == 2) {
addAll = "00" + iall + addAll;
} else if (iall.toString().length() == 1) {
addAll = "000" + iall + addAll;// 保证最前面的数字不会多加0
} else if (iall.toString().length() == 4) {
addAll = iall + addAll;
} else if (a1 == a2) {
addAll = iall + addAll;
}
}
// 如果最前面的一块相加超过1000
if (fillThousand[a1]) {
addAll = "1" + addAll;
}
} else {
Integer iall = Integer.parseInt(group1[i]);
if (fillThousand[i]) {
iall += 1;
}
if (i == a1 - 1) {
addAll = iall + addAll;
}
if (iall.toString().length() == 3 && i != a1 - 1) {
addAll = "0" + iall + addAll;
} else if (iall.toString().length() == 2 && i != a1 - 1) {
addAll = "00" + iall + addAll;
} else if (iall.toString().length() == 1 && i != a1 - 1) {// iall是否超过1000
addAll = "000" + iall + addAll;// 保证最前面的数字不会多加0
} else if (iall.toString().length() == 1 && iall == 0 && i == a1 - 1) {
addAll = addAll;// 保证最前面的数字不会多加0
} else if (iall.toString().length() == 4 && i != a1 - 1) {
addAll = iall + addAll;
}

// 如果最前面的一块相加超过1000
if (fillThousand[a1]) {
addAll = "1" + addAll;
}
}
}
// 若不进行此步，则会出现000000000001这样的情况
if (addAll != "") {
if (addAll.charAt(0) == ‘0‘) {
int a = 0;
while (Integer.parseInt(addAll.substring(a, a + 1)) == 0) {
a += 1;
if (a == addAll.length()) {
break;
}
}
addAll = addAll.substring(a, addAll.length());
if (a == addAll.length()) {
addAll = "0";
}
}
} else {
addAll = "0";
}
return addAll;
}

　　

以上是，两个正整数进行加法运算时的代码，当然加法里面还会有负数相加。所以结合后来的，两个正整数的减法。可以得出加法的完整算法

public MyBigInteger add(MyBigInteger bigtwo) {

String returnNum=null;

if (!(this.bignum.charAt(0) == ‘-‘) && !(bigtwo.bignum.charAt(0) == ‘-‘)) {
returnNum = addPN(bigtwo.bignum);
} else if (this.bignum.charAt(0) == ‘-‘ && !(bigtwo.bignum.charAt(0) == ‘-‘)) {
bignum = bignum.substring(1, bignum.length());
if (substractPN(bigtwo.bignum).charAt(0) == ‘-‘) {
returnNum = substractPN(bigtwo.bignum).substring(1, substractPN(bigtwo.bignum).length());
} else {
returnNum = "-" + substractPN(bigtwo.bignum);
}
} else if (!(this.bignum.charAt(0) == ‘-‘) && bigtwo.bignum.charAt(0) == ‘-‘) {
bigtwo.bignum = bigtwo.bignum.substring(1, bigtwo.bignum.length());
returnNum = substractPN(bigtwo.bignum);
} else// 两个都是负数
{
bignum = bignum.substring(1, bignum.length());
bigtwo.bignum = bigtwo.bignum.substring(1, bigtwo.bignum.length());
returnNum = "-" + addPN(bigtwo.bignum);
}
return new MyBigInteger(returnNum);
}

　　

减法：

减法的算法比加法的算法要复杂一些，因为减法不仅要考虑借位还要考虑正负。

还是先进行两个整数的减法运算

首先还是分组.......

然后将大的数当成被减数

减法里面要设置两个大属性，一个是boolean reverse，这个意味着，如果是第一个数字小于第二个数字，那就交换两个的位置，然后在结果前面加上”-“。

private String substractPN(String bigtwo) {
// 暂时无考虑负数
int a1 = (int) Math.ceil(bignum.length() / 4.0);
int a2 = (int) Math.ceil(bigtwo.length() / 4.0);
String[] group1 = new String[a1];
String[] group2 = new String[a2];
group1 = getGroup(bignum);
group2 = getGroup(bigtwo);
boolean reverse = false;// 判断是否是一个小数字减去一个大数字，若是，则交换两个的位置，并在最后加一个负号

boolean oneMoreTwo = true;// 位数相同，比较大小
if (bigtwo.length() == bignum.length()) {
// 如果两个数长度相等，比较前两段数字的大小
if (Integer.parseInt(group2[a1 - 1]) > Integer.parseInt(group1[a1 - 1])) {
oneMoreTwo = false;
}
if ((Integer.parseInt(group2[a1 - 1]) == Integer.parseInt(group1[a1 - 1]))
&& (Integer.parseInt(group2[a1 - 2]) > Integer.parseInt(group1[a1 - 2]))) {
oneMoreTwo = false;
}
}
if (bigtwo.length() > bignum.length() || !oneMoreTwo) {// 将长的数放到a1上
String[] temp = group1;
group1 = group2;
group2 = temp;
a1 = group1.length;
a2 = group2.length;
reverse = true;
}

//。。。。。。。。。。。。
//。。。。。。。。。。。。
//。。。。。。。。。。。。

//这是最后的两行，中间省略若干代码
          if (reverse) {
             substractAll = "-" + substractAll;
          }

　　

另外一个boolean[] borrowone，是否借位，和加法的fillThousand属性类似。如果一个对应块相减后结果小于0，那就把这个结果加10000，然后相前一个块借1。然后将前一个块的borrowone设置为true。

若一个块的borrowone属性为true则将这个块的结果减1.

boolean[] borrowone = new boolean[a1 + 1];// 判断是否需要借位
String substractAll = "";
for (int i = 0; i < a1; i++) {
if (i <= a2 - 1) {
Integer i1 = Integer.parseInt(group1[i]);
Integer i2 = Integer.parseInt(group2[i]);
Integer isubstract = i1 - i2;// 处理isubstract是0000的情况
if (borrowone[i]) {
isubstract -= 1;
}
if (isubstract < 0) {
isubstract = isubstract + 10000;// 判断位数
borrowone[i + 1] = true;
if (isubstract > 0 && isubstract.toString().length() == 3) {
substractAll = "0" + isubstract + substractAll;
} else if (isubstract > 0 && isubstract.toString().length() == 2) {
substractAll = "00" + isubstract + substractAll;
} else if (isubstract > 0 && isubstract.toString().length() == 1) {
substractAll = "000" + isubstract + substractAll;
} else if (isubstract > 0 && isubstract.toString().length() == 4) {
substractAll = isubstract + substractAll;
} else if (isubstract == 0) {
substractAll = "0000" + substractAll;
}
} else if (isubstract > 0 && isubstract.toString().length() == 3) {
substractAll = "0" + isubstract + substractAll;
} else if (isubstract > 0 && isubstract.toString().length() == 2) {
substractAll = "00" + isubstract + substractAll;
} else if (isubstract > 0 && isubstract.toString().length() == 1) {
substractAll = "000" + isubstract + substractAll;
} else if (isubstract > 0 && isubstract.toString().length() == 4) {
substractAll = isubstract + substractAll;
} else if (isubstract == 0) {
substractAll = "0000" + substractAll;
}
} else {
Integer isubstract = Integer.parseInt(group1[i]);
if (borrowone[i]) {
isubstract -= 1;
}
if (i == a1 - 1) {
substractAll = isubstract + substractAll;
}
if (isubstract > 0 && isubstract.toString().length() == 3 && i != a1 - 1) {
substractAll = "0" + isubstract + substractAll;
} else if (isubstract > 0 && isubstract.toString().length() == 2 && i != a1 - 1) {
substractAll = "00" + isubstract + substractAll;
} else if (isubstract > 0 && isubstract.toString().length() == 1 && i != a1 - 1) {
substractAll = "000" + isubstract + substractAll;
} else if (isubstract > 0 && isubstract.toString().length() == 4 && i != a1 - 1) {
substractAll = isubstract + substractAll;
} else if (isubstract == 0) {
substractAll = "0000" + substractAll;
}
}
}

　　

当然，减法，还要处理一下000001这类情况

// 若不进行此步，则会出现000000000001这样的情况

if (Integer.parseInt(substractAll.substring(0, 1)) == 0) {
int a = 0;
while (Integer.parseInt(substractAll.substring(a, a + 1)) == 0) {
a += 1;
}
substractAll = substractAll.substring(a, substractAll.length());
}

以上是正数减法的实现，结合加法，则可以实现完整的减法

public MyBigInteger substract(MyBigInteger bigtwo) {
// 只能用equals不能用==

String returnNum=null;

if (!(this.bignum.charAt(0) == ‘-‘) && !(bigtwo.bignum.charAt(0) == ‘-‘)) {

returnNum = substractPN(bigtwo.bignum);
} else if (this.bignum.charAt(0) == ‘-‘ && !(bigtwo.bignum.charAt(0) == ‘-‘)) {
bignum = bignum.substring(1, bignum.length());
returnNum = "-" + addPN(bigtwo.bignum);

} else if (!(this.bignum.charAt(0) == ‘-‘) && bigtwo.bignum.charAt(0) == ‘-‘) {
bigtwo.bignum = bigtwo.bignum.substring(1, bigtwo.bignum.length());
returnNum = addPN(bigtwo.bignum);
} else {// 两个都是负数
bignum = bignum.substring(1, bignum.length());
bigtwo.bignum = bigtwo.bignum.substring(1, bigtwo.bignum.length());
if (substractPN(bigtwo.bignum).charAt(0) == ‘-‘) {

returnNum = substractPN(bigtwo.bignum).substring(1, substractPN(bigtwo.bignum).length());
} else {
returnNum = "-" + substractPN(bigtwo.bignum);
}

}

return new MyBigInteger(returnNum);
}

乘法：

乘法的算法思想比较简单。我采用的逐位相乘的思路，即两个数下标和相同的数字相乘之后相加。然后最后的和作为结果对对应的位数。即∑Ai(A的i位）*Bz-i(B的z-i位) = Cz

若Cz大于十，则保留其个位数，并且向Cz+1进位，进的位数为Cz十位以上的数字，例如Cz=123，则向前进十二位。

	public MyBigInteger multiply(MyBigInteger bigtwo) {
                String returnNum=null;
		boolean positive = false;
		if ((bigtwo.bignum.charAt(0) == ‘-‘ && this.bignum.charAt(0) == ‘-‘)
				|| (!(bigtwo.bignum.charAt(0) == ‘-‘) && !(this.bignum.charAt(0) == ‘-‘))) {
			positive = true;
		}
		if (bigtwo.bignum.charAt(0) == ‘-‘) {
			bigtwo.bignum = bigtwo.bignum.substring(1);
		}
		if (this.bignum.charAt(0) == ‘-‘) {
			this.bignum =this.bignum.substring(1);
		}
		int a = this.bignum.length();
		int b = bigtwo.bignum.length();
		String[] s1 = new String[a];
		String[] s2 = new String[b];
		int[] mulAll = new int[a + b - 1];
		for (int i = 0; i < a; i++) {
			s1[a - i - 1] = this.bignum.substring(i, i + 1);
		}
		for (int i = 0; i < b; i++) {
			s2[b - i - 1] = bigtwo.bignum.substring(i, i + 1);
		}
		if (a < b) {
			int temp = a;
			a = b;
			b = temp;
			String[] stemp = s1;
			s1 = s2;
			s2 = stemp;
		}
		for (int i = 0; i < a; i++) {
			for (int j = 0; j < b; j++) {
				mulAll[i + j] +=Integer.parseInt(s1[i]) * Integer.parseInt(s2[j]);
			}
		}
		for (int i = 0; i < mulAll.length - 1; i++) {
			if (mulAll[i] > 9) {
				while (mulAll[i] > 9) {
					mulAll[i] -=10;
					mulAll[i + 1] += 1;
				}
			}
		}
		returnNum = "";
		for (int i = mulAll.length - 1; i >= 0; i--) {
			returnNum = returnNum + mulAll[i];
		}
		if (positive) {
			return new MyBigInteger2(returnNum);
		} else {
			returnNum = "-" + returnNum;
			return new MyBigInteger(returnNum);
		}
	}

　　小弟不才，以上是本人根据大整数的处理思路写出来的代码，其中需要优化的地方很多，需要不断修改。

时间： 2024-10-06 03:20:00

基于Java的大整数运算的实现（加法，减法，乘法）学习笔记的相关文章

大整数运算

对于A,B的范围在int范围内,求解A与B的加减乘除运算我相信大家很快就可以写出程序来,但是如果A,B是有着1000个数位的整数呢?恐怕就没有已有的数据类型来表示了,这时候只能老实的模拟加减乘除运算的过程.模拟加减乘除的运算的过程,原理就是小学的. 大整数又称为高精度整数,其含义就是用基本的数据类型无法存储其精度的整数.大整数运算即高精度运算. 首先,介绍大整数的存储. 很简单,用数组即可.例如,int型数组d[1000]:如将123456存储到数组中,则有d[0]=6,d[1]=5......

大整数运算模板总结

大整数运算模板总结. 大整数结构体表示 整型数组从低位到高位顺序存储每一位数字,另外需要存储数字的长度. struct bign { int d[1000]; int len; bign(){ memset(d, 0, sizeof(d)); len = 0; } }; 大整数输入 一般通过字符串输入. bign Change(string str)//输入字符串转大整数 { bign a; a.len = str.length(); for (int i = 0; i < a.len; i++

用Java的大整数类Integer来实现大整数的一些运算

import java.io.*; import java.util.*; import java.math.*; public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); BigInteger a, b; while(sc.hasNext()) { a = sc.nextBigInteger(); b = sc.nextBigInteger(); Syste

Java 实现大整数加减乘除

自己用Java实现的大整数加减乘除运算.还有可以改进的地方,有兴趣的童鞋可以加以改进.仅供参考,请勿转载! package barrytest; import java.util.ArrayList;import java.util.List;import java.util.regex.Matcher;import java.util.regex.Pattern; //@author Barry Wang// all the four method have not considered th

大整数运算---模拟笔算

/* *m=a[k]×10k-1+a[k-1]×10k-2+-.+a[2]×10+a[1] *其中a[0]保存该长整数的位数. * *模拟笔算 */ #include<iostream> #include<cstring> using namespace std; #define SIZE 255 void getl(char* n);//获取长整数 void prt(char* n);//打印长整数 int cmp(char* n1, char* n2);//比较长整数大小 vo

大整数运算C++1

//下面的代码勉强算是bignum_beta1版本! //实现了大整数的加减乘除四则运算,以及求两个整数的最大公约数,以及求乘法逆,miller_rabin素性检验,平方_乘法算法 //不足之处,位数还很难扩展至几千位,以及运算速度有一点慢,既然是beta1,说明bug还是挺多的 //程序缺少测试数据来测试,所以有的结果不敢保证其正确性 //由于使用c++复写了很多运算符,加入这个文件之后,大数bignum可以看做是一个如同如同int一样的基本类型 //可以像int一样加减乘除和输入输出 #in

大整数运算C++

//下面的代码勉强算是bignum_beta1版本! //实现了大整数的加减乘除四则运算,以及求两个整数的最大公约数,以及求乘法逆,miller_rabin素性检验,平方_乘法算法 //不足之处,位数还很难扩展至几千位,以及运算速度有一点慢,既然是beta1,说明bug还是挺多的 //程序缺少测试数据来测试,所以有的结果不敢保证其正确性 //由于使用c++复写了很多运算符,加入这个文件之后,大数bignum可以看做是一个如同如同int一样的基本类型 //可以像int一样加减乘除和输入输出 #in

算法学习——大整数运算（高精度）C++

1.大整数加法 用数组来存储大整数的每一位,然后模拟人工运算,用for循环按位运算和处理,原理十分简单,直接上模板. #include<iostream> #include<vector> using namespace std; //大整数加法 vector<int> add(vector<int>& A,vector<int>& B){ vector<int> C; int t = 0; for(int i = 0

Java多线程之JUC包：ReentrantReadWriteLock源码学习笔记

若有不正之处请多多谅解,并欢迎批评指正. 请尊重作者劳动成果,转载请标明原文链接: http://www.cnblogs.com/go2sea/p/5634701.html ReentrantLock提供了标准的互斥操作,但在应用中,我们对一个资源的访问有两种方式:读和写,读操作一般不会影响数据的一致性问题.但如果我们使用ReentrantLock,则在需要在读操作的时候也独占锁,这会导致并发效率大大降低.JUC包提供了读写锁ReentrantReadWriteLock,使得读写锁分离,在上述情