Question

double n = 123.4567, o = 123.4567, p = 123.4567;
n *= 100;
n = Math.round(n);
n = n / 100;

System.out.println(n);

System.out.println(Math.round(o * 100) / 100);

System.out.println(((double) Math.round(p * 100)) / 100);

我正在以轻易的方式 playing一把小数点到两点,并发现。

产出:

123.46
123
123.46

我看不到的第一和第二办法之间是否有差别? 它们应是相同的算法,只是压缩为一行。为什么需要一行的投放,一行不通。

Answer 1

You re missing two important things:

This isn t at all how you should deal with rounding.
Nevertheless you may still be interested in an answer to your question. Which is: / means different things depending on context.

`/` means different things

你再次失踪的关键是,<代码>/ 系指2 java<>/strong>中不同的物品;背景决定了你获得的2件物品。在您的第一和第二版中,/系指不同的事物。

在第一和第二阶段,这意味着双重划分。第二,这意味着分类。

这2件事与枪炮和祖马一样。审议<代码>+ 系指completely不同的事项。鉴于a + b,

String a = "Hello"; String b = "World"; String c = a + b; // means string concatenation

int a = 5; int b = 7; int c = a + b; // means integer addition

您认为<代码>/同样。

总而言之,all java math operations are homogenous 。那么,java知道如何添加一根 in子,但当这两种论点都是同一类型时,不能处理这种情况。为了确定这一点,你必须把双方中的一方改为另一方。为了使事情复杂化,javac本身将assume <>em>。你打算这样做,并将把其中一人改换成你。它可以: 规则手册规定,java将只适用于扩大的转换,一旦这些转换通常被视为无损失。例如,将胎面转换为双倍被认为是无益的。 a. 将斜体改为短体(short)。数值可低于<代码>int。

鉴于:

int a = 11; int b = 10; double c = a / b; System.out.println(c);

您可能认为,“1.1”的文字。 <>0> 引证——是这样。仅打印1本。

...... The slash There means integer Division: 由于这两种论点都是类型的<代码>int,因此,内部划分是意思。因此,你将这一结果分配到“<代码>杜布尔>/代码”的变量中,与这一确定无关。因此,a / b是分类,在分类账中,其余部分都只是空档(因此,四舍五入为正数,但四舍五入为负数,五.5变为5,只生产刚刚开始。 1. 之后,该编码被分配到需要转换的<代码> double。由于这一条正在扩大,java inject静地向你们投放了票,因此没有必要明确写,而<条码>c现在为1.0。

你们的法典也是如此: 第二类氮化物是按体格分类的(由于<条码>>四面/代码>方法的回归类型,载于<条码>/代码>类别为<条码>),因此,你获得了立体字数。

如果你使用<条码>/,而歌剧有混合型,一种是<条码>杜布尔<>/条码>,另一种是<条码>int,java将沉默地扩大至翻一番,这样就能够奏效:

double x = 11.0; int y = 10; double z = x / y; System.out.println(z); // really will print 1.1

因此,必须投放:

int x = 11; int y = 10; double z = (double) x / y; System.out.println(z); // really will print 1.1

这里的<条码>/<条码> 左侧的表述为:<条码>(双重)×,其类型为<条码>;<条码>;<条码>;<条码>;<条码>;<条码>;<条码>;>条码>;

.. but don t do any of this

两倍不准确。顺便提一下。如果我请你在一份小纸上写出1份数分3份的结果,你不能做这个——你写了0.3333份,从会议室外出。

计算机也一样:其空间有限(64比特,double),以及储存精度而不是比率(在该系统中,可以撰写“1/ 3”字,只有“0.3333”字)。除此以外,计算机不使用mal,而是使用二元。

“1 / 10”工程的原因 (千分之十,无数位数的顺序)是因为10位数为2和5位,因此,任何可以仅表示为将2和5位数加在一起的作品(10 = 2 * 5-该作品)的分位数,而其他东西则升。

简言之,它只是两倍。
www.un.org/Depts/DGACM/index_spanish.htm 这意味着0.1不双重,造成四舍五入的错误。 !! 撰写一 j,仅此办理:

double v = 0.0; for (int i = 0; i < 10; i++) v += 0.1; System.out.println(1.0 == v);

And you will marvel! Because that prints false and that seems incorrect. It s correct in the same sense that if I ask you to write 1/3 on a piece of paper three times and I then ask you to tell me the sum of those 3 pieces of paper, you won t tell me 1. No, you d tell me 0.999999 . Which is very close to, but not quite equal to, 1.0.

因此,you不能认为double in this way——他们不能被利用来持有整数四舍五入到两条精子,因为做精干(如“0.10”)的一件事可能无法用双双筒。

相反,你有三种选择:

Atomicity

不管你再做什么,如果它有一个可行的原子单位,并且公正使用这些单位,就会发现。例如,如果提供资金,则不把成本4桶和20%的物体的价格储存在<条码>中。页: 1

但并非一切都有一个原子单位。

Accept the error

认为会发生轻微的四舍五入错误。 NEVER试图打整一个编号,而是在打印时,回合:

double v = 1.2345; // v s value is not quite 1.2345, but something very close. System.out.printf("%.2f ", v);

这印刷了1.23。千兆克不要四舍五入,要求打印件四舍五入。

BigDecimal

采用java s BigDecimal类,这是你想要的精准数字。但这意味着:

It s very slow and hard to use.

Memory requirements grow as your number gains digits.

It still cannot solve the 1 / 3 dilemma. That division will fail, unless you tell BigDecimal how to round it.

一般来说,BD技能过高。除非你真心实意地知道你正在做什么,否则不要使用。

Sooo.. finance stuff?

Always use long, to represent their financial ( Unless You really knowledge what You are do and consider BD is a better concept). 很少。无论发生什么情况,double> 是never金融正确数据类型。

当然,它代表的是原子。因此,欧元和多彩的百分数、日元的百分数、比美元的oshi子、磅的pen子等。

Answer 2

在第一种办法中:

n *= 100;        // Multiply by 100
n = Math.round(n); // Round to the nearest whole number
n = n / 100;      // Divide by 100

此处,由于imprecision a>,由于 floating-point/ ahmritetic。你的123 4567圆乘以100,获得12346.0。在隔了100人之后,你获得123.46。

In the second approach:

System.out.println(Math.round(o * 100) / 100);

Here, you re rounding 123.4567 * 100, which results in 12346. When you then divide by 100, you get 123.0.

The key difference is that in the first approach, you perform the rounding after the multiplication and then the division, while in the second approach, you round the result of the multiplication and immediately divide it.

如果你想采取第二种办法,得出与第一种办法相似的结果,那么,你就应当把四舍五入行动的结果翻一番,然后再将:

System.out.println((double) Math.round(o * 100) / 100);

这使该司能够以浮动点精确度进行,因此,损失为123.46。

Answer 3

<代码>Math.round (double) Return a long。如果您通过<代码>int 100而分出。结果是long(integer Division)。如果您先把四舍五入值定为“<>n>/code>的两倍,则请设一个浮动点。

你错了两倍。

Answer 4

页: 1 我看不到的第一和第二办法之间是否有差别? 它们应是相同的算法,只是压缩为一行。 ......

他们似乎也重复了同样的说法;他们没有。

在第一次计算中,请promoting<<<
n = Math.round(n * 100);

Whereas, in the second calculation, the result, a long, is then divided by an integer, 100.
Thus, only "123" is printed.

页: 1 为什么需要一行的投放,而不需要单独打线。

integer ;无交易价值。

这里就是一个例子。

out.println(100 / 3);
out.println(100 / 3d);

产出

33
33.333333333333336

On a final note, it s worth mentioning, you can choose a rounding "mode", when utilizing the BigDecimal class.
Each mode is outlined in the RoundingMode JavaDoc.

这里就是一个例子。

import static java.lang.System.out;
import static java.math.RoundingMode.*;

BigDecimal d = new BigDecimal("123.4567");
out.println(d.setScale(2, CEILING));
out.println(d.setScale(2, DOWN));
out.println(d.setScale(2, FLOOR));
out.println(d.setScale(2, HALF_DOWN));
out.println(d.setScale(2, HALF_EVEN));
out.println(d.setScale(2, HALF_UP));
out.println(d.setScale(2, UP));

产出

/ means different things

.. but don t do any of this

Atomicity

Accept the error

BigDecimal

Sooo.. finance stuff?

友情链接

`/` means different things