java里面的高精度运算
1 package com.lv.study.am.first;
2
3 import java.math.BigDecimal;
4
5 public class TestBigDecimal {
6
7 public static void main(String[] args) {
8
9 // double d1=1.0;
10 // double d2=0.9;
11
12 // System.out.println(d1-d2);//0.1
13
14 // 计算机语言-》 二进制 01
15
16 // 计算10/3
17
18 // 漏洞 吧小数点后小于2角的全部打到自己的账号里面
19
20 // test1();
21 // test3();
22 test4();
23
24 }
25
26 // 减法
27 public static void test4() {
28 BigDecimal bd1 = new BigDecimal(1.0);// 这个类没有无参的构造器
29 BigDecimal bd2 = new BigDecimal(0.9999);
30
31 BigDecimal result = bd1.subtract(bd2);//
32
33 System.out.println(result.floatValue());// 得到浮点类型
34 System.out.println(result.intValue());//得到int类型
35 System.out.println(result.longValue());
36
37 System.out.println(result.setScale(10,BigDecimal.ROUND_HALF_UP));
38
39 System.out.printf("%");
40 }
41
42 // 乘法
43 public static void test3() {
44 BigDecimal bd1 = new BigDecimal(1.0);// 这个类没有无参的构造器
45 BigDecimal bd2 = new BigDecimal(0.9);
46
47 BigDecimal result = bd1.multiply(bd2);//
48
49 System.out.println(result.floatValue());// 得到浮点类型
50 System.out.println(result.intValue());
51 }
52
53 // 加法
54 public static void test2() {
55 BigDecimal bd1 = new BigDecimal(1.0);// 这个类没有无参的构造器
56 BigDecimal bd2 = new BigDecimal(0.9);
57
58 BigDecimal result = bd1.add(bd2);// 做加法
59
60 System.out.println(result.floatValue());// 得到浮点类型
61 System.out.println(result.intValue());
62 }
63
64 public static void test1() {
65
66 BigDecimal bd1 = new BigDecimal(1.0);// 这个类没有无参的构造器
67 BigDecimal bd2 = new BigDecimal(0.9);
68
69 // 在计算时候没有指定余下多少位小数和他的小数怎么进位就会报异常
70 // System.out.println(bd1.divide(bd2).setScale(2,BigDecimal.ROUND_HALF_UP));//
71 // 1/0.9->1.1111111
72
73 // bd1： 被除数 bd2： 除数 2：留下的几位小数 ROUND_HALF_UP ：四舍五入
74 System.out.println(bd1.divide(bd2, 2, BigDecimal.ROUND_HALF_UP));// 静态常量所有字母大写
75
76 // 一般涉及到比较敏感的金额不会用double
77 Double d1 = new Double(1.0);
78 Double d2 = new Double(0.9);
79
80 // 除法运算
81 // System.out.println(d1/d2);
82 // System.out.println(d1+d2);
83 // System.out.println(d1-d2);
84 // System.out.println(d1*d2);
85 }
86
87 }
下面具体讲解
1 BigDecimal类处理高精度计算
2 Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数，但在实际应用中，可能需要对更大或者更小的数进行运算和处理。一般情况下，对于那些不需要准确计算精度的数字，我们可以直接使用Float和Double处理，但是Double.valueOf(String) 和Float.valueOf(String)会丢失精度。所以开发中，如果我们需要精确计算的结果，则必须使用BigDecimal类来操作啦！
3
4 （一）BigDecimal类的常用的几个构造方法
5
6 BigDecimal(int)：将int表示形式转换为BigDecimal对象
7 BigDecimal(String) ：将字符串表示形式转换为BigDecimal对象
8 BigDecimal(double)：将double表示形式转换为BigDecimal对象
9 （二）BigDecimal类的常用方法
10
11 add(BigDecimal)：BigDecimal对象中的值相加，返回BigDecimal对象
12 subtract(BigDecimal)：BigDecimal对象中的值相减，返回BigDecimal对象
13 multiply(BigDecimal)：BigDecimal对象中的值相乘，返回BigDecimal对象
14 divide(BigDecimal)：BigDecimal对象中的值相除，返回BigDecimal对象
15 toString()：将BigDecimal对象中的值转换成字符串
16 doubleValue()：将BigDecimal对象中的值转换成双精度数
17 floatValue()：将BigDecimal对象中的值转换成单精度数
18 longValue()：将BigDecimal对象中的值转换成长整数
19 intValue()：将BigDecimal对象中的值转换成整数
20
21 //常用的;一般情况下,使用的都是四舍五入
22 BigDecimal.ROUND_HALF_UP表示四舍五入，
23 BigDecimal.ROUND_HALF_DOWN也是五舍六入，
24 BigDecimal.ROUND_UP表示进位处理（就是直接加1），
25 BigDecimal.ROUND_DOWN表示直接去掉尾数。
26 1: 加减乘除
27 BigDecimal bignum1 = new BigDecimal("10");
28 BigDecimal bignum2 = new BigDecimal("5");
29 BigDecimal bignum3 = null;
30
31 //加法
32 bignum3 = bignum1.add(bignum2);
33 System.out.println("和 是：" + bignum3);
34
35 //减法
36 bignum3 = bignum1.subtract(bignum2);
37 System.out.println("差 是：" + bignum3);
38
39 //乘法
40 bignum3 = bignum1.multiply(bignum2);
41 System.out.println("积 是：" + bignum3);
42
43 //除法
44 bignum3 = bignum1.divide(bignum2);
45 System.out.println("商 是：" + bignum3);
46
47 2: 比较大小
48
49 BigDecimal a = new BigDecimal (888);
50 BigDecimal b = new BigDecimal (666);
51
52 //使用compareTo方法比较
53 //注意：a、b均不能为null，否则会报空指针
54 if(a.compareTo(b) == -1){
55 System.out.println("a小于b");
56 }
57
58 if(a.compareTo(b) == 0){
59 System.out.println("a等于b");
60 }
61
62 if(a.compareTo(b) == 1){
63 System.out.println("a大于b");
64 }
65
66 if(a.compareTo(b) > -1){
67 System.out.println("a大于等于b");
68 }
69
70 if(a.compareTo(b) < 1){
71 System.out.println("a小于等于b");
72
73 // 四舍五入 保留两位小数
74 new BigDecimal("1024.1234").setScale(2,BigDecimal.ROUND_HALF_UP);
75
76
77
78 //默认除法运算精度
79 private static final int DEF_DIV_SCALE = 10;
80
81 /**
82 * 提供精确的加法运算
83 *
84 * @param v1 被加数
85 * @param v2 加数
86 * @return 两个参数的和
87 */
88
89 public static double add(double v1, double v2) {
90 BigDecimal b1 = new BigDecimal(Double.toString(v1));
91 BigDecimal b2 = new BigDecimal(Double.toString(v2));
92 return b1.add(b2).doubleValue();
93 }
94
95 /**
96 * 提供精确的加法运算
97 *
98 * @param v1 被加数
99 * @param v2 加数
100 * @return 两个参数的和
101 */
102 public static BigDecimal add(String v1, String v2) {
103 BigDecimal b1 = new BigDecimal(v1);
104 BigDecimal b2 = new BigDecimal(v2);
105 return b1.add(b2);
106 }
107
108 /**
109 * 提供精确的加法运算
110 *
111 * @param v1 被加数
112 * @param v2 加数
113 * @param scale 保留scale 位小数
114 * @return 两个参数的和
115 */
116 public static String add(String v1, String v2, int scale) {
117 if (scale < 0) {
118 throw new IllegalArgumentException(
119 "The scale must be a positive integer or zero");
120 }
121 BigDecimal b1 = new BigDecimal(v1);
122 BigDecimal b2 = new BigDecimal(v2);
123 return b1.add(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
124 }
125
126 /**
127 * 提供精确的减法运算
128 *
129 * @param v1 被减数
130 * @param v2 减数
131 * @return 两个参数的差
132 */
133 public static double sub(double v1, double v2) {
134 BigDecimal b1 = new BigDecimal(Double.toString(v1));
135 BigDecimal b2 = new BigDecimal(Double.toString(v2));
136 return b1.subtract(b2).doubleValue();
137 }
138
139 /**
140 * 提供精确的减法运算。
141 *
142 * @param v1 被减数
143 * @param v2 减数
144 * @return 两个参数的差
145 */
146 public static BigDecimal sub(String v1, String v2) {
147 BigDecimal b1 = new BigDecimal(v1);
148 BigDecimal b2 = new BigDecimal(v2);
149 return b1.subtract(b2);
150 }
151
152 /**
153 * 提供精确的减法运算
154 *
155 * @param v1 被减数
156 * @param v2 减数
157 * @param scale 保留scale 位小数
158 * @return 两个参数的差
159 */
160 public static String sub(String v1, String v2, int scale) {
161 if (scale < 0) {
162 throw new IllegalArgumentException(
163 "The scale must be a positive integer or zero");
164 }
165 BigDecimal b1 = new BigDecimal(v1);
166 BigDecimal b2 = new BigDecimal(v2);
167 return b1.subtract(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
168 }
169
170 /**
171 * 提供精确的乘法运算
172 *
173 * @param v1 被乘数
174 * @param v2 乘数
175 * @return 两个参数的积
176 */
177 public static double mul(double v1, double v2) {
178 BigDecimal b1 = new BigDecimal(Double.toString(v1));
179 BigDecimal b2 = new BigDecimal(Double.toString(v2));
180 return b1.multiply(b2).doubleValue();
181 }
182
183 /**
184 * 提供精确的乘法运算
185 *
186 * @param v1 被乘数
187 * @param v2 乘数
188 * @return 两个参数的积
189 */
190 public static BigDecimal mul(String v1, String v2) {
191 BigDecimal b1 = new BigDecimal(v1);
192 BigDecimal b2 = new BigDecimal(v2);
193 return b1.multiply(b2);
194 }
195
196
197 /**
198 * 提供精确的乘法运算
199 *
200 * @param v1 被乘数
201 * @param v2 乘数
202 * @param scale 保留scale 位小数
203 * @return 两个参数的积
204 */
205 public static double mul(double v1, double v2, int scale) {
206 BigDecimal b1 = new BigDecimal(Double.toString(v1));
207 BigDecimal b2 = new BigDecimal(Double.toString(v2));
208 return round(b1.multiply(b2).doubleValue(), scale);
209 }
210
211 /**
212 * 提供精确的乘法运算
213 *
214 * @param v1 被乘数
215 * @param v2 乘数
216 * @param scale 保留scale 位小数
217 * @return 两个参数的积
218 */
219 public static String mul(String v1, String v2, int scale) {
220 if (scale < 0) {
221 throw new IllegalArgumentException(
222 "The scale must be a positive integer or zero");
223 }
224 BigDecimal b1 = new BigDecimal(v1);
225 BigDecimal b2 = new BigDecimal(v2);
226 return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
227 }
228
229 /**
230 * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
231 * 小数点以后10位，以后的数字四舍五入
232 *
233 * @param v1 被除数
234 * @param v2 除数
235 * @return 两个参数的商
236 */
237
238 public static double div(double v1, double v2) {
239 return div(v1, v2, DEF_DIV_SCALE);
240 }
241
242 /**
243 * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
244 * 定精度，以后的数字四舍五入
245 *
246 * @param v1 被除数
247 * @param v2 除数
248 * @param scale 表示表示需要精确到小数点以后几位。
249 * @return 两个参数的商
250 */
251 public static double div(double v1, double v2, int scale) {
252 if (scale < 0) {
253 throw new IllegalArgumentException("The scale must be a positive integer or zero");
254 }
255 BigDecimal b1 = new BigDecimal(Double.toString(v1));
256 BigDecimal b2 = new BigDecimal(Double.toString(v2));
257 return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
258 }
259
260 /**
261 * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
262 * 定精度，以后的数字四舍五入
263 *
264 * @param v1 被除数
265 * @param v2 除数
266 * @param scale 表示需要精确到小数点以后几位
267 * @return 两个参数的商
268 */
269 public static String div(String v1, String v2, int scale) {
270 if (scale < 0) {
271 throw new IllegalArgumentException("The scale must be a positive integer or zero");
272 }
273 BigDecimal b1 = new BigDecimal(v1);
274 BigDecimal b2 = new BigDecimal(v1);
275 return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString();
276 }
277
278 /**
279 * 提供精确的小数位四舍五入处理
280 *
281 * @param v 需要四舍五入的数字
282 * @param scale 小数点后保留几位
283 * @return 四舍五入后的结果
284 */
285 public static double round(double v, int scale) {
286 if (scale < 0) {
287 throw new IllegalArgumentException("The scale must be a positive integer or zero");
288 }
289 BigDecimal b = new BigDecimal(Double.toString(v));
290 return b.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
291 }
292
293 /**
294 * 提供精确的小数位四舍五入处理
295 *
296 * @param v 需要四舍五入的数字
297 * @param scale 小数点后保留几位
298 * @return 四舍五入后的结果
299 */
300 public static String round(String v, int scale) {
301 if (scale < 0) {
302 throw new IllegalArgumentException(
303 "The scale must be a positive integer or zero");
304 }
305 BigDecimal b = new BigDecimal(v);
306 return b.setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
307 }
308
309
310 /**
311 * 取余数
312 *
313 * @param v1 被除数
314 * @param v2 除数
315 * @param scale 小数点后保留几位
316 * @return 余数
317 */
318 public static String remainder(String v1, String v2, int scale) {
319 if (scale < 0) {
320 throw new IllegalArgumentException(
321 "The scale must be a positive integer or zero");
322 }
323 BigDecimal b1 = new BigDecimal(v1);
324 BigDecimal b2 = new BigDecimal(v2);
325 return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
326 }
327
328 /**
329 * 取余数 BigDecimal
330 *
331 * @param v1 被除数
332 * @param v2 除数
333 * @param scale 小数点后保留几位
334 * @return 余数
335 */
336 public static BigDecimal remainder(BigDecimal v1, BigDecimal v2, int scale) {
337 if (scale < 0) {
338 throw new IllegalArgumentException(
339 "The scale must be a positive integer or zero");
340 }
341 return v1.remainder(v2).setScale(scale, BigDecimal.ROUND_HALF_UP);
342 }
343
344 /**
345 * 比较大小
346 *
347 * @param v1 被比较数
348 * @param v2 比较数
349 * @return 如果v1 大于v2 则 返回true 否则false
350 */
351 public static boolean compare(String v1, String v2) {
352 BigDecimal b1 = new BigDecimal(v1);
353 BigDecimal b2 = new BigDecimal(v2);
354 int bj = b1.compareTo(b2);
355 boolean res;
356 if (bj > 0)
357 res = true;
358 else
359 res = false;
360 return res;
361 }
java里面的高精度运算的更多相关文章
- java中小数的处理：高精度运算用bigDecimal类，精度保留方法，即舍入方式的指定
一. 计算机的小数计算一定范围内精确,超过范围只能取近似值: 计算机存储的浮点数受存储bit位数影响,只能保证一定范围内精准,超过bit范围的只能取近似值. java中各类型的精度范围参见:http: ...
- ICPC Asia Nanning 2017 F. The Chosen One (高精度运算)
题目链接:The Chosen One 比赛链接:ICPC Asia Nanning 2017 题意 \(t\) 组样例,每组给出一个整数 \(n(2\le n\le 10^{50})\),求不大于 ...
- java ->大的数据运算（BigInteger）
大数据运算 BigInteger java中long型为最大整数类型,对于超过long型的数据如何去表示呢.在Java的世界中,超过long型的整数已经不能被称为整数了,它们被封装成BigIntege ...
- Java中的递归运算
Java中的递归运算是一种在自己的方法内部调用自己的方法 递归的设计思想是:把一个复杂的问题,分解为若干个等同的子问题,重复执行,直到之问题能够简单到直接求解,这样复杂的问题就得以解决. 递归运算有两 ...
- 高精度运算专题3-乘法运算（The multiplication operation）
这个专题呢,我就来讲讲高精度的乘法,下面是三个计算乘法的函数,第一个函数是char类型的,要对字符串进行数字转换,而第二个是两个int类型的数组,不用转换成数字,第三个则更为优化,用a数组-b数组放回 ...
- [code]高精度运算
数组存储整数,模拟手算进行四则运算 阶乘精确值 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 #includ ...
- 系统的讲解 - PHP 浮点数高精度运算
目录 概述 浮点数运算的"锅" 任意精度数学函数 常用数值处理方案 扩展 小结 概述 记录下,工作中遇到的坑 ... 关于 PHP 浮点数运算,特别是金融行业.电子商务订单管理.数 ...
- #C++初学记录(高精度运算)（加法）
高精度运算 不管是int还是double亦或者long long ,这些定义变量都有数据范围的一定限制,在计算位数超过十几位的数,也就是超过他们自身的数据范围时,不能采用现有类型进行计算,只能自己通过 ...
- 关于Java中用Double型运算时精度丢失的问题
注:转自 https://blog.csdn.net/bleach_kids/article/details/49129943 在使用Java,double 进行运算时,经常出现精度丢失的问题,总是在 ...
- java 整除(/) 求余(%) 运算
1. java 整除(/) 求余(%) 运算 1.求余 System.out.println(11%2); //顾名思义就是11除2的余数-->1 System.out. ...
随机推荐
- 【Azure Developer】分享两段Python代码处理表格(CSV格式)数据 : 根据每列的内容生成SQL语句
问题描述 在处理一个数据收集工作任务上,收集到的数据内容格式都不能直接对应到数据库中的表格内容. 比如: 第一种情况:服务名作为第一列内容,然后之后每一列为一个人名,1:代表此人拥有这个服务,0:代表 ...
- HashMap遍历方法
HashMap是Java中非常常用的集合类,用于存储键值对映射.遍历HashMap的方法有多种,每种方法有其特定的用途和效率.以下是几种常用的遍历方法: 1. 使用 entrySet 遍历 这是最常用 ...
- Debian 下安装 Nginx
Debian 下安装 Nginx 非常容易. apt update apt install nginx 输入以下命令查看是否可以正常访问, 顺便验证下安装是否成功. curl -I 127.0.0.1 ...
- exim4
exim4 一台 debian 机器日常执行 apt update 后发现需要更新如下软件包, 之前没见过, 特此记录下. root@idebian:~# apt list --upgradable ...
- 创建windows脚本bat/cmd或jar为windows服务完整教程
一.将windows bat/cmd脚本创建为windows服务 1.下载winsw工具 https://gitee.com/colinisg/winsw/releases/download/v2 ...
- DevSecOps的实现与相关开源工具
DevSecOps的实现与相关开源工具 DevSecOps是一种以自动化方式在DevOps流程中集成安全工具的方法.DevSecOps不仅仅是引入新的安全工具,还包括关于使用这些工具的必要知识.这需要 ...
- 🎀Nginx 安全设置(禁止Iframe跨域访问、隐藏server、限制ip访问)
1.安装[headers-more-nginx-module]模块,自定义nginx头信息 2.禁止Iframe跨域请求 more_set_headers 'X-Frame-Options SAMEO ...
- 『Plotly实战指南』--布局进阶篇
在数据可视化领域,Plotly的子图布局是打造专业级仪表盘的核心武器. 当面对多维数据集时,合理的子图布局能显著提升多数据关联分析效率,让数据的呈现更加直观和美观. 本文将深入探讨Plotly中子图布 ...
- 关于wireshark抓包工具抓取登录数据的一点心得
研究这个软件很久了,一直处于门外汉状态,今天终于用它抓到点有用的东西,做个简单的笔记吧,后面再继续完善. 最近研究跨域自动登录时一直不太顺利,今天就仿照网上前辈们的方法,用wireshark先抓一下手 ...
- 使用TypeScript开发微信小程序(云开发)-入门篇
配置小程序云开发 TypeScript 环境 1. 检查本地 nodejs 环境 2. 安装 TypeScript npm install typescript --save-dev 3. 初始化/配 ...