java练习_大数运算_BigInteger

合集下载

java 实验常用实用类上级实践实验4处理大整数

java 实验常用实用类上级实践实验4处理大整数

java 实验常用实用类上级实践8实验4处理大整数处理大整数的常用实用类是BigInteger类。

BigInteger类是Java中处理任意长度整数的类,可以进行大整数的加减乘除、取模、幂运算等操作。

以下是处理大整数的常用实践:1. 创建BigInteger对象:javaBigInteger num1 = new BigInteger("123456789"); BigInteger num2 = BigInteger.valueOf(987654321);2. 进行加法操作:javaBigInteger sum = num1.add(num2);3. 进行减法操作:javaBigInteger difference = num1.subtract(num2);4. 进行乘法操作:javaBigInteger product = num1.multiply(num2);5. 进行除法操作:javaBigInteger quotient = num1.divide(num2);6. 进行取模操作:javaBigInteger remainder = num1.remainder(num2);7. 进行幂运算:javaBigInteger power = num1.pow(2);8. 比较两个大整数的大小:javaint compareResult = pareTo(num2);// compareResult < 0,num1小于num2// compareResult = 0,num1等于num2// compareResult > 0,num1大于num29. 将大整数转换为字符串:javaString numStr = num1.toString();10. 将字符串转换为大整数:javaBigInteger num = new BigInteger("123456789");这些是处理大整数的常用实践,可以根据具体需求选择适合的操作进行处理。

java编程基础练习题

java编程基础练习题

java编程基础练习题Java是一种面向对象的编程语言,具有跨平台特性,被广泛应用于开发各种应用程序。

对于初学者来说,掌握Java编程基础是非常重要的。

在本文中,我将为您提供一些Java编程基础练习题,帮助您巩固和提升自己的编程技能。

练习一:Hello, Java!创建一个Java类,命名为HelloJava,编写一个main方法,在该方法中打印输出"Hello, Java!"。

运行该程序,确保输出结果与期望一致。

练习二:变量和数据类型创建一个Java类,命名为Variables,编写一个main方法。

在该方法中,完成以下任务:1. 声明一个整型变量age,并赋值为182. 声明一个浮点型变量height,并赋值为1.753. 声明一个布尔型变量isMale,并赋值为true4. 声明一个字符型变量initial,并赋值为'A'5. 声明一个字符串型变量name,并赋值为"Tom"6. 打印输出上述变量的值运行该程序,确保输出结果与期望一致。

练习三:数学运算创建一个Java类,命名为MathOperations,编写一个main方法。

在该方法中,完成以下任务:1. 声明两个整型变量a和b,并分别赋值为10和52. 分别使用加法、减法、乘法、除法、取余运算对a和b进行运算,并打印输出结果运行该程序,确保输出结果与期望一致。

练习四:条件语句创建一个Java类,命名为Conditions,编写一个main方法。

在该方法中,完成以下任务:1. 声明一个整型变量score,并赋值为852. 使用条件语句判断score的等级,将结果存储在一个字符串变量grade中。

具体规则如下:- 当score大于等于90时,grade为"A"- 当score大于等于80且小于90时,grade为"B"- 当score大于等于70且小于80时,grade为"C"- 当score大于等于60且小于70时,grade为"D"- 当score小于60时,grade为"E"3. 打印输出grade的值运行该程序,确保输出结果与期望一致。

计算两个大整数的差(Java)

计算两个大整数的差(Java)

计算两个大整数的差(Java)在Java中计算两个大整数的差可以使用BigInteger类。

BigInteger是Java中的一个内置类,用于处理任意大小的整数。

它提供了一系列方法,可以执行加减乘除等操作。

要计算两个大整数的差,首先需要创建两个BigInteger对象,分别表示这两个大整数。

然后,使用subtract()方法执行减法操作,得到它们的差。

最后,使用toString()方法将结果转换为字符串。

下面是一个示例程序,演示了如何计算两个大整数的差:```javaimport java.math.BigInteger;public class BigIntegerSubtraction {public static void main(String[] args) {//创建两个大整数BigInteger num1 = new BigInteger("12345678901234567890");BigInteger num2 = new BigInteger("98765432109876543210");//计算它们的差BigInteger difference = num1.subtract(num2);//打印结果System.out.println("Difference: " +difference.toString());}}```在上面的示例中,我们创建了两个BigInteger对象`num1`和`num2`,分别表示两个大整数。

然后,我们使用subtract()方法计算它们的差,并将结果赋值给一个新的BigInteger对象`difference`。

最后,我们使用toString()方法将结果转换为字符串,并打印出来。

编译并运行上面的示例程序,输出结果为:```Difference: -86419753208641975320```这是因为`num1`减去了`num2`,所以结果是一个负数。

biginteger构造方法

biginteger构造方法

Java 中 BigInteger 构造方法及其使用在 Java 中,BigInteger 类是一个用于表示大型整数的类。

它支持任意精度的整数,可以准确地表示任何大小的整数值而不会丢失任何信息。

Java 中的 BigInteger 构造方法是用于创建大型整数对象的方法。

BigInteger 构造方法有两个版本:public BigInteger(int val) 和 public BigInteger(long val)。

其中,第一个版本接受一个整数作为参数,用于创建大型整数对象。

第二个版本接受一个长整数作为参数,用于创建大型整数对象。

使用 BigInteger 构造方法创建大型整数对象时,可以传递任意整数作为参数。

例如,可以使用以下代码创建一个包含 10000 位的BigInteger 对象:```BigInteger bigInt = newBigInteger("1234567890123456789012345678901234567890");```BigInteger 构造方法支持使用小数点来表示整数的精度。

例如,可以使用以下代码创建一个包含 10 位小数的 BigInteger 对象:```BigInteger bigInt = newBigInteger("1.234567890123456789012345678901234567890");```在使用 BigInteger 构造方法创建大型整数对象时,需要注意位数的限制。

Java 中的 BigInteger 对象支持的位数取决于参数的大小。

例如,上面的代码中,使用的整数值为 10000 位,但是如果使用的整数值为 10 位,则 BigInteger 对象只支持到 9 位。

除了使用 BigInteger 构造方法创建大型整数对象之外,还可以使用 BigInteger 类的方法和属性来操作大型整数对象。

java biginter的值由mag数组的计算方法

java biginter的值由mag数组的计算方法

java biginter的值由mag数组的计算方法计算java BigInteger的值的方法简介在Java中,BigInteger是一个用于处理大整数的类,可以进行大数的运算。

它提供了多种方式来计算BigInteger的值,本文将详细介绍这些方法。

方法一:使用BigInteger的构造方法BigInteger提供了多个构造方法,可以直接传入一个字符串、一个long类型的参数、一个byte数组等来创建BigInteger对象。

在这些构造方法中,最常用的是使用字符串创建BigInteger对象的方法。

String value = "90";BigInteger bigInteger = new BigInteger(value);这样就可以使用字符串中的数值来创建一个BigInteger对象。

方法二:使用add、subtract、multiply和divide方法BigInteger还提供了四个基本的运算方法:add、subtract、multiply和divide。

这些方法用于进行加法、减法、乘法和除法运算。

BigInteger num1 = new BigInteger("123");BigInteger num2 = new BigInteger("456");BigInteger sum = (num2); // 加法BigInteger difference = (num2); // 减法BigInteger product = (num2); // 乘法BigInteger quotient = (num2); // 除法使用这些方法,可以方便地进行BigInteger的运算。

方法三:使用pow方法BigInteger的pow方法可以用于计算一个BigInteger对象的幂。

它接受一个int类型的参数,表示指数。

BigInteger base = new BigInteger("2");int exponent = 10;BigInteger result = (exponent);上述代码将计算2的10次方,并将结果存储在result中。

大数加法java

大数加法java

大数加法java在程序设计中,大数加法是指两个大整数相加的计算方法。

由于计算机内部表示整数的位数有限,因此需要使用特殊的算法来处理超出位数限制的大整数加法,这就是大数加法。

在Java语言中,实现大数加法主要有两种方法:传统的高精度算法和Java的BigInteger类。

这里我们分别介绍这两种方法的实现步骤。

1. 传统的高精度算法传统的高精度算法是基于进制推理方式实现的。

具体步骤如下:(1)将两个大整数按位进行相加,若相加和不大于进位数(10或16),则将和存储在结果数组中;若相加和大于进位数,则将进位存储在下一位相加中。

(2)处理完较短的整数后,将剩余的高位数处理完,并存储在结果数组中。

如果最高位相加后进位,则需要将进位存储在数组的下一位中。

(3)将结果数组转换成字符串输出即可。

这种方法常常使用在竞赛编程中,由于它的计算过程比较简单,性能也比较高。

但对于大数相加,速度仍然比BigInteger类慢。

2. Java的BigInteger类Java的BigInteger类是一个高精度整数类,它支持任意精度的整数计算。

它的实现方式是采用分块存储的方式,每块存储一个固定位数的整数。

具体步骤如下:(1)通过BigInteger类对输入的两个大整数进行初始化。

(2)调用add方法,将两个BigInteger对象相加。

(3)调用toString方法,将结果对象转换为字符串输出。

这种方法的特点是简单、方便、精度高,但是计算过程速度略慢于高精度算法。

综上所述,两种实现大数加法的方式各有优缺点。

在实际开发中,应该根据具体需求和运算量的大小选择合适的方法。

如果只是简单的大数相加,可以使用传统的高精度算法;如果需要高精度运算,并且运算量大,可以使用Java的BigInteger类。

RSA算法java实现(BigInteger类的各种应用)

RSA算法java实现(BigInteger类的各种应用)

RSA算法java实现(BigInteger类的各种应⽤)⼀、RSA算法1.密钥⽣成随机⽣成两个⼤素数p、q计算n=p*q计算n的欧拉函数f=(p-1)*(q-1)选取1<e<f,使e与f互素计算d,ed=1modf公钥为(e,n),私钥为(d,n)2.加密c=m^e mod n3.解密m=c^e mod n⼆、BigInteger类(⼤数)定义:BigInteger b=new BigInteger("1");将其他类型变量转化为BigInteger变量BigInteger b=BigInteger.valueof(1);随机⽣成⼤素数BigInteger bigInteger = BigInteger.probablePrime(2048, r); //随机⽣成2048位的⼤素数,r为Random变量素性检验(⽶勒罗宾检验)boolean a = b.isProbablePrime(256); //b是素数的概率为1 - 1 / 2^256四则运算BigInteger a,b,c;c=a.add(b); //加c=a.subtract(b); //减c=a.multiply(b); //乘c=a.divide(b); //除最⼤公因⼦BigInteger a,b,c;c=a.gcd(b);取余BigInteger a,b,c;c=a.remainder(b);次⽅模(a^b mod m)BigInteger a,b,c;c=a.modPow(b,m);三、算法实现1.两个⼤素数的⽣成构建Big类,随机⽣成⼤素数,并进⾏素性检验2.公钥⽣成寻找与f互素的公钥e(1<e<f)3.私钥⽣成利⽤欧⼏⾥得算法(辗转相除法),列表,计算e模f的逆d在Keys类中将公钥、私钥输出到⽂件5.加密(1)从⽂件逐⾏读取明⽂、公钥(2)使⽤getByte()将明⽂转化为byte数组(3)依次计算c=m^e mod n (4)将结果逐⾏输出到⽂件6.解密(1)从⽂件逐⾏读取密⽂、私钥(2)读⼊密⽂的同时计算m=c^d mod n,并将其存⼊byte数组(3)将byte数组还原为字符串(明⽂)(4)输出明⽂到⽂件四、遇到的问题和解决⽅法问题1:加密时不知道如何将明⽂转化为可⽤于加密的数字解决1:纠结了好久,想到看书时看到过的getByte()⽅法可以将字符串转化为byte数组问题2:解密时,出现了以下问题解决2:这个错误还没法调试,检查了好久,发现⾃⼰计算公钥e的时候模的是n,修改了成模f后,解决了该问题问题3:之后,解密出来的⽂件还是有问题解决3:调试后,发现⾃⼰犯了很蠢的错误,我把int i=0放在了while 循环⾥,每次循环都会把i置1...问题4:然后,输出还是有问题,后⾯会多⼀些空格解决4:增加⼀个与明⽂长度等长的byte数组成功~~五、码云链接。

java实现超大整数加减乘除四则运算

java实现超大整数加减乘除四则运算

java实现超⼤整数加减乘除四则运算原理:⽤数组存储数字,按照计算法则进⾏运算。

代码:package com.hdwang;import java.util.regex.Matcher;import java.util.regex.Pattern;/*** ⼤数四则运算(超出long型的⼤数(64位:18446744073709551615))* Created by hdwang on 2017/10/9.*/public class Calculator {/*** 两数相加* @param numStr1 数1* @param numStr2 数2* @return结果*/public static String add(String numStr1, String numStr2){int numLen1 = numStr1.length();int numLen2 = numStr2.length();int[] numArray1 = new int[numLen1]; //数字数组int[] numArray2 = new int[numLen2];// "12345"-> [5,4,3,2,1]for(int i=0;i<numLen1;i++){String c = numStr1.substring(i,i+1);numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}for(int i=0;i<numLen2;i++){String c = numStr2.substring(i,i+1);numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}int minLen = 0; //取长度⼩的数位数int maxLen = 0; //取长度⼤的数位数int[] maxArray = null; //长度⼤的数if(numLen1<numLen2){minLen = numLen1;maxLen = numLen2;maxArray = numArray2;}else{minLen = numLen2;maxLen = numLen1;maxArray = numArray1;}int[] resultArray = new int[maxLen+1]; //考虑到可能会进位,多给⼀个元素空间//两数长度相同的部分,同位相加,超出9进1int added = 0;int i=0;for(;i<minLen;i++){int t = numArray1[i]+numArray2[i]+added; //两数相加,再加进位if(t>9){added = 1; //进1resultArray[i] = t-10; //当前位计算结果}else{added = 0; //不进位resultArray[i] = t; //当前位计算结果}}//长度超出部分累加for(;i<maxLen;i++){int t = maxArray[i]+added; //多余位数加上进位if(t>9){added = 1; //进1resultArray[i] = t-10; //当前位计算结果}else{added = 0; //不进位resultArray[i] = t; //当前位计算结果}}resultArray[i] = added; //最⾼位//拼接结果 [1,4,8,2,0] -> 2841StringBuilder builder = new StringBuilder();for(int n=resultArray.length-1;n>=0;n--){//如果最⾼位为0,移除if(n==resultArray.length-1 && resultArray[resultArray.length-1]==0){continue; //跳过}else{builder.append(resultArray[n]);}}return builder.toString();}/*** 两数相减* @param numStr1 数1* @param numStr2 数2* @return结果*/public static String subtract(String numStr1,String numStr2){int numLen1 = numStr1.length();int numLen2 = numStr2.length();int[] numArray1 = new int[numLen1]; //数字数组int[] numArray2 = new int[numLen2];// "12345"-> [5,4,3,2,1]for(int i=0;i<numLen1;i++){String c = numStr1.substring(i,i+1);numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}for(int i=0;i<numLen2;i++){String c = numStr2.substring(i,i+1);numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}int minLen = 0; //取长度⼩的数位数int maxLen = 0; //取长度⼤的数位数int[] maxArray = null; //数值⼤的数if(numLen1<numLen2){minLen = numLen1;maxLen = numLen2;maxArray = numArray2;}else{minLen = numLen2;maxLen = numLen1;maxArray = numArray1;if(numLen1 == numLen2){ //等于maxArray = getMaxNumber(numArray1,numArray2);}}int[] minArray = maxArray==numArray1?numArray2:numArray1; //数值⼩的数int[] resultArray = new int[maxLen];//⼤数-⼩数,同位相减,⼩于0借位int subtracted = 0;int i=0;for(;i<minLen;i++){int t = maxArray[i] - minArray[i] - subtracted; //两数相减,再减借位if(t<0){subtracted = 1; //向⾼位借1,暂存起来resultArray[i] = t+10; //当前位计算结果(借1相当于借了10)}else{subtracted = 0; //不借位resultArray[i] = t; //当前位计算结果}}//⼤数超出部分减掉借位for(;i<maxLen;i++){int t = maxArray[i]-subtracted; //多余位数减掉借位if(t<0){subtracted = 1; //进1resultArray[i] = t+10; //当前位计算结果}else{subtracted = 0; //不借位resultArray[i] = t; //当前位计算结果}}//拼接结果 [1,4,8,2,0] -> 2841StringBuilder builder = new StringBuilder();boolean highBitNotEqualZero = false; //存在⾼位不为0的情况,低位0保留for(int n=resultArray.length-1;n>=0;n--){//如果⾼位为0,移除if(resultArray[n]==0 && !highBitNotEqualZero && n!=0){ //⾼位⽆⽤的0去除continue; //跳过}else{highBitNotEqualZero = true; //找到不为0的位builder.append(resultArray[n]);}}if(maxArray == numArray1){ //第⼀个数⼤或相等}else{ //第⼀个数⼩于第⼆个数,相减为负数builder.insert(0,"-");}return builder.toString();}/*** 两数相乘* @param numStr1 数1* @param numStr2 数2* @return结果*/public static String multiply(String numStr1,String numStr2){int numLen1 = numStr1.length();int numLen2 = numStr2.length();int[] numArray1 = new int[numLen1]; //数字数组int[] numArray2 = new int[numLen2];// "12345"-> [5,4,3,2,1]for(int i=0;i<numLen1;i++){String c = numStr1.substring(i,i+1);numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字for(int i=0;i<numLen2;i++){String c = numStr2.substring(i,i+1);numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}int minLen = 0; //取长度⼩的数位数int maxLen = 0; //取长度⼤的数位数int[] maxArray = null; //长度⼤的数int[] minArray = null; //长度⼩的数if(numLen1<numLen2){minLen = numLen1;maxLen = numLen2;minArray = numArray1;maxArray = numArray2;}else{minLen = numLen2;maxLen = numLen1;minArray = numArray2;maxArray = numArray1;}//⼆维数组存储结果,例如:23*23 ->[[6,9],[4,6]] ,内部括号(低维)存某位的相乘结果,⾼维低位存个位,⼗位...int[][] resultArray = new int[minLen][maxLen+1];//长度⼤的数*长度⼩的数的每⼀位,分别存到相应数组中,然后累加for(int h=0;h<minLen;h++){ //⾼维int l=0;int added = 0;for(;l<maxLen;l++){ //低维int t = maxArray[l]*minArray[h]+added; //长度⼤的数的每⼀位*长度⼩的数的个位、⼗位...if(t>9){added = t/10; //进位resultArray[h][l] = t%10; //当前位计算结果}else{added = 0; //不进位resultArray[h][l] = t; //当前位计算结果}}resultArray[h][l] = added; //个位、⼗位...的计算结果的最⾼位}//对结果补位(左移),个位不动,⼗位补0,百位补00...,然后累加int[] sum = null; //最终累加结果int[] lowBitResult = null; //低位补0结果(前⼀位)for(int h=0;h<minLen;h++){int[] bitResult = resultArray[h];int[] r; //个位、⼗位...的补0结果if(h==0){ //个位r = bitResult;sum = r;lowBitResult = r; //记录下来,待下次循环累加}else{ //⼗位...的计算结果r = new int[resultArray[h].length+h]; //初始化默认就是0的int rLen = r.length-1;for(int i=bitResult.length-1;i>=0;i--){ //从⾼位开始复制到新数组r[rLen--] = bitResult[i];}//累加之前的数sum = new int[r.length+1]; //取⾼位长度+1,可能进位//================加法核⼼算法====================//两数长度相同的部分,同位相加,超出9进1int added = 0;int i=0;for(;i<lowBitResult.length;i++){int t = lowBitResult[i]+r[i]+added; //两数相加,再加进位if(t>9){added = 1; //进1sum[i] = t-10; //当前位计算结果}else{added = 0; //不进位sum[i] = t; //当前位计算结果}}//长度超出部分累加for(;i<r.length;i++){int t = r[i]+added; //多余位数加上进位if(t>9){added = 1; //进1sum[i] = t-10; //当前位计算结果}else{added = 0; //不进位sum[i] = t; //当前位计算结果}}sum[i] = added; //最⾼位//===============================================lowBitResult = sum; //记录下来,待下次循环累加}}//拼接结果 [1,4,8,2,0] -> 2841StringBuilder builder = new StringBuilder();boolean existHighNotZero = false; //⾼位存在不为0的,这个0就不能移除for(int n=sum.length-1;n>=0;n--){//移除⾼位⽆效的0,保留最后⼀个0if(sum[n]==0 && !existHighNotZero && n!=0){continue; //跳过}else{existHighNotZero = true;builder.append(sum[n]);}}return builder.toString();/*** 两数相除* @param numStr1 数1(被除数)* @param numStr2 数2(除数,不能超过long型)* @return结果*/public static String divide(String numStr1,String numStr2){int numLen1 = numStr1.length();int numLen2 = numStr2.length();int[] numArray1 = new int[numLen1]; //数字数组int[] numArray2 = new int[numLen2];// "12345"-> [5,4,3,2,1]for(int i=0;i<numLen1;i++){String c = numStr1.substring(i,i+1);numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}for(int i=0;i<numLen2;i++){String c = numStr2.substring(i,i+1);numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}int effectiveNum = (numLen1 >= numLen2 ? numLen1:numLen2)+16; //有效位数: 默认⼤数长度+16int[] resultArray = new int[effectiveNum]; //⾼位存⾼位//将被除数的每⼀位除以除数,取整为该位结果,取余暂存借给低位(除数不能⼤过long型,除⾮除法转换为减法) long yu = 0;int resultIndex = effectiveNum-1;for(int i=numArray1.length-1;i>=0;i--){long num = yu * 10 + numArray1[i]; //被除数该位为:余数*10+⾃⼰int r= (int)(num / Long.parseLong(numStr2)); //取整yu = num % Long.parseLong(numStr2); //取余resultArray[resultIndex--] = r;}int decimalPoint = effectiveNum-numArray1.length-1; //⼩数点位置if(yu!=0){int decimal = decimalPoint; //⼩数for(int i=0;i<effectiveNum-numArray1.length;i++){long num = yu * 10 + 0; //⼩数部分被除数补0int r= (int)(num / Long.parseLong(numStr2)); //取整yu = num % Long.parseLong(numStr2); //取余resultArray[decimal--] = r;if(yu==0){break; //余数为0,提前退出}}}//拼接结果StringBuilder builder = new StringBuilder();boolean existHighNotZero = false;for(int i=effectiveNum-1;i>=0;i--){if(i==decimalPoint){builder.append(".");}if(resultArray[i]==0){if(!existHighNotZero && i>decimalPoint+1){ //跳过⾼位⽆⽤的0continue;}}else{existHighNotZero = true;}builder.append(resultArray[i]);}String result = builder.toString();//去除尾部⽆⽤的0int endIndex = result.length();for(int i=result.length()-1;i>=0;i--){char c = result.charAt(i);if(c!='0'){endIndex = i+1;break;}}//去除多余的⼩数点if(result.charAt(endIndex-1)=='.'){endIndex = endIndex-1;}result = result.substring(0,endIndex);return result;}/*** 两数相除(增强版)* @param numStr1 数1(被除数)* @param numStr2 数2(除数)* @return结果*/public static String divideEnhanced(String numStr1,String numStr2){int numLen1 = numStr1.length();int numLen2 = numStr2.length();int[] numArray1 = new int[numLen1]; //数字数组int[] numArray2 = new int[numLen2];// "12345"-> [5,4,3,2,1]for(int i=0;i<numLen1;i++){String c = numStr1.substring(i,i+1);numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}for(int i=0;i<numLen2;i++){String c = numStr2.substring(i,i+1);numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}int effectiveNum = (numLen1 >= numLen2 ? numLen1:numLen2)+16; //有效位数: 默认⼤数长度+16int[] resultArray = new int[effectiveNum]; //⾼位存⾼位//将被除数的每⼀位除以除数,取整为该位结果,取余暂存借给低位(除数不能⼤过long型,除⾮除法转换为减法) String yu = "0";int resultIndex = effectiveNum-1;for(int i=numArray1.length-1;i>=0;i--){String num = "0".equals(yu)?numArray1[i]+"":add(yu+"0",numArray1[i]+""); //被除数该位为:余数*10+⾃⼰ DivideResult result = getDivideResult(num,numStr2);String r= result.getR() ; //取整yu = result.getYu(); //取余resultArray[resultIndex--] = Integer.parseInt(r); //某位上的结果肯定⼩于10}int decimalPoint = effectiveNum-numArray1.length-1; //⼩数点位置if(!"0".equals(yu)){int decimal = decimalPoint; //⼩数for(int i=0;i<effectiveNum-numArray1.length;i++){String num = yu+"0"; //⼩数部分被除数补0DivideResult result = getDivideResult(num,numStr2);String r= result.getR() ; //取整yu = result.getYu(); //取余resultArray[decimal--] = Integer.parseInt(r);if("0".equals(yu)){break; //余数为0,提前退出}}}//拼接结果StringBuilder builder = new StringBuilder();boolean existHighNotZero = false;for(int i=effectiveNum-1;i>=0;i--){if(i==decimalPoint){builder.append(".");}if(resultArray[i]==0){if(!existHighNotZero && i>decimalPoint+1){ //跳过⾼位⽆⽤的0continue;}}else{existHighNotZero = true;}builder.append(resultArray[i]);}String result = builder.toString();//去除尾部⽆⽤的0int endIndex = result.length();for(int i=result.length()-1;i>=0;i--){char c = result.charAt(i);if(c!='0'){endIndex = i+1;break;}}//去除多余的⼩数点if(result.charAt(endIndex-1)=='.'){endIndex = endIndex-1;}result = result.substring(0,endIndex);return result;}/*** 校验数字是否合法* @param numStr 数字字符串* @return是否合法*/public static boolean numberValid(String numStr){Pattern pattern = pile("^[1-9]\\d*$|0");Matcher matcher = pattern.matcher(numStr);return matcher.matches();}/*** 计算⼤数* @param numArray1 数1* @param numArray2 数2* @return⼤数*/public static int[] getMaxNumber(int[] numArray1, int[] numArray2) {for(int i=numArray1.length-1;i>=0;i--){if(numArray1[i]>numArray2[i]){return numArray1;}else{if(numArray1[i]==numArray2[i]){continue; //待继续⽐较}else{return numArray2;}}}return numArray1; //全部相等,返回第⼀个}/*** 除法转换为减法* @param numStr1 数1(被除数)* @param numStr2 数2(除数)* @return除的结果*/public static DivideResult getDivideResult(String numStr1,String numStr2){DivideResult result = new DivideResult();String r = "";// String times = "0";int times = 0; //取整不会⼤于9的(被除数(余数+某位)/除数(肯定⼤于余数)这个过程是,被除数逐渐增⼤到可以除以除数为⽌,此时被除数>=除数,刚刚好,所以被除数最多⽐除数多1位,两数相差肯定⼩于10倍)while (true){r=subtract(numStr1,numStr2);// times = add(times,"1"); //次数递增times++;if("0".equals(r)){ //除尽了result.setYu("0");result.setR(times+"");break;}else if(r.startsWith("-")){ //负数,多减了⼀次result.setYu(numStr1); //上次减下来多余的数值,就是余数// result.setR(subtract(times,"1"));result.setR((times-1)+"");break;}numStr1 = r; //被减数重置为剩余的数值}return result;}}package com.hdwang;/*** Created by hdwang on 2017/10/10.* 相除结果*/public class DivideResult {/*** 取整结果*/private String r;/*** 取余结果*/private String yu;public String getR() {return r;}public void setR(String r) {this.r = r;}public String getYu() {return yu;}public void setYu(String yu) {this.yu = yu;}}package com.hdwang;import java.util.Scanner;import static com.hdwang.Calculator.*;public class Main {public static void main(String[] args) {// write your code hereScanner scanner = new Scanner(System.in);boolean loop = true;while (loop) {System.out.println("请输⼊第⼀个⾮负整数:");String numStr1 = scanner.nextLine();if (!numberValid(numStr1)) {System.out.println(String.format("%s不合法", numStr1));continue;}System.out.println("请输⼊第⼆个⾮负整数:");String numStr2 = scanner.nextLine();if (!numberValid(numStr2)) {System.out.println(String.format("%s不合法", numStr2));continue;}String r1 = add(numStr1, numStr2);System.out.println(String.format("⼤数加法计算:%s+%s%s=%s", numStr1, numStr2,r1.length()>50?"\n":"", r1));try {System.out.println("加法直接计算:" + (Long.parseLong(numStr1) + Long.parseLong(numStr2)));}catch (Exception ex){System.out.println("加法直接计算:"+ex.getClass().getName());}String r2 = subtract(numStr1, numStr2);System.out.println(String.format("⼤数减法计算:%s-%s%s=%s", numStr1, numStr2,r2.length()>50?"\n":"", r2));try {System.out.println("减法直接计算:" + (Long.parseLong(numStr1) - Long.parseLong(numStr2)));}catch (Exception ex){System.out.println("减法直接计算:"+ex.getClass().getName());}String r3 = multiply(numStr1, numStr2);System.out.println(String.format("⼤数乘法计算:%s*%s%s=%s", numStr1, numStr2,r3.length()>50?"\n":"", r3));try {System.out.println("乘法直接计算:" + (Long.parseLong(numStr1) * Long.parseLong(numStr2)));}catch (Exception ex){System.out.println("乘法直接计算:"+ex.getClass().getName());}try {String r4 = divide(numStr1, numStr2);System.out.println(String.format("⼤数除法计算:%s/%s%s=%s", numStr1, numStr2, r4.length() > 50 ? "\n" : "", r4)); }catch (Exception ex){System.out.println("⼤数除法计算:"+ex.getClass().getName());}try {System.out.println("除法直接计算:" + ((double)Long.parseLong(numStr1) / (double) Long.parseLong(numStr2)));}catch (Exception ex){System.out.println("除法直接计算:"+ex.getClass().getName());}String r5 = divideEnhanced(numStr1, numStr2);System.out.println(String.format("增强版⼤数除法计算:%s/%s%s=%s", numStr1, numStr2,r5.length()>50?"\n":"", r5)); System.out.println("退出输⼊q,否则继续");String line = scanner.nextLine();if(line.equalsIgnoreCase("Q")){loop = false;}else{loop = true;}}}}运⾏结果:请输⼊第⼀个⾮负整数:1请输⼊第⼆个⾮负整数:1⼤数加法计算:1+1=2加法直接计算:2⼤数减法计算:1-1=0减法直接计算:0⼤数乘法计算:1*1=1乘法直接计算:1⼤数除法计算:1/1=1除法直接计算:1.0增强版⼤数除法计算:1/1=1退出输⼊q,否则继续请输⼊第⼀个⾮负整数:2请输⼊第⼆个⾮负整数:3⼤数加法计算:2+3=5加法直接计算:5⼤数减法计算:2-3=-1减法直接计算:-1⼤数乘法计算:2*3=6乘法直接计算:6⼤数除法计算:2/3=0.6666666666666666除法直接计算:0.6666666666666666增强版⼤数除法计算:2/3=0.6666666666666666退出输⼊q,否则继续请输⼊第⼀个⾮负整数:25请输⼊第⼆个⾮负整数:25⼤数加法计算:25+25=50加法直接计算:50⼤数减法计算:25-25=0减法直接计算:0⼤数乘法计算:25*25=625乘法直接计算:625⼤数除法计算:25/25=1除法直接计算:1.0增强版⼤数除法计算:25/25=1退出输⼊q,否则继续请输⼊第⼀个⾮负整数:100请输⼊第⼆个⾮负整数:50⼤数加法计算:100+50=150加法直接计算:150⼤数减法计算:100-50=50减法直接计算:50⼤数乘法计算:100*50=5000乘法直接计算:5000⼤数除法计算:100/50=2除法直接计算:2.0增强版⼤数除法计算:100/50=2退出输⼊q,否则继续请输⼊第⼀个⾮负整数:3请输⼊第⼆个⾮负整数:4⼤数加法计算:3+4=7加法直接计算:7⼤数减法计算:3-4=-1减法直接计算:-1⼤数乘法计算:3*4=12乘法直接计算:12⼤数除法计算:3/4=0.75除法直接计算:0.75增强版⼤数除法计算:3/4=0.75退出输⼊q,否则继续请输⼊第⼀个⾮负整数:4请输⼊第⼆个⾮负整数:3⼤数加法计算:4+3=7加法直接计算:7⼤数减法计算:4-3=1减法直接计算:1⼤数乘法计算:4*3=12乘法直接计算:12⼤数除法计算:4/3=1.3333333333333333除法直接计算:1.3333333333333333增强版⼤数除法计算:4/3=1.3333333333333333退出输⼊q,否则继续请输⼊第⼀个⾮负整数:1请输⼊第⼆个⾮负整数:100⼤数加法计算:1+100=101加法直接计算:101⼤数减法计算:1-100=-99减法直接计算:-99⼤数乘法计算:1*100=100乘法直接计算:100⼤数除法计算:1/100=0.01除法直接计算:0.01增强版⼤数除法计算:1/100=0.01退出输⼊q,否则继续请输⼊第⼀个⾮负整数:100请输⼊第⼆个⾮负整数:1⼤数加法计算:100+1=101加法直接计算:101⼤数减法计算:100-1=99减法直接计算:99⼤数乘法计算:100*1=100乘法直接计算:100⼤数除法计算:100/1=100除法直接计算:100.0增强版⼤数除法计算:100/1=100退出输⼊q,否则继续请输⼊第⼀个⾮负整数:1请输⼊第⼆个⾮负整数:10000000000⼤数加法计算:1+10000000000=10000000001加法直接计算:10000000001⼤数减法计算:1-10000000000=-9999999999减法直接计算:-9999999999⼤数乘法计算:1*10000000000=10000000000乘法直接计算:10000000000⼤数除法计算:1/10000000000=0.0000000001除法直接计算:1.0E-10增强版⼤数除法计算:1/10000000000=0.0000000001退出输⼊q,否则继续请输⼊第⼀个⾮负整数:1请输⼊第⼆个⾮负整数:100000000000000000000000000000000000000000000000000⼤数加法计算:1+100000000000000000000000000000000000000000000000000=100000000000000000000000000000000000000000000000001加法直接计算:ng.NumberFormatException⼤数减法计算:1-100000000000000000000000000000000000000000000000000=-99999999999999999999999999999999999999999999999999减法直接计算:ng.NumberFormatException⼤数乘法计算:1*100000000000000000000000000000000000000000000000000=100000000000000000000000000000000000000000000000000乘法直接计算:ng.NumberFormatException⼤数除法计算:ng.NumberFormatException除法直接计算:ng.NumberFormatException增强版⼤数除法计算:1/100000000000000000000000000000000000000000000000000=0.00000000000000000000000000000000000000000000000001退出输⼊q,否则继续说明:当数字的⼤⼩超过long类型的数值范围时,将⽆法对数值进⾏计算,所以必须实现⼀套算法。

JavaBigInteger详解

JavaBigInteger详解

JavaBigInteger详解BigInteger概述可⽤于⽆限⼤的整数计算所在的包java.math.BigInteger;构造函数public BigInteger(String val)成员函数⽐较⼤⼩函数public int compareTo(BigInteger val)实例pareTo(b)如果a>b,返回值⼤于零a<b,返回值⼩于零a=b,返回值等于零加法函数public BigInteger add(BigInteger val)减法函数public BigInteger subtract(BigInteger val)乘法函数public BigInteger multiply(BigInteger val)除法函数public BigInteger divide(BigInteger val)取余函数public BigInteger remainder(BigInteger val)取除数和余数函数public BigInteger[] divideAndRemainder(BigInteger val)实例import java.math.*;public class Main {public static void main(String[] args){BigInteger bi1 = new BigInteger("20");BigInteger bi2 = new BigInteger("5");//加法System.out.println("20+5结果:"+bi1.add(bi2));//减法System.out.println("20-5结果:"+bi1.subtract(bi2));//乘法System.out.println("20×5结果:"+bi1.multiply(bi2));//除法System.out.println("20÷5结果:"+bi1.divide(bi2));//取余System.out.println("20%5结果:"+bi1.remainder(bi2));//取除数和余数BigInteger[] bigIntegers = bi1.divideAndRemainder(bi2);for(BigInteger bi :bigIntegers){System.out.println(bi);}}}/*输出20+5结果:2520-5结果:1520×5结果:10020÷5结果:420%5结果:04*/。

bigint mybatis long 类型

bigint mybatis long 类型

bigint mybatis long 类型(原创版)目录1.大整数类型 BigInteger2.MyBatis 中的 Long 类型3.类型转换与使用示例正文1.大整数类型 BigIntegerBigInteger 是 Java 中的一种大整数类型,它可以表示任意大小的整数。

与普通的整数类型如 int 和 long 不同,BigInteger 可以表示超过它们范围的整数。

BigInteger 类型主要应用于需要处理大整数的场景,例如加密算法、大数运算等。

2.MyBatis 中的 Long 类型MyBatis 是一个 Java 持久层框架,它可以简化数据库操作。

在MyBatis 中,Long 类型用于表示数据库中的 BIGINT 类型。

BIGINT 是数据库中的一种大整数类型,它可以表示超过 int 和 long 范围的整数。

MyBatis 中的 Long 类型与 Java 中的 BigInteger 类型类似,可以表示任意大小的整数。

3.类型转换与使用示例在使用 MyBatis 进行数据库操作时,可能需要将 Java 中的BigInteger 类型转换为 MyBatis 中的 Long 类型。

可以使用 MyBatis 的 TypeHandler 功能来实现类型转换。

以下是一个简单的示例:```java// 创建一个 BigInteger 对象BigInteger bigInt = newBigInteger("1234567890123456789012345678901234567890");// 将 BigInteger 对象转换为 MyBatis 的 Long 类型Long longValue = bigInt.longValue();// 在 MyBatis 的 SQL 语句中使用 Long 类型String sql = "INSERT INTO my_table (id) VALUES (#{id})";// 其中,id 对应的类型是 Long// 调用 MyBatis 的 insert 方法执行 SQL 语句//...```通过以上示例,可以将 Java 中的 BigInteger 类型转换为MyBatis 中的 Long 类型,并在数据库操作中使用。

【JAVA基础教程】Java大数字运算BigInteger和BigDecimar-潭州JAVA

【JAVA基础教程】Java大数字运算BigInteger和BigDecimar-潭州JAVA
gDecimal和BigInteger都能实现大数字的运算,不同的是BigDecimal加入了 小数的概念。一般的float型和double型数据只可以用来做科学计算或工程计算, 但由于在商业计算中要求数字精度比较高,所以要用到java.math.BigDecimal 类。BigDecimal类支持任何精度的定点数,可以用它来精确计算货币值。
BigDecimal 的运算方式 不支持 + - * / 这类的运算 它有自己的运算方法 BigDecimal add(BigDecimal augend) 加法运算 BigDecimal subtract(BigDecimal subtrahend) 减法运算 BigDecimal multiply(BigDecimal multiplicand) 乘法运算 BigDecimal divide(BigDecimal divisor) 除法运算
BigDecimal的构造方法
BigDecimal一共有4个构造方法
BigDecimal(int) 创建一个具有参数所指定整数值的对象。
BigDecimal(double) 创建一个具有参数所指定双精度值的对象。 BigDecimal(long) 创建一个具有参数所指定长整数值的对象。
BigDecimal(String) 创建一个具有参数所指定以字符串表示的数值的对象。
大数字运算
本讲大纲: 1、BigInteger 2、BigDecimal
BigInteger
在BigInteger类中封装了多种操作,除了基本的加、减、乘、除操作之外,还提 供了绝对值、相反数、最大公约数以及判断是否为质数等操作。 当使用BigInteger类时,可以实例化一个BigInteger对象,并自动调用相应的构 造函数。BigInteger类具有很多构造函数,但最直接的一种方式是参数以字符串 形式代表要处理的数字。

java大数乘法

java大数乘法

java大数乘法Java大数乘法Java是一种高级编程语言,它的强大之处在于它可以处理各种类型的数据,包括大数。

在Java中,大数是指超过了基本数据类型的范围的数字,例如1000位的整数。

在计算机科学中,大数乘法是一种重要的算法,它可以用来计算大数的乘积。

本文将介绍Java中的大数乘法算法。

一、大数乘法的基本原理大数乘法的基本原理是将两个大数分别拆分成若干个小数,然后将小数相乘,最后将结果相加得到最终的乘积。

例如,要计算123456789012345678901234567890的平方,可以将它拆分成123456789012345678901234567和890,然后将这两个数相乘,最后将结果相加得到最终的乘积。

二、Java中的大数乘法实现在Java中,可以使用BigInteger类来实现大数乘法。

BigInteger类是Java中的一个内置类,它可以处理任意长度的整数。

下面是一个使用BigInteger类实现大数乘法的示例代码:```import java.math.BigInteger;public class BigMultiplication {public static void main(String[] args) {BigInteger a = new BigInteger("123456789012345678901234567");BigInteger b = new BigInteger("890");BigInteger c = a.multiply(b);System.out.println(c);}}```在上面的代码中,我们首先创建了两个BigInteger对象a和b,分别表示要相乘的两个大数。

然后,我们使用multiply()方法将它们相乘,得到一个新的BigInteger对象c,表示它们的乘积。

最后,我们使用println()方法将结果输出到控制台。

Java大数类题型训练

Java大数类题型训练

本文由我司收集整编,推荐下载,如有疑问,请与我司联系Java 大数类题型训练2015/10/24 0 Fibonacci Numbers Time Limit: 2 Seconds Memory Limit: 65536 KBA Fibonacci sequence is calculated by adding the previous two members of the sequence,with the first two members being both 1. f(1) = 1, f(2) = 1, f(n 2) = f(n - 1) + f(n - 2)Your task is to take a number as input, and print that Fibonacci number.Sample Input100Sample Output354224848179261915075Note:No generated Fibonacci number in excess of 1000 digits will be in the test data, i.e. f(20) = 6765 has 4 digits. 这是第一题,真是恶心,到头来是少了while(cin.hasNext())需要导的包看来就这两个util.* 和math.*import java.util.*;import java.math.*;public class Main{ public static void main(String args[]){ Scanner cin = new Scanner(System.in); while(cin.hasNext()){ int n = cin.nextInt(); if(n==1) System.out.println(n); else { BigInteger f[]=new BigInteger[n];f[0]=f[1]=new BigInteger(“1”);for(int i=2;i i++) f[i]=f[i-1].add(f[i-2]); System.out.println(f[n-1]); } } }}A + B Problem IITime Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 276033 Accepted Submission(s): 53273Problem Description I have a very simple problem for you. Given two integers A and B, your job is to calculate the Sum of A + B.Input The first line of the input contains an integer T(1 =T =20) which means the number of test cases. Then T lines follow, each line consists of two positive integers, A and B. Notice that the integers are very large, that means you should not process them byusing 32-bit integer. You may assume the length of each integer will not exceed 1000.。

java练习大数运算 (1)

java练习大数运算 (1)

/*** 大数运算* BigInteger* 求91的92次方* 求它除以100的余数* 大数运算Biginteger类的方法调用*/package com.test1;import java.math.*;import java.math.BigInteger;public class test100 {/*** @param args*/static BigInteger k=BigInteger.valueOf(1);static BigInteger j=BigInteger.valueOf(91);static BigInteger n;BigDecimal l=new BigDecimal("100");static BigInteger m=new BigInteger("100");public static void main(String[] args) {// TODO Auto-generated method stub// k=BigInteger.valueOf(1);// k=new BigInteger("1");for(int i=1;i<=92;i++){k=k.multiply(j);System.out.println(k.toString());// n=k.remainder(m);n=k.remainder(m);System.out.println(n.toString());}}}//java大数运算Biginteger类的方法调用//以下代码与本练习没有必要关系,可以删除class BigIntegerGet{public String getAdd(String Str1,String Str2){ String Str3=new String();BigInteger BigInt1=new BigInteger(Str1);BigInteger BigInt2=new BigInteger(Str2);BigInt1=BigInt1.add(BigInt2);//加Str3=BigInt1.toString();return Str3;}public String getSubtract(String Str1,String Str2){String Str3=new String();BigInteger BigInt1=new BigInteger(Str1);BigInteger BigInt2=new BigInteger(Str2);BigInt1=BigInt1.subtract(BigInt2);//减Str3=BigInt1.toString();return Str3;}public String getMultiply(String Str1,String Str2){String Str3=new String();BigInteger BigInt1=new BigInteger(Str1);BigInteger BigInt2=new BigInteger(Str2);BigInt1=BigInt1.multiply(BigInt2);//乘Str3=BigInt1.toString();return Str3;}public String getDivide(String Str1,String Str2){String Str3=new String();BigInteger BigInt1=new BigInteger(Str1);BigInteger BigInt2=new BigInteger(Str2);BigInt1=BigInt1.divide(BigInt2);//除Str3=BigInt1.toString();return Str3;}public String getRemainder(String Str1,String Str2){//% String Str3=new String();BigInteger BigInt1=new BigInteger(Str1);BigInteger BigInt2=new BigInteger(Str2);BigInt1=BigInt1.remainder(BigInt2);//余数Str3=BigInt1.toString();return Str3;}public String getGcd(String Str1,String Str2){String Str3=new String();BigInteger BigInt1=new BigInteger(Str1);BigInteger BigInt2=new BigInteger(Str2);BigInt1=BigInt1.gcd(BigInt2);//最大公约数Str3=BigInt1.toString();return Str3;}public String getPow(String Str1,String Str2){String Str3=new String();BigInteger BigInt1=new BigInteger(Str1);int Int2=Integer.valueOf(Str2);BigInt1=BigInt1.pow(Int2);//方Str3=BigInt1.toString();return Str3;}public String getMod(String Str1,String Str2){String Str3=new String();BigInteger BigInt1=new BigInteger(Str1);BigInteger BigInt2=new BigInteger(Str2);BigInt1=BigInt1.mod(BigInt2);//模Str3=BigInt1.toString();return Str3;}public String getModInverse(String Str1,String Str2){ String Str3=new String();BigInteger BigInt1=new BigInteger(Str1);BigInteger BigInt2=new BigInteger(Str2);BigInt1=BigInt1.modInverse(BigInt2);//倒数取模Str3=BigInt1.toString();return Str3;}public String getMax(String Str1,String Str2){String Str3=new String();BigInteger BigInt1=new BigInteger(Str1);BigInteger BigInt2=new BigInteger(Str2);BigInt1=BigInt1.max(BigInt2);//返回较大一个数的值Str3=BigInt1.toString();return Str3;}public String getMin(String Str1,String Str2){String Str3=new String();BigInteger BigInt1=new BigInteger(Str1);BigInteger BigInt2=new BigInteger(Str2);BigInt1=BigInt1.min(BigInt2);//返回较小一个数的值Str3=BigInt1.toString();return Str3;}public int getHashcode(String Str){int hash=-1;BigInteger BigInt=new BigInteger(Str);hash=BigInt.hashCode();return hash;}public boolean getIsProbablePrime(String Str,int certainty){ boolean flag=false;BigInteger BigInt=new BigInteger(Str);flag=BigInt.isProbablePrime(certainty);//素数return flag;}}。

biginteger 方法

biginteger 方法

biginteger 方法BigInteger类是Java中用于处理大整数的一个类。

它允许我们进行超出普通整数范围的数学运算。

BigInteger类提供了一系列方法来进行加减乘除等运算,以及比较、取余、幂运算等操作。

下面我将从几个方面介绍BigInteger类的常用方法。

1. 创建BigInteger对象,BigInteger类提供了多种构造方法,可以通过字符串、整数、字节数组等方式来创建BigInteger对象。

比如可以使用BigInteger(String val)来将字符串转换为BigInteger对象,或者使用BigInteger.valueOf(long val)来将普通整数转换为BigInteger对象。

2. 运算方法,BigInteger类提供了add、subtract、multiply、divide等方法来进行加减乘除运算。

这些方法可以对两个BigInteger对象进行相应的运算,并返回一个新的BigInteger对象作为结果。

3. 比较方法,BigInteger类提供了compareTo、equals等方法来进行大小比较和相等判断。

通过这些方法可以方便地比较两个BigInteger对象的大小关系或者是否相等。

4. 其他常用方法,除了上述的方法,BigInteger类还提供了abs、negate、mod、pow等方法来进行绝对值、取反、取余、幂运算等操作。

总之,BigInteger类提供了丰富的方法来进行大整数的运算和操作,可以满足我们在实际开发中对于大整数运算的需求。

通过合理使用这些方法,我们可以方便地处理超出普通整数范围的数学运算,使得我们的程序能够更加灵活和强大。

基础算法 —— 高精度计算 —— Java 大数类

基础算法 —— 高精度计算 —— Java 大数类

【概述】在 C++ 中数据类型的长度最多能到 64 位,一旦超出这个位数,就要用数组进行模拟计算,即高精度算法而在 Java 中有两个类:BigInteger、BigDecimal 分别表示大整数类和大浮点数类,其理论上能表示无限大的数,只要计算机内存足够大。

这两个类都是 Number 类的子类,但存放在 java.math.* 包中,因此每次使用必须在开头处引用该包。

【常量】BigInteger 的 ONE、ZERO、TEN 分别代表 1、0、10BigInteger.ZERO //大整数0BigInteger.ONE //大整数1BigInteger.TEN //大整数10而在 BigDecimal 中除了以上三个常量外还有8个关于舍入的常量:ROUND_UP、ROUND_DOWN、ROUND_CEILING、ROUND_FLOOR、ROUND_HALF_UP、ROUND_HALF_DOWN、ROUND_HALF_EVEN、ROUND_UNNECESSARY。

【声明赋值】基本类型的定义:BigInteger name = new BigInteger(String) ;//参数是字符串BigInteger name = BigInteger.valueOf(123); //参数是 int、longBigDecimal name = new BigDecimal(String) ;//参数是字符串BigDecimal name = BigDecimal.valueOf(123.45); //参数是 float、double【输入框架】Scanner input = new Scanner(System.in);while(input.hasNext()){BigInteger a;a = input.BigInteger();System.out.println(a);}【基本用法】1.四则运算BigInteger a = new BigInteger.valueOf(10);BigInteger b = new BigInteger.valueOf(10);BigInteger res new BigInteger();res=a.add(b); //加法res=a.subtract(b); //减法res=a.divide(b); //除法res=a.multiply(b); //乘法2.比较大小BigInteger a = new BigInteger.valueOf(10); BigInteger b = new BigInteger.valueOf(10);a.equals(b); //如果a、b相等返回true否则返回false areTo(b); //a小于b返回-1,等于返回0,大于返回13.常用方法BigInteger a = new BigInteger.valueOf(10); BigInteger b = new BigInteger.valueOf(15); BigInteger mod = new BigInteger.valueOf(10007); BigInteger res=new BigInteger();res=a.mod(mod); //求余res=a.gcd(b); //求最大公约数res=a.max(b); //求最大值res=a.min(b); //求最小值res=a.modPow(b,mod); //求(a^b)%mod。

java大数运算(讲解)

java大数运算(讲解)

java⼤数运算(讲解)在算法竞赛或者⾯试中我们经常遇到⼤数问题,例如求⼀个很⼤的阶层,⼤数加法等等。

住在这种情况下我们⽤常规解法(使⽤long long或long long int)肯定是不⾏的,⽽我们⾃⼰⽤c/c++写⼀个⼤数的算法⼜过于⿇烦且易于出错,在这种情况下使⽤java中⾃带的⼤数类是我们最好的选择,相对⽐c/c++⽐较⽽⾔,java语⾔写⼤数是⽐较流氓的,但是代码量⾮常的少,⽽且容易理解,你只需要调包就可以了。

BigIntegerpackage ⼤数;import java.math.BigInteger;import java.util.Scanner;public class ⼤数 {public static void main(String[] args) {Scanner sc=new Scanner(System.in);BigInteger b1=new BigInteger("123456789");BigInteger b2=new BigInteger("987654321");System.out.println("加法操作:"+b2.add(b1));System.out.println("减法操作:"+b2.subtract(b1));System.out.println("乘法操作:"+b2.multiply(b1));System.out.println("除法操作:"+b2.divide(b1));System.out.println("最⼤数:"+b2.max(b1));System.out.println("最⼩数:"+b2.min(b1));BigInteger result[]=b2.divideAndRemainder(b1);System.out.println("商是:"+result[0]+" "+"余数是:"+result[1]);}}1.定义常⽤⽅法:BigInteger a=new BigInteger(“123”); //第⼀种,参数是字符串BigInteger a=BigInteger.valueOf(123); //第⼆种,参数可以是int、long2.⼤整数⽐较⼤⼩a.equals(b); //如果a、b相等返回true否则返回falsepareTo(b); //a⼩于b返回-1,等于返回0,⼤于返回13.⼤数常⽤⽅法及常量a.mod(b); //求余a.gcd(b); //求最⼤公约数a.max(b); //求最⼤值a.min(b); //求最⼩值BigInteger.ZERO //⼤整数0BigInteger.ONE //⼤整数1BigInteger.TEN //⼤整数10//先转换成字符串再求字符串的长度a.toString().length(); //a的类型为BigIntegerBigDecimal使⽤此类可以完成⼤的⼩数操作,⽽且也可以使⽤此类进⾏精确的四舍五⼊,这⼀点在开发中经常使⽤。

JAVA大数处理(BigInteger,BigDecimal)

JAVA大数处理(BigInteger,BigDecimal)

JAVA大数处理(BigInteger,BigDecimal)Ⅰ基本函数:1.valueOf(parament); 将参数转换为制定的类型比如 int a=3;BigInteger b=BigInteger.valueOf(a);则b=3;String s=”12345”;BigInteger c=BigInteger.valueOf(s);则c=12345;2.add(); 大整数相加BigInteger a=new BigInteger(“23”); BigInteger b=new BigInteger(“34”);a. add(b);3.subtract(); 相减4.multiply(); 相乘5.divide(); 相除取整6.remainder(); 取余7.pow(); a.pow(b)=a^b8.gcd(); 最大公约数9.abs(); 绝对值10.negate(); 取反数11.mod(); a.mod(b)=a%b=a.remainder(b);12.max(); min();13.punlic int comareTo();14.boolean equals(); 是否相等15.BigInteger构造函数:一般用到以下两种:BigInteger(String val);将指定字符串转换为十进制表示形式;BigInteger(String val,int radix);将指定基数的 BigInteger 的字符串表示形式转换为 BigInteger Ⅱ.基本常量:A=BigInteger.ONE 1B=BigInteger.TEN 10C=BigInteger.ZERO 0Ⅲ.基本操作1. 读入:用Scanner类定义对象进行控制台读入,Scanner类在java.util.*包中Scanner cin=new Scanner(System.in);// 读入while(cin.hasNext()) //等同于!=EOF{int n;BigInteger m;n=cin.nextInt(); //读入一个int;m=cin.BigInteger();//读入一个BigInteger;System.out.print(m.toString());}Ⅳ.运用四则预算:import java.util.Scanner;import java.math.*;import java.text.*;public class Main{public static void main(String args[]){Scanner cin = new Scanner ( System.in ); BigInteger a,b;int c;char op;String s;while( cin.hasNext() ){a = cin.nextBigInteger();s = cin.next();op = s.charAt(0);if( op == '+'){b = cin.nextBigInteger();System.out.println(a.add(b));}else if( op == '-'){b = cin.nextBigInteger();System.out.println(a.subtract(b));}else if( op == '*'){b = cin.nextBigInteger();System.out.println(a.multiply(b));}else{BigDecimal a1,b1,eps;String s1,s2,temp;s1 = a.toString();a1 = new BigDecimal(s1);b = cin.nextBigInteger();s2 = b.toString();b1 = new BigDecimal(s2);c = cin.nextInt();eps = a1.divide(b1,c,4);//System.out.println(a + " " + b + " " + c);//System.out.println(a1.doubleValue() + " " + b1.doubleValue() + " " + c);System.out.print( a.divide(b) + " " + a.mod(b) + " ");if( c != 0){temp = "0.";for(int i = 0; i < c; i ++) temp += "0";DecimalFormat gd = new DecimalFormat(temp);System.out.println(gd.format(eps));}else System.out.println(eps);}}}}补充:a=a.pow(b);a=a.stripTrailingZeros();d=a.toPlainString();if(d.charAt(0)=='0') d=d.substring(1);。

biginteger bigdecimal转换计算

biginteger bigdecimal转换计算

BigInteger 和BigDecimal 是Java 中的两种处理大数字和浮点数的类,它们有各自的特性和用途。

如果你想在两者之间进行转换并进行计算,你可以按照以下步骤操作:从BigDecimal 到BigInteger:使用BigDecimal 的toBigInteger() 方法可以将BigDecimal 转换为BigInteger。

这会将BigDecimal 转换为最接近的BigInteger,但可能舍入错误。

如果要确保没有舍入错误,可以使用toBigIntegerExact() 方法。

从BigInteger 到BigDecimal:使用new BigDecimal(BigInteger) 构造函数可以将BigInteger 转换为BigDecimal。

计算:一旦你有了BigInteger 或BigDecimal,你可以使用它们的各种方法(如加法、减法、乘法、除法等)进行计算。

需要注意的是,当涉及到除法时,BigDecimal 提供了高精度的结果,而BigInteger 可能会截断小数部分。

示例:import java.math.BigDecimal;import java.math.BigInteger;public class BigDecimalToBigInteger {public static void main(String[] args) {// 从BigDecimal 到BigInteger 的转换示例BigDecimal bd = new BigDecimal("123456789012345678901234567890.123 4567890");BigInteger bi = bd.toBigInteger(); // 这可能导致舍入错误System.out.println("BigDecimal to BigInteger: " + bi);// 从BigInteger 到BigDecimal 的转换示例BigInteger bigIntValue = new BigInteger("1234567890");BigDecimal bdValue = new BigDecimal(bigIntValue);System.out.println("BigInteger to BigDecimal: " + bdValue);}在进行这些转换时,重要的是要理解舍入和精度损失的可能性,并确保你的应用场景可以处理这些潜在的问题。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

/**
* 大数运算
* BigInteger
* 求91的92次方
* 求它除以100的余数
* 大数运算Biginteger类的方法调用
*/
package com.test1;
import java.math.*;
import java.math.BigInteger;
public class test100 {
/**
* @param args
*/
static BigInteger k=BigInteger.valueOf(1);
static BigInteger j=BigInteger.valueOf(91);
static BigInteger n;
BigDecimal l=new BigDecimal("100");
static BigInteger m=new BigInteger("100");
public static void main(String[] args) {
// TODO Auto-generated method stub
// k=BigInteger.valueOf(1);
// k=new BigInteger("1");
for(int i=1;i<=92;i++){
k=k.multiply(j);
System.out.println(k.toString());
// n=k.remainder(m);
n=k.remainder(m);
System.out.println(n.toString());
}
}
}
//java大数运算Biginteger类的方法调用
//以下代码与本练习没有必要关系,可以删除
class BigIntegerGet
{
public String getAdd(String Str1,String Str2){ String Str3=new String();
BigInteger BigInt1=new BigInteger(Str1);
BigInteger BigInt2=new BigInteger(Str2);
BigInt1=BigInt1.add(BigInt2);//加
Str3=BigInt1.toString();
return Str3;
}
public String getSubtract(String Str1,String Str2){
String Str3=new String();
BigInteger BigInt1=new BigInteger(Str1);
BigInteger BigInt2=new BigInteger(Str2);
BigInt1=BigInt1.subtract(BigInt2);//减
Str3=BigInt1.toString();
return Str3;
}
public String getMultiply(String Str1,String Str2){
String Str3=new String();
BigInteger BigInt1=new BigInteger(Str1);
BigInteger BigInt2=new BigInteger(Str2);
BigInt1=BigInt1.multiply(BigInt2);//乘
Str3=BigInt1.toString();
return Str3;
}
public String getDivide(String Str1,String Str2){
String Str3=new String();
BigInteger BigInt1=new BigInteger(Str1);
BigInteger BigInt2=new BigInteger(Str2);
BigInt1=BigInt1.divide(BigInt2);//除
Str3=BigInt1.toString();
return Str3;
}
public String getRemainder(String Str1,String Str2){//% String Str3=new String();
BigInteger BigInt1=new BigInteger(Str1);
BigInteger BigInt2=new BigInteger(Str2);
BigInt1=BigInt1.remainder(BigInt2);//余数
Str3=BigInt1.toString();
return Str3;
}
public String getGcd(String Str1,String Str2){
String Str3=new String();
BigInteger BigInt1=new BigInteger(Str1);
BigInteger BigInt2=new BigInteger(Str2);
BigInt1=BigInt1.gcd(BigInt2);//最大公约数
Str3=BigInt1.toString();
return Str3;
}
public String getPow(String Str1,String Str2){
String Str3=new String();
BigInteger BigInt1=new BigInteger(Str1);
int Int2=Integer.valueOf(Str2);
BigInt1=BigInt1.pow(Int2);//方
Str3=BigInt1.toString();
return Str3;
}
public String getMod(String Str1,String Str2){
String Str3=new String();
BigInteger BigInt1=new BigInteger(Str1);
BigInteger BigInt2=new BigInteger(Str2);
BigInt1=BigInt1.mod(BigInt2);//模
Str3=BigInt1.toString();
return Str3;
}
public String getModInverse(String Str1,String Str2){ String Str3=new String();
BigInteger BigInt1=new BigInteger(Str1);
BigInteger BigInt2=new BigInteger(Str2);
BigInt1=BigInt1.modInverse(BigInt2);//倒数取模
Str3=BigInt1.toString();
return Str3;
}
public String getMax(String Str1,String Str2){
String Str3=new String();
BigInteger BigInt1=new BigInteger(Str1);
BigInteger BigInt2=new BigInteger(Str2);
BigInt1=BigInt1.max(BigInt2);//返回较大一个数的值
Str3=BigInt1.toString();
return Str3;
}
public String getMin(String Str1,String Str2){
String Str3=new String();
BigInteger BigInt1=new BigInteger(Str1);
BigInteger BigInt2=new BigInteger(Str2);
BigInt1=BigInt1.min(BigInt2);//返回较小一个数的值
Str3=BigInt1.toString();
return Str3;
}
public int getHashcode(String Str){
int hash=-1;
BigInteger BigInt=new BigInteger(Str);
hash=BigInt.hashCode();
return hash;
}
public boolean getIsProbablePrime(String Str,int certainty){ boolean flag=false;
BigInteger BigInt=new BigInteger(Str);
flag=BigInt.isProbablePrime(certainty);//素数
return flag;
}
}。

相关文档
最新文档