java加减时四舍五入_java中高精度加减乘除及四舍五入、点分法

最新推荐文章于 2024-07-08 10:32:28 发布
最新推荐文章于 2024-07-08 10:32:28 发布
阅读量195 收藏
点赞数
文章标签： java加减时四舍五入
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_33842969/article/details/114246131
版权

package com.util;

public class NumberUtil {

private int precision = 8;// 除法运算的精度，小数位

public NumberUtil(int precision) {

if (precision > 0) {

this.precision = precision;

} else {

this.precision = precision - 1;

}

}

public NumberUtil() {

}

public static void main(String[] args) {

NumberUtil nu = new NumberUtil(20);

System.out.println(System.currentTimeMillis());

System.out.println();

// System.out.println(nu.add(".2", "0.003"));

// System.out.println(nu.minus("100", "-200"));

// System.out.println(nu.multiply("0.00000023",

"67823412"));

System.out.println(nu.divided("36", "5"));

// System.out.println(nu.round("9999.999999999999",

10));

// System.out.println(nu.splitNum("12341234124"));

System.out.println();

System.out.println(System.currentTimeMillis());

}

public String divided(String num1, String num2) {

String ret = "0";

if (num1 == null || num2 == null)

return null;

num1 = num1.replaceAll(" ", "");

num2 = num2.replaceAll(" ", "");

boolean fs1 = false, fs2 = false;

if (num1.length() > 0) {

fs1 = num1.charAt(0) == '-';

if (fs1)

num1 = num1.substring(1);

}

if (num2.length() > 0) {

fs2 = num2.charAt(0) == '-';

if (fs2)

num2 = num2.substring(1);

}

if (fs1 == fs2) {

ret = dividedCore(num1, num2);

} else {

ret = "-" + dividedCore(num1, num2);

}

return ret;

}

private String dividedCore(String num1, String num2) {

String[] nums = trimNum(num1, num2);

num1 = nums[0].replaceAll("\\.", "");

num2 = nums[1].replaceAll("\\.", "");

if ("0".equals(prettyNum(num2)) || "".equals(num2)) {

System.out.println("除数不能为0！");

return null;

}

String tmp = "", ret = "", shang = "0";

boolean enough = true, start = false, step = false;

int i = 0, pos = 0;

while (pos++ < num1.length() || i++ <= precision)

{

if (pos <= num1.length()) {

tmp += num1.substring(pos - 1, pos);

} else {

tmp += "0";

}

enough = true;

shang = "0";

while (enough) {

tmp = minusCore(tmp, num2);

enough = tmp.charAt(0) != '-';

if (enough) {

shang = addCore(shang, "1");

start = true;

} else {

tmp = add(tmp, num2);

}

}

ret += shang;

if ("0".equals(tmp) && start && pos >=

num1.length()) {

step = true;

break;

}

if (pos == num1.length()) {

ret += ".";

}

}

if (ret.indexOf(".") != -1 && !step

&& ret.length() - ret.indexOf(".") > i - 1) {//

对于除不净的四舍五入

ret = round(ret, i - 2);

}

ret = prettyNum(ret);

return ret;

}

public String movePoint(String num, int offset) {

int dot = num.indexOf("."), pos;

dot = dot == -1 ? num.length() : dot;

dot = dot + offset;

pos = dot;

num = num.replaceAll("\\.", "");

if (dot < 0 && offset < 0) {

while (dot++ < 1) {

num = "0" + num;

}

} else if (offset > 0 && dot > num.length())

{

while (dot > num.length()) {

num += "0";

}

}

pos = pos < 0 ? 1 : pos;

StringBuilder s = new StringBuilder(num);

if (pos != num.length())

s.insert(pos, ".");

return s.toString();

}

public String multiply(String num1, String num2) {

String ret = "0";

if (num1 == null || num2 == null)

return null;

num1 = num1.replaceAll(" ", "");

num2 = num2.replaceAll(" ", "");

boolean fs1 = false, fs2 = false;

if (num1.length() > 0) {

fs1 = num1.charAt(0) == '-';

if (fs1)

num1 = num1.substring(1);

}

if (num2.length() > 0) {

fs2 = num2.charAt(0) == '-';

if (fs2)

num2 = num2.substring(1);

}

if (fs1 == fs2) {

ret = multiplyCore(num1, num2);

} else {

ret = "-" + multiplyCore(num1, num2);

}

return ret;

}

private String multiplyCore(String num1, String num2) {

String ret = "0";

int dot = num2.indexOf("."), len = num2.length();

dot = dot == -1 ? num2.length() - 1 : dot;

int tmpNum;

String tmp;

while (len-- > 0) {

tmp = "0";

if (num2.charAt(len) == '.') {

dot--;

continue;

}

tmpNum =

Integer.valueOf(String.valueOf(num2.charAt(len)));

while (tmpNum-- > 0) {

tmp = addCore(num1, tmp);

}

tmp = movePoint(tmp, dot - len);

ret = addCore(ret, tmp);

}

return ret;

}

public String splitNum(String num) {

int end = num.indexOf(".");

if (end == -1) {

end = num.length();

}

StringBuilder s = new StringBuilder(num);

while ((end = end - 3) > 0) {

s.insert(end, ',');

}

return s.toString();

}

public String round(String num, int scale) {

if (scale <= 0)

return num;

String rd = "0.";

int len = scale;

while (scale-- > 0) {

rd += "0";

}

rd += "5";

num = add(num, rd);

num = num.substring(0, num.indexOf(".") + len + 1);

return num;

}

public String minus(String num1, String num2) {

String sum = null;

if (num1 == null || num2 == null)

return null;

num1 = num1.replaceAll(" ", "");

num2 = num2.replaceAll(" ", "");

boolean fs1 = false, fs2 = false;

if (num1.length() > 0) {

fs1 = num1.charAt(0) == '-';

if (fs1)

num1 = num1.substring(1);

}

if (num2.length() > 0) {

fs2 = num2.charAt(0) == '-';

if (fs2)

num2 = num2.substring(1);

}

if (fs1 == fs2) {// 同号

sum = minusCore(num1, num2);

if (fs1 && sum.length() > 0) {

if (sum.charAt(0) == '-') {

sum = sum.substring(1);

} else {

sum = "-" + sum;

}

}

} else {

sum = (fs1 ? "-" : "") + addCore(num1, num2);

}

return sum;

}

private String minusCore(String num1, String num2) {

String[] nums = trimNum(num1, num2);

num1 = nums[0];

num2 = nums[1];

String ret = "";

int length = num1.length();

short a, b, c;

boolean p = false;

while (length-- > 0) {

if (num1.charAt(length) == '.') {

ret = "." + ret;

continue;

}

a = Short.valueOf(String.valueOf(num1.charAt(length)));

b = Short.valueOf(String.valueOf(num2.charAt(length)));

c = (short) (a - b - (p ? 1 : 0));

p = c < 0;

ret = (p ? (c + 10) : c) + ret;

}

ret = p ? minus(num2, num1) : ret;

ret = prettyNum(ret);

return p ? ("-" + ret) : ret;

}

public String add(String num1, String num2) {

String sum = null;

if (num1 == null || num2 == null)

return null;

num1 = num1.replaceAll(" ", "");

num2 = num2.replaceAll(" ", "");

boolean fs1 = false, fs2 = false;

if (num1.length() > 0) {

fs1 = num1.charAt(0) == '-';

if (fs1)

num1 = num1.substring(1);

}

if (num2.length() > 0) {

fs2 = num2.charAt(0) == '-';

if (fs2)

num2 = num2.substring(1);

}

if (fs1 == fs2) {// 同号

sum = (fs1 ? "-" : "") + addCore(num1, num2);

} else {

sum = minusCore(fs1 ? num2 : num1, fs2 ? num2 : num1);

}

return sum;

}

private String addCore(String num1, String num2) {

String[] nums = trimNum(num1, num2);

num1 = nums[0];

num2 = nums[1];

String sum = "";

int length = num1.length();

boolean p = false;

short a, b, c;

while (length-- > 0 || p) {

a = b = 0;

if (length >= 0) {

if (num1.charAt(length) == '.') {

sum = "." + sum;

continue;

}

a = Short.valueOf(String.valueOf(num1.charAt(length)));

b = Short.valueOf(String.valueOf(num2.charAt(length)));

}

c = (short) (a + b + (p ? 1 : 0));

sum = c % 10 + sum;

p = c > 9;

}

return prettyNum(sum);

}

public String[] trimNum(String num1, String num2) {

if (num1.indexOf(".") == -1) {

num1 = num1 + ".";

}

if (num2.indexOf(".") == -1) {

num2 = num2 + ".";

}

while (num1.length() != num2.length()

|| num1.indexOf(".") != num2.indexOf(".")) {

if (num1.indexOf(".") > num2.indexOf(".") ||

num2.indexOf(".") == 0) {

num2 = "0" + num2;

continue;

} else if (num1.indexOf(".") < num2.indexOf(".")

|| num1.indexOf(".") == 0) {

num1 = "0" + num1;

continue;

}

if (num1.length() > num2.length()) {

num2 = num2 + "0";

continue;

} else if (num1.length() < num2.length()) {

num1 = num1 + "0";

}

}

return new String[] { num1, num2 };

}

private String prettyNum(String num) {

if (null == num || "".equals(num))

return num;

int i = 0;

while ('0' == num.charAt(i++) && i <

num.length())

;

num = num.substring(i - 1);

if (num.indexOf(".") != -1) {

i = num.length();

while ('0' == num.charAt(--i))

;

num = num.substring(0, i + 1);

}

i = num.length();

if (i == 1 && '.' == num.charAt(0)) {// 为0

num = "0";

} else if (i > 1 && num.indexOf(".") == 0) {//

在最前面

num = "0" + num;

} else if (i > 1 && num.indexOf(".") == i - 1) {//

在最后面

num = num.substring(0, i - 1);

}

return num;

}

}

guenchi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
四舍五入 java_Java中四舍五入
weixin_42525343的博客
02-19 721
Java有四舍五入函数--Math.round，通过一个例子看看他的用法：package math;public class MathRoundTest {/*** Math类中提供了三个与取整有关的方法：ceil,floor,round,* 这些方法的作用于它们的英文名称的含义相对应，例如：ceil的英文意义是天花板，该方法就表示向上取整，* Math.ceil(11.3)的结果为12，Math...
Java 加减乘除工具类（解决精度损失问题）
07-18
唔，其实里面就是一个工具类，加减乘除、保留两位小数。一共5个方法。。。emmmm.....为啥分这么高呢。因为宝宝想分想疯了。 附代码，有土豪就打赏打赏，没土豪的直接拿去使吧。 package cn.cisdom.base.utils; ...
加减乘除等工具NumberUtils
08-16
支持+-*/，格式化数字，四舍五入等，BigDecimal精准处理
java加减时四舍五入_JAVA大数类—基础操作（加减乘除、取模、四舍五入、设置保留位数）...
weixin_34665386的博客
02-25 304
当基础数据类型长度无法满足需求时可以使用大数类构造方法接受字符串为参数1 BigInteger bInt = new BigInteger("123123");2 BigDecimal bDouble = new BigDecimal("123123.123123124");基础操作(取模使用divideAndRemainder方法，返回的数组第二个元素为余数)： BigDecimal在做除法时必...
Java中几种常见的四舍五入方法
最新发布
AOMGyz的博客
07-08 2386
在Java中，四舍五入到特定的小数位数是一个常见的需求，可以通过多种方式实现。
java四舍五入
asd199205的博客
06-16 1064
java中Math类中提供了三个与取整有关的方法： 分别是ceil、floor、round,这些方法的作用与它们的英文名称的含义相对应 ceil的英文解释是天花板,该方法就表示向上取整,所以,Math.ceil(16.2)的结果为16,Math.ceil(-16.2)的结果是-16； floor的英文解释是地板,所以该方法就表示向下取整,那么Math.floor(16.6)的结果
POJ 3077 Rounders（我的水题之路——高精度四舍五入）
02-13 1378
Rounders Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 6419   Accepted: 4155 Description For a given number, if greater than ten, round it to the nearest
java中BigDecimal进行加减乘除的基本用法
09-01
在Java编程语言中，`BigDecimal` 类位于 `java.math` 包下，它提供了一种进行高精度和任意精度的十进制算术运算的方法。`BigDecimal` 是为那些需要精确数值计算的场景设计的，比如金融计算或会计应用，因为普通的 `...
【Java】BigDecimal实现加减乘除运算代码
08-31
在Java编程中，进行高精度的数学计算时，通常会使用`java.math.BigDecimal`类，因为Java中的简单数据类型如`float`和`double`在处理大数或精确计算时可能会出现误差。`BigDecimal`类提供了加减乘除等运算方法，确保...
MathTask_单元测试_加减乘除运算_
10-01
"MathTask_单元测试_加减乘除运算_"这个标题暗示我们正在处理一个与数学运算相关的项目，特别是涉及基本的加法、减法、乘法和除法。这个项目可能是一个计算器应用、一个数学库或者任何其他需要进行数值计算的软件...
java 加减乘除工具类_BigDecimal - 用于加、减、乘、除计算的工具类
weixin_35756892的博客
03-07 1375
开发过程中经常会需要进行一些数据的运算操作，比如加、减、乘、除，但是在计算过程中，到底使用哪种数据类型进行计算才是最合适的呢？1、数据类型1.1、 基础数据类型int：只能进行整数的计算，应用范围单一。float：单精度浮点型，可以进行小数类型的计算，但是容易丢失精度。double：双精度浮点型，精确度比float高，消耗的内存也比float高，但是也容易丢失精度。String：字符串类型，没法进...
java进行四舍五入_JAVA正确的四舍五入方法
weixin_29649047的博客
02-13 1070
原文：http://www.cnblogs.com/yangzhilong/p/8405840.html在JDK版本为1.8的情况运行下面的代码，会发现很神奇的情况(见运行结果)。看如下代码：package com.longge.mytest;import java.math.BigDecimal;import java.math.RoundingMode;import java.text.Dec...
Java中BigDecimal的使用：加减乘除、四舍五入、比较大小、资金统计
pan_junbiao的博客
12-19 4499
Java在 java.math 包中提供的API类 BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数。在实际应用中，需要对更大或者更小的数进行运算和处理。float和double只能用来做科学计算或者是工程计算，在商业计算中要用java.math.BigDecimal。BigDecimal所创建的是对象，我们不能使用传统的+、-、*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象
java使用BigDecimal实现加减乘除法四四舍五入
爱java的小蓝的博客
06-09 1278
import java.math.BigDecimal; /** * 提供精确的浮点数运算(包括加 、 减 、 乘 、 除 、 四舍五入)工具类 * * @author yangmenghao * @date 2020/07/02 */ public class BigDecimalUtil { /** * 除法运算默认精度 */ private static final int DEF_DIV_SCALE = 5; /** * 精确加法 */ public st..
Java工具类——数字计算工具 NumberUtil
王新友的博客
06-15 1419
[java] view plaincopy package com.luang.util.common;        import java.util.HashSet;     import java.util.Random;     import java.util.Set;           /**   *    * NumberUtil.j
java基本运算怎么四舍五入_Java 四舍五入运算
weixin_36446407的博客
02-27 447
-- StartJava 的 Math 和 StrictMath 类提供了一些关于数学运算的静态方法. Math 类中的方法运行速度更快而 StrictMath 类中的方法更为精确.Math 和 StrictMath 类提供了以下四个方法来进行四舍五入运算.ceil // 天花板round // 四舍五入, 返回整数rint // 四舍五入, 返回浮点数floor // 地板来看下面代码的结果, ...
java四舍五入方法
chenxingde的博客
08-11 1327
题目要求： （1）0.01-99.99：在毫位上四舍五入，保留两位小数，如10.235元，处理为10.24元；10.231元，处理为10.23元。 （2）100.00-999.99：在分位上四舍五入，保留2位小数，分位上变为0。如100.35元，处理为100.40元；100.21元，处理为100.20元；100.95元，处理为101.00。 （3）1000.00以上：在角位上四舍五入，保留两位
java四则运算，四舍五入
不是很好的先生
04-22 301
package com.lianqiang.tmms.util; import java.math.BigDecimal; import java.text.DecimalFormat; public class DecimalUtil { /** * 格式化输出结果 */ private static final DecimalFormat df = new DecimalFo...
BigDecimal操作指南：加减乘除与四舍五入
"这篇文档主要介绍了Java中BigDecimal类型的使用，包括如何处理前端传入的数据，与数据库字段的对应关系，以及BigDecimal对象的各种算术运算和四舍五入的方法。此外，还提到了BigDecimal对象的比较操作。" 在Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值