「java乘法精度」编程高精度乘法

今天给各位分享java乘法精度的知识，其中也会对编程高精度乘法进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、java里面double 做乘法和加法会丢失精度嘛?
• 2、java中整型乘以一个双精度型的结果是什么类型
• 3、java导出excel的方法中算乘法失去精度怎么办
• 4、怎么控制精度在java
• 5、java如何进行精确运算

java里面double 做乘法和加法会丢失精度嘛?

public BigDecimal(double val)

Translates a double into a BigDecimal which is the exact decimal representation of the double's binary 

floating-point value. The scale of the returned BigDecimal is the 

smallest value such that (10scale × val) is an integer.

Notes: 

Parameters: 

val - double value to be converted to 

BigDecimal.

Throws: 

NumberFormatException - if val is infinite or NaN. 

The results of this constructor can be somewhat unpredictable. One might 

assume that writing new BigDecimal(0.1) in Java creates a 

BigDecimal which is exactly equal to 0.1 (an unscaled value of 1, 

with a scale of 1), but it is actually equal to 

0.1000000000000000055511151231257827021181583404541015625. This is because 0.1 

cannot be represented exactly as a double (or, for that matter, as 

a binary fraction of any finite length). Thus, the value that is being passed 

in to the constructor is not exactly equal to 0.1, appearances 

notwithstanding.

The String constructor, on the other hand, is perfectly 

predictable: writing new BigDecimal("0.1") creates a 

BigDecimal which is exactly equal to 0.1, as one would 

expect. Therefore, it is generally recommended that the String constructor be used in preference to this one.

When a double must be used as a source for a 

BigDecimal, note that this constructor provides an exact 

conversion; it does not give the same result as converting the 

double to a String using the Double.toString(double) method and then using the BigDecimal(String) constructor. To get that result, use the static valueOf(double) method.

这是java.math.BigDecimal类的其中一个构造器的介绍。好好看，格式好像乱了。。传图一直传不上去，不造是为啥。。。。

java中整型乘以一个双精度型的结果是什么类型

java中双精度型变量

java中双精度型变量_java中的基本数据类型



轻之文库

原创

关注

0点赞·860人阅读

什么是变量？

变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间。内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来储存该类型数据。因此，通过定义不同类型的变量，可以在内存中储存整数、小数或者字符。

内置数据类型(基本数据类型)

基本类型，或者叫做内置类型，是Java中不同于类(Class)的特殊类型。它们是我们编程中使用最频繁的类型。

Java是一种强类型语言，第一次申明变量必须说明数据类型，第一次变量赋值称为变量的初始化。

Java基本类型共有八种，基本类型可以分为三类：

六种数字类型(四个整数型，两个浮点型)，一种字符类型，还有一种布尔型。

byte：

byte 数据类型是8位、有符号的，以二进制补码表示的整数；

最小值是 -128(-2^7)；

最大值是 127(2^7-1)；

默认值是 0；

byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；

例子：byte a = 100，byte b = -50。

short：

short 数据类型是 16 位、有符号的以二进制补码表示的整数

最小值是 -32768(-2^15)；

最大值是 32767(2^15 - 1)

java导出excel的方法中算乘法失去精度怎么办

数据缺失可能是精度问题。没看到具体代码 也不知道。你可以试试 BigDecimal b = new BigDecimal（0）.setScale(5),精度可以设大一点，就可以看看。如果不是精度的问题，那具体我就想不到了。POI解析EXCEL 最多的问题就是数据类型的问题。

怎么控制精度在java

JAVA中如何对double或者float的浮点数进行精度计算，在JAVA中提供了多种参数来实现精度的不同控制方式。具体例子如下： 

转自

Java代码 

/* 

 * Created on 2005-6-5 

 * Author stephen 

 * Email zhoujianqiang AT gmail DOT com 

 * CopyRight(C)2005-2008 , All rights reserved. 

 */  

package com.soft4j.utility;  

import java.math.BigDecimal;  

/** 

 * 与小数位精度(四舍五入等)相关的一些常用工具方法. 

 *  

 * float/double的精度取值方式分为以下几种: br 

 * java.math.BigDecimal.ROUND_UP br 

 * java.math.BigDecimal.ROUND_DOWN br 

 * java.math.BigDecimal.ROUND_CEILING br 

 * java.math.BigDecimal.ROUND_FLOOR br 

 * java.math.BigDecimal.ROUND_HALF_UPbr 

 * java.math.BigDecimal.ROUND_HALF_DOWN br 

 * java.math.BigDecimal.ROUND_HALF_EVEN br 

 *  

 * @author stephen 

 * @version 1.0.0 

 */  

public final class RoundTool {  

    /** 

     * 对double数据进行取精度. 

     * p 

     * For example: br 

     * double value = 100.345678; br 

     * double ret = round(value,4,BigDecimal.ROUND_HALF_UP); br 

     * ret为100.3457 br 

     *  

     * @param value 

     *            double数据. 

     * @param scale 

     *            精度位数(保留的小数位数). 

     * @param roundingMode 

     *            精度取值方式. 

     * @return 精度计算后的数据. 

     */  

    public static double round(double value, int scale, int roundingMode) {  

        BigDecimal bd = new BigDecimal(value);  

        bd = bd.setScale(scale, roundingMode);  

        double d = bd.doubleValue();  

        bd = null;  

        return d;  

    }  

    /** 

     * 测试用的main方法. 

     *  

     * @param argc 

     *            运行参数. 

     */  

    public static void main(String[] argc) {  

        //下面都以保留2位小数为例  

        //ROUND_UP  

        //只要第2位后面存在大于0的小数，则第2位就+1  

        System.out.println(round(12.3401,2,BigDecimal.ROUND_UP));//12.35  

        System.out.println(round(-12.3401,2,BigDecimal.ROUND_UP));//-12.35  

        //ROUND_DOWN  

        //与ROUND_UP相反  

        //直接舍弃第2位后面的所有小数  

        System.out.println(round(12.349,2,BigDecimal.ROUND_DOWN));//12.34  

        System.out.println(round(-12.349,2,BigDecimal.ROUND_DOWN));//-12.34  

        //ROUND_CEILING  

        //如果数字0 则和ROUND_UP作用一样  

        //如果数字0 则和ROUND_DOWN作用一样  

        System.out.println(round(12.3401,2,BigDecimal.ROUND_CEILING));//12.35  

        System.out.println(round(-12.349,2,BigDecimal.ROUND_CEILING));//-12.34  

        //ROUND_FLOOR  

        //如果数字0 则和ROUND_DOWN作用一样  

        //如果数字0 则和ROUND_UP作用一样  

        System.out.println(round(12.349,2,BigDecimal.ROUND_FLOOR));//12.34  

        System.out.println(round(-12.3401,2,BigDecimal.ROUND_FLOOR));//-12.35  

        //ROUND_HALF_UP [这种方法最常用]  

        //如果第3位数字=5,则第2位数字+1  

        //备注:只看第3位数字的值,不会考虑第3位之后的小数的  

        System.out.println(round(12.345,2,BigDecimal.ROUND_HALF_UP));//12.35  

        System.out.println(round(12.3449,2,BigDecimal.ROUND_HALF_UP));//12.34  

        System.out.println(round(-12.345,2,BigDecimal.ROUND_HALF_UP));//-12.35  

        System.out.println(round(-12.3449,2,BigDecimal.ROUND_HALF_UP));//-12.34  

        //ROUND_HALF_DOWN  

        //如果第3位数字=5,则做ROUND_UP  

        //如果第3位数字5,则做ROUND_DOWN  

        System.out.println(round(12.345,2,BigDecimal.ROUND_HALF_DOWN));//12.35  

        System.out.println(round(12.3449,2,BigDecimal.ROUND_HALF_DOWN));//12.34  

        System.out.println(round(-12.345,2,BigDecimal.ROUND_HALF_DOWN));//-12.35  

        System.out.println(round(-12.3449,2,BigDecimal.ROUND_HALF_DOWN));//-12.34  

        //ROUND_HALF_EVEN  

        //如果第3位是偶数,则做ROUND_HALF_DOWN  

        //如果第3位是奇数,则做ROUND_HALF_UP  

        System.out.println(round(12.346,2,BigDecimal.ROUND_HALF_EVEN));//12.35  

        System.out.println(round(12.345,2,BigDecimal.ROUND_HALF_EVEN));//12.35  

    }  

}

 如果要求精确控制位数，推荐使用BigDecimal，这是在JDK1.4版本之后推荐的一个处理精度的类。

java如何进行精确运算

importjava.math.BigDecimal;publicclassArith{//默认除法运算精度privatestaticfinalintDEF_DIV_SCALE=10;//这个类不能实例化privateArith(){;}/***提供精确的加法运算。*@paramv1被加数*@paramv2加数*@return 两个参数的和*/publicstaticdoubleadd(doublev1, doublev2){ BigDecimalb1=newBigDecimal(Double.toString(v1)); BigDecimalb2=newBigDecimal(Double.toString(v2));returnb1.add(b2).doubleValue();}/***提供精确的减法运算。*@paramv1被减数*@paramv2减数*@return 两个参数的差*/publicstaticdoublesub(doublev1, doublev2){ BigDecimalb1=newBigDecimal(Double.toString(v1)); BigDecimalb2=newBigDecimal(Double.toString(v2));returnb1.subtract(b2).doubleValue();}/***提供精确的乘法运算。*@paramv1被乘数*@paramv2乘数*@return 两个参数的积*/publicstaticdoublemul(doublev1, doublev2){ BigDecimalb1=newBigDecimal(Double.toString(v1)); BigDecimalb2=newBigDecimal(Double.toString(v2));returnb1.multiply(b2).doubleValue();}/***提供（相对）精确的除法运算，当发生除不尽的情况时，精确到*小数点以后10位，以后的数字四舍五入。*@paramv1被除数*@paramv2除数*@return 两个参数的商*/publicstaticdoublediv(doublev1, doublev2){returndiv(v1,v2,DEF_DIV_SCALE);}/***提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指*定精度，以后的数字四舍五入。

关于java乘法精度和编程高精度乘法的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。