精华内容
下载资源
问答
  • 1. 大数运算Java中有两个类BigInteger和BigDecimal分别表示不可变的任意精度的整数和不可变的有符号的任意精度的十进制数(浮点数)。主要用于高精度计算中。这两个类使得java中的大数,高精度运算变得很简单,至于...

    1. 大数运算

    在Java中有两个类BigInteger和BigDecimal分别表示不可变的任意精度的整数和不可变的有符号的任意精度的十进制数(浮点数)。

    主要用于高精度计算中。这两个类使得java中的大数,高精度运算变得很简单,至于两个类的对象能表示最大范围不清楚,理论上能够表示无线大的数,只要计算机内存足够大。

    这两个类都在java.math.*包中,因此每次必须在开头处引用该包。

    为什么Java会有这两个大数类出现?

    正常情况下一个整数最多只能放在long类型之中,但是如果现在有如下的一个数字:

    1111111111111111111111111111111111111111111111111

    根本就是无法保存的,所以为了解决这样的问题,在java中引入了两个大数的操作类:

    操作整型:BigInteger

    操作小数:BigDecimal

    当然了,这些大数都会以字符串的形式传入。

    2. BigInteger

    BigInteger类的构造方法:

    构造方法中,采用字符串的形式给出整数

    3. BigDecimal

    在程序中执行下列代码,会出现什么问题?

    double和float类型在运算中很容易丢失精度,造成数据的不准确性,Java提供我们BigDecimal类可以实现浮点数据的高精度运算;

    构造方法如下:

    建议浮点数据以字符串形式给出,因为参数结果是可以预知的

    实现加法减法乘法代码如下:(运算方法与BigInteger一致)

    展开全文
  • 转自:https://blog.csdn.net/stffer/article/details/46382949 有修改 关于BigInteger类更详细的用法请移步...import java.util.*;import java.io.*;import java.math.*;import java.math.*;public class Main {pu...

    转自:https://blog.csdn.net/stffer/article/details/46382949 有修改  关于BigInteger类更详细的用法请移步官方文档

    package practice;

    import java.util.*;

    import java.io.*;

    import java.math.*;

    import java.math.*;

    public class Main {

    public static void main(String []args) {

    Scanner sc=new Scanner(System.in);

    BigInteger a=sc.nextBigInteger();

    BigInteger b=sc.nextBigInteger();

    int n=sc.nextInt();

    BigInteger c=BigInteger.ONE;

    BigDecimal d=sc.nextBigDecimal();

    BigInteger e=sc.nextBigInteger();

    String str=sc.nextLine();

    /*

    //d为int型,a,b,c都为大数

    c=a.add(b); // 相加

    c=a.subtract(b); // 相减

    c=a.multiply(b); // 相乘

    c=a.divide(b); // 相除取整

    c=a.gcd(b); // 最大公约数

    c=a.remainder(b); // 取余

    c=a.mod(b); // a mod b

    c=a.abs(); // a的绝对值

    c=a.negate(); // a的相反数

    c=a.pow(d); // a的b次幂 d为int型

    c=a.max(b); // 取a,b中较大的

    c=a.min(b); // 取a,b中较小的

    d=a.compareTo(b); // 比较a与b的大小 d=-1小于 d=0等于 d=1大于 d为int型

    a.equals(b); // 判断a与b是否相等 相等返回true 不相等返回false

    */

    //加减乘除add,subtract,multiply,divide

    System.out.println(a.add(b));

    System.out.println(a.subtract(b));

    System.out.println(a.multiply(b));

    System.out.println(a.divide(b));

    //阶乘

    //注意BigInteger.valueOf()的使用

    for(int i=1;i<=n;i++) {

    c=c.multiply(BigInteger.valueOf(i));

    }

    System.out.println(c);

    //比较大小

    int flag=a.compareTo(b);

    if(flag==-1) {

    System.out.println("a

    } else if(flag==0) {

    System.out.println("a=b");

    } else {

    System.out.println("a>b");

    }

    //高精度幂

    //stripTrailingZeros():返回数值上等于此小数,但从该表示形式移除所有尾部0的BigDecimal

    //toPlainString():将BigDecimal转换为字符串

    //stratswith("c"):判断该字符串是不是以字符c开头的

    //substring(st,en):返回该字符串减去下标在[st,en)的字符串

    String res=d.pow(n).stripTrailingZeros().toPlainString();

    if(res.startsWith("0")) {

    res=res.substring(0,1);

    }

    System.out.println(res);

    //大数的进制转换

    //先将字符串转化为10进制大数,然后将大数转化为2进制字符串

    e=new BigInteger(str,10);

    String tmp=e.toString(2);

    /*

    d=a.intValue(); // 将大数a转换为 int 类型赋值给 d

    e=a.longValue(); // 将大数a转换为 long 类型赋值给 e

    f=a.floatValue(); // 将大数a转换为 float 类型赋值给 f

    g=a.doubleValue(); // 将大数a转换为 double 类型赋值给 g

    s=a.toString(); // 将大数a转换为 String 类型赋值给 s

    a=BigInteger.valueOf(e); // 将 e 以大数形式赋值给大数 a e只能为long或int

    */

    sc.close();

    }

    }

    展开全文
  • 转载自:... /****************************************************************************************************************************** * 为了解决Java基本数据类型在运算时会出现的

    转载自:http://blog.himdd.com/,同样是一个比较好的博客,推荐~~~~

    /******************************************************************************************************************************
    * 为了解决Java基本数据类型在运算时会出现的溢出和计算不精确的问题。
    * Java 提供了两个类BigInteger和BigDecimal,专门用于进行高精度运算
    * 凡是能用int 或float 做的事情,用BigInteger和BigDecimal也可以做,
    * 只是必须换用方法调用,而不是使用运算符。
    *
    * 高精度整数BigInteger
    * BigInteger支持任意精度的整数,也就是说我们可精确表示任意大小的整数值;同时在运算过程中不会丢失任何信息;
    *
    * 高精度浮点数BigDecimal
    * 它可以表示任意精度的小数,并对它们进行计算。
    * 由于 BigDecimal 对象是不可变的,这些方法中的每一个都会产生新的 BigDecimal 对象。
    * 因此,因为创建对象的开销,BigDecimal 不适合于大量的数学计算,但设计它的目的是用来精确地表示小数。
    ******************************************************************************************************************************/

    import java.math.BigDecimal;
    import java.math.BigInteger;
    public class BigNumber {
    //默认除法运算精度,即保留小数点多少位
    private static final int DEFAULT_DIV_SCALE = 10;
    //这个类不能实例化
    private BigNumber() {
    }
    /**
    * 提供精确的加法运算。
    * @param v1 被加数
    * @param v2 加数
    * @return 两个参数的和
    */
    public static double add(double v1, double v2) {
       BigDecimal b1 = new BigDecimal(Double.toString(v1));
       BigDecimal b2 = new BigDecimal(Double.toString(v2));
       return (b1.add(b2)).doubleValue();
    }
    /**
    * 提供精确的减法运算。
    * @param v1 被减数
    * @param v2 减数
    * @return 两个参数的差
    */
    public static double sub(double v1, double v2) {
       BigDecimal b1 = new BigDecimal(Double.toString(v1));
       BigDecimal b2 = new BigDecimal(Double.toString(v2));
       return (b1.subtract(b2)).doubleValue();
    }
    /**
    * 提供精确的乘法运算。
    * @param v1 被乘数
    * @param v2 乘数
    * @return 两个参数的积
    */
    public static double mul(double v1, double v2) {
       BigDecimal b1 = new BigDecimal(Double.toString(v1));
       BigDecimal b2 = new BigDecimal(Double.toString(v2));
       return (b1.multiply(b2)).doubleValue();
    }
    /**
    * 提供(相对)精确的除法运算,当发生除不尽的情况时,精确到
    * 小数点以后多少位,以后的数字四舍五入。
    * @param v1 被除数
    * @param v2 除数
    * @return 两个参数的商
    */
    public static double div(double v1, double v2) {
       return div(v1, v2, DEFAULT_DIV_SCALE);
    }
    /**
    * 提供(相对)精确的除法运算。当发生除不尽的情况时,由scale参数指
    * 定精度,以后的数字四舍五入。
    * @param v1 被除数
    * @param v2 除数
    * @param scale 表示需要精确到小数点以后几位。
    * @return 两个参数的商
    */
    public static double div(double v1, double v2, int scale) {
       if (scale < 0) {
        System.err.println("除法精度必须大于0!");
        return 0;
       }
       BigDecimal b1 = new BigDecimal(Double.toString(v1));
       BigDecimal b2 = new BigDecimal(Double.toString(v2));
       return (b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP)).doubleValue();
    }
    /**
    * 计算Factorial阶乘!
    * @param n   任意大于等于0的int
    * @return     n!的值
    */
    public static BigInteger getFactorial(int n) {
       if (n < 0) {
        System.err.println("n必须大于等于0!");
        return new BigInteger("-1");
       } else if (n == 0) {
        return new BigInteger("0");
       }
       //将数组换成字符串后构造BigInteger
       BigInteger result = new BigInteger("1");
       for (; n > 0; n--) {
        //将数字n转换成字符串后,再构造一个BigInteger对象,与现有结果做乘法
        result = result.multiply(new BigInteger(new Integer(n).toString()));
       }
       return result;
    }
    public static void main(String[] args) {
       //   如果我们编译运行下面这个程序会看到什么?
       System.out.println(0.05 + 0.01);
       System.out.println(1.0 - 0.42);
       System.out.println(4.015 * 100);
       System.out.println(123.3 / 100);
       //   0.060000000000000005
       //   0.5800000000000001
       //   401.49999999999994
       //   1.2329999999999999
       //计算阶乘,可以将n设得更大
       int n = 30;
       System.out.println("计算n的阶乘" + n + "! = " + BigNumber.getFactorial(n));
       //用double构造BigDecimal
       BigDecimal bd1 = new BigDecimal(0.1);
       System.out.println("(bd1 = new BigDecimal(0.1)) = " + bd1.toString());
       //用String构造BigDecimal
       BigDecimal bd2 = new BigDecimal("0.1");
       System.out.println("(bd2 = new BigDecimal(\"0.1\")) = "
         + bd2.toString());
       BigDecimal bd3 = new BigDecimal("0.10");
       //equals方法比较两个BigDecimal对象是否相等,相等返回true,不等返回false
       System.out.println("bd2.equals(bd3) = " + bd2.equals(bd3));//false
       //compareTo方法比较两个BigDecimal对象的大小,相等返回0,小于返回-1,大于返回1。
       System.out.println("bd2.compareTo(bd3) = " + bd2.compareTo(bd3));//0
       //进行精确计算
       System.out.println("0.05 + 0.01 = " + BigNumber.add(0.05, 0.01));
       System.out.println("1.0 - 0.42 = " + BigNumber.add(1.0, 0.42));
       System.out.println("4.015 * 100 =" + BigNumber.add(4.015, 100));
       System.out.println("123.3 / 100 = " + BigNumber.add(123.3, 100));
       }
    }
    

    /******************************************************************************************************************************************************
    * (1)BigInteger和BigDecimal都是不可变(immutable)的,在进行每一步运算时,都会产生一个新的对象,由于创建对象会引起开销,
    * 它们不适合于大量的数学计算,应尽量用long,float,double等基本类型做科学计算或者工程计算。
    * 设计BigInteger和BigDecimal的目的是用来精确地表示大整数和小数,使用于在商业计算中使用。
    * (2)BigDecimal有4个够造方法,其中的两个用BigInteger构造,另一个是用double构造,还有一个使用String构造。
    * 应该避免使用double构造BigDecimal,因为:有些数字用double根本无法精确表示,传给BigDecimal构造方法时就已经不精确了。
    * 比如,new BigDecimal(0.1)得到的值是0.1000000000000000055511151231257827021181583404541015625。
    * 使用new BigDecimal(“0.1″)得到的值是0.1。因此,如果需要精确计算,用String构造BigDecimal,避免用double构造,尽管它看起来更简单!
    * (3)equals()方法认为0.1和0.1是相等的,返回true,而认为0.10和0.1是不等的,结果返回false。
    * 方法compareTo()则认为0.1与0.1相等,0.10与0.1也相等。所以在从数值上比较两个BigDecimal值时,应该使用compareTo()而不是 equals()。
    * (4)另外还有一些情形,任意精度的小数运算仍不能表示精确结果。例如,1除以9会产生无限循环的小数 .111111…。
    * 出于这个原因,在进行除法运算时,BigDecimal可以让您显式地控制舍入。
    *******************************************************************************************************************************************************/

    运行结果:
    0.060000000000000005
    0.5800000000000001
    401.49999999999994
    1.2329999999999999
    计算n的阶乘30! = 265252859812191058636308480000000
    (bd1 = new BigDecimal(0.1)) = 0.1000000000000000055511151231257827021181583404541015625
    (bd2 = new BigDecimal(“0.1″)) = 0.1
    bd2.equals(bd3) = false
    bd2.compareTo(bd3) = 0
    0.05 + 0.01 = 0.06
    1.0 – 0.42 = 1.42
    4.015 * 100 =104.015
    123.3 / 100 = 223.3


     

    展开全文
  • 一:大数运算出现的背景java里面整型int与浮点型...二:Java中的大数运算Java提供了两个用于高精度计算的类:BigInteger和BigDecimal。创建:需要注意必须使用String类型参数来创建大数变量,而不是用基本类型值...

    一:大数运算出现的背景

    java里面整型int与浮点型float,double它们存放数据的范围是有限的,当出行更大的数值时会发生溢出。

    最典型的场景是金融行业,直接使用单精度或者双精浮点数来表示金额信息会出现精度误差。

    二:Java中的大数运算类

    Java提供了两个用于高精度计算的类:BigInteger和BigDecimal。

    创建:需要注意必须使用String类型参数来创建大数变量,而不是用基本类型值来生成大数变量。

    运算:调用BigInteger和BigDecimal封装好的运算方法即可。

    BigInteger和BigDecimal都是不可变的,每次修改都会新建一个新对象,因为其底层其实是long或数组!

    三:BigDecimal的底层原理

    十进制整数在转化成二进制数时不会有精度问题,那么把十进制小数扩大N倍让它在整数的维度上进行计算,并保留相应的精度信息,就不会有精度损失的问题。

    BigDecimal底层数据结构主要是由下面四个属性值组成

    nt scale; //有多少位小数(即小数点后有多少位)

    int precision; //总工有多少位数字

    long intCompact; //字符串去掉小数点后,转为long的值,只有当传的字符串长度小于18时才使用该言

    BigInteger intVal; //当传的字符串长度大于等于18时才使用BigInteger表示数字

    即:BigDecimal底层的数据结构其实是  将String转为了long或BigInteger来进行计算,当长度小于18时,转化为long类型进行运算,大于等于18时,转化为BigInteger类型进行运算。

    四:BigInteger的底层原理

    1)JDK的BigInteger类里用一个int数组来保存数据:

    int[] mag;

    2)用一个属性来表示正负

    int signum;

    原理:把一个字符串val所代表的的大整数转换并保存mag数组中,把正负保存在signum属性,然后使用数组操作来实现各种运算方法。

    五:Java实现大数四则运算的算法

    todo。

    展开全文
  • * Java 提供了两个类BigInteger和BigDecimal,专门用于进行高精度运算* 凡是能用int 或float 做的事情,用BigInteger和BigDecimal也可以做,* 只是必须换用方法调用,而不是使用运算符。** 高精度整数BigInteger* ...
  • 要想计算更加规模的数,就要用软件来扩展了,比如用数组或字符串来模拟更多规模的数及共运算。 现在输入两个整数,请输出它们的乘积。 数据规模和约定 每个整数不超过10000位 输入 两行,每行一个正整数,每个整数不...
  • 高精度运算(大数运算

    千次阅读 2020-03-24 03:36:31
    高精度运算是指参与运算的数远大于标准数据类型的数,动辄成百上千位的数。所以高精度数又被称为大数。 本文主要讲解:大数加法,...java大数类做这一类题很方便,效率高代码短,但是学会高精度算法还是很有必要的。
  • 今天上了第一次Java课,又得从零开始重新学一门新语言了。就像当年学C语言一样,慢慢做题,熟悉语法。 在oj上做题,可以立即看到正确或者错误的反馈,比较有动力。做了四道题,顺便怀念一下C++。(不过ACM还是要用...
  • * Java 提供了两个类BigInteger和BigDecimal,专门用于进行高精度运算 * 凡是能用int 或float 做的事情,用BigInteger和BigDecimal也可以做, * 只是必须换用方法调用,而不是使用运算符。 *  * 高精度整数...
  • #一:大数运算出现的背景java里面整型int与浮点型...二:Java中的大数运算Java提供了两个用于高精度计算的类:BigInteger和BigDecimal。创建:需要注意必须使用String类型参数来创建大数变量,而不是用基本类型...
  • 转自:https://blog.csdn.net/stffer/article/details/46382949 有修改 关于BigInteger类更详细的用法请移步...import java.util.*;import java.io.*;import java.math.*;import java.math.*;public class Main {pu...
  • 高精度 + 高精度 高精度 - 高精度 高精度 * 高精度 高精度 / 高精度 & 高精度 % 高精度 高精度 * 单精度 高精度幂取模 高精度 + 高精度 题目链接:http://bailian.openjudge.cn/practice/2981?lang=en_US ...
  • 转自:https://blog.csdn.net/stffer/article/details/46382949 有修改 关于BigInteger类更详细的用法请移步官方...import java.util.*; import java.io.*; import java.math.*; import java.math.*; pub...
  • hdu4927 Series 1(组合+公式 Java大数高精度运算
  • Java实现大数运算

    千次阅读 2016-04-24 11:24:53
    它是指由于编程语言提供的基本数值数据类型表示的数值范围有限,不能满足较大规模的高精度数值计算,因此需要利用其他方法实现高精度数值的计算,于是产生了大数运算。 二、Java实现大数运算方法 ...
  • 大数运算Java BigInteger 的基本用法在程序设计竞赛中会遇到高精度运算的问题,C++没有高精度运算,只能手动模拟人工运算,手动实现高精度,而 java.math 包中的 BigInteger 提供了高精度的基本运算,因此竞赛中...
  • 高精度运算java大数

    千次阅读 2014-10-03 16:17:21
    高精度幂 时间限制:3000 ms | 内存限制:65535 KB 难度:2 描述 对数值很大、精度很高的数进行高精度计算是一类十分常见的问题。比如,对国债进行计算就是属于这类问题。  现在要你解决的问题是:对...
  • 它是指由于编程语言提供的基本数值数据类型表示的数值范围有限,不能满足较大规模的高精度数值计算,因此需要利用其他方法实现高精度数值的计算,于是产生了大数运算。二、Java实现大数运算方法在BigDecimal用法详解...
  • 题目链接:Series 1Time Limit: 2000/1000 MS (Java/Others)Memory Limit: 262144/262144 K (Java/Others)Total Submission(s): 423Accepted Submission(s): 146Problem DescriptionLet A be an integral series ...
  • 在用C或者C++处理大数时感觉非常麻烦,但是在Java中有两个类BigInteger和BigDecimal分别表示大整数类和大浮点数类,至于两个类的对象能表示最大范围不清楚,理论上能够表示无线大的数,只要计算机内存足够大。...
  • java 高精度 四则运算

    2014-03-15 09:13:00
    java大数处理对于ACM中的大数来说,相当的简单啊; 整数的运算 BigInteger 小数的运算 BigDecimal 导入类: ...import java.util.Scanner;...java 大数相除不能整除时会抛出异常,解决办法,设置精度;参...
  • Ⅲ.Java高精度实数类 BigDecimal BigDecimal add(BigDecimal augend) :加法 BigDecimal subtract(BigDecimal subtrahend) :减法 BigDecimal multiply(BigDecimal multiplicand) :乘法 BigDecimal divide...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 149
精华内容 59
热门标签
关键字:

java高精度大数运算

java 订阅