Java 四舍五入至小数点后2位，总结时给出问题

获取以下数字集-->

加起来就是一个整数

public static void main(String... ignored) {
    sum(5.1429, 5.1429, 5.1429, 5.1429, 5.1429, 5.1429, 5.1426);
    sum(0.8333, 0.8333, 0.8333, 0.8333, 0.8333, 0.8335);
}

private static void sum(double... xs) {
    double sum = 0;
    for (double x : xs) {
        sum += x;
    }
    System.out.printf("sum was %.2f%n", sum);
}

现在我们必须在四舍五入到2位小数后显示这些数字，如下所示-->

这不是一个整数。这导致整个总数达到了

99.96

或

101.01

我们有没有办法把数字四舍五入，这样总数就成了一个整数

public static void main(String... ignored) {
    sum(5.1429, 5.1429, 5.1429, 5.1429, 5.1429, 5.1429, 5.1426);
    sum(0.8333, 0.8333, 0.8333, 0.8333, 0.8333, 0.8335);
}

private static void sum(double... xs) {
    double sum = 0;
    for (double x : xs) {
        sum += x;
    }
    System.out.printf("sum was %.2f%n", sum);
}

---

我不想找一个办法来凑整这笔钱。我正在寻找一种方法来处理已经四舍五入的数字（如5.14,5.14…等），以便它们给出一个整数。（如果有一种方法……那就是：）

除非你放弃公司的要求，否则没有办法做到这一点
用于将数字四舍五入（小数点后2位）并考虑

（a） 截断数字（小数点后第二位）
（b） 向上/向下四舍五入，实际上你需要向下/向上四舍五入

如果允许这些操作（在某些数字上），而不是
按书本将所有这些内容四舍五入，那么您很可能会得出结论
使用某种算法，该算法将为您提供相同的（整数）和偶数
对原始数据应用舍入/截断操作后

---

数字。但是，这并不是真正的四舍五入（正如我们从数学中知道的）

除非您放弃公司要求，否则无法做到这一点
用于将数字四舍五入（小数点后2位）并考虑

（a） 截断数字（小数点后第二位）
（b） 向上/向下四舍五入，实际上你需要向下/向上四舍五入

如果允许这些操作（在某些数字上），而不是
按书本将所有这些内容四舍五入，那么您很可能会得出结论
使用某种算法，该算法将为您提供相同的（整数）和偶数
对原始数据应用舍入/截断操作后

---

数字。但是，这并不是真正的四舍五入（正如我们从数学中知道的）

除非您放弃公司要求，否则无法做到这一点
用于将数字四舍五入（小数点后2位）并考虑

（a） 截断数字（小数点后第二位）
（b） 向上/向下四舍五入，实际上你需要向下/向上四舍五入

如果允许这些操作（在某些数字上），而不是
按书本将所有这些内容四舍五入，那么您很可能会得出结论
使用某种算法，该算法将为您提供相同的（整数）和偶数
对原始数据应用舍入/截断操作后

---

数字。但是，这并不是真正的四舍五入（正如我们从数学中知道的）

除非您放弃公司要求，否则无法做到这一点
用于将数字四舍五入（小数点后2位）并考虑

（a） 截断数字（小数点后第二位）
（b） 向上/向下四舍五入，实际上你需要向下/向上四舍五入

如果允许这些操作（在某些数字上），而不是
按书本将所有这些内容四舍五入，那么您很可能会得出结论
使用某种算法，该算法将为您提供相同的（整数）和偶数
对原始数据应用舍入/截断操作后

---

数字。但是，这并不是真正的四舍五入（正如我们从数学中知道的）

你可以看看这个方法

---

在

中，您可以查看该方法

---

在

中，您可以查看该方法

---

在

中，您可以查看该方法

---

从

可以做到这一点的一种方法是四舍五入到小数点后两位，然后取每个数字乘以一百，再除以这些数字的总和。这将使您接近100，如果您迭代足够多的时间，您的结果将接近100。所以基本上（伪代码）

---

一种方法是四舍五入到小数点后两位，然后取每个数字乘以一百，再除以这些数字的和。这将使您接近100，如果您迭代足够多的时间，您的结果将接近100。所以基本上（伪代码）

---

一种方法是四舍五入到小数点后两位，然后取每个数字乘以一百，再除以这些数字的和。这将使您接近100，如果您迭代足够多的时间，您的结果将接近100。所以基本上（伪代码）

---

一种方法是四舍五入到小数点后两位，然后取每个数字乘以一百，再除以这些数字的和。这将使您接近100，如果您迭代足够多的时间，您的结果将接近100。所以基本上（伪代码）

---

如果我把结果四舍五入，我得到一个整数

public static void main(String... ignored) {
    sum(5.1429, 5.1429, 5.1429, 5.1429, 5.1429, 5.1429, 5.1426);
    sum(0.8333, 0.8333, 0.8333, 0.8333, 0.8333, 0.8335);
}

private static void sum(double... xs) {
    double sum = 0;
    for (double x : xs) {
        sum += x;
    }
    System.out.printf("sum was %.2f%n", sum);
}

---

顺便说一句：如果你知道你想要一个整数，你应该四舍五入到一个整数，而不是小数点后两位。

如果我对结果进行四舍五入，我得到一个整数

public static void main(String... ignored) {
    sum(5.1429, 5.1429, 5.1429, 5.1429, 5.1429, 5.1429, 5.1426);
    sum(0.8333, 0.8333, 0.8333, 0.8333, 0.8333, 0.8335);
}

private static void sum(double... xs) {
    double sum = 0;
    for (double x : xs) {
        sum += x;
    }
    System.out.printf("sum was %.2f%n", sum);
}

---

顺便说一句：如果你知道你想要一个整数，你应该四舍五入到一个整数，而不是小数点后两位。

如果我对结果进行四舍五入，我得到一个整数

public static void main(String... ignored) {
    sum(5.1429, 5.1429, 5.1429, 5.1429, 5.1429, 5.1429, 5.1426);
    sum(0.8333, 0.8333, 0.8333, 0.8333, 0.8333, 0.8335);
}

private static void sum(double... xs) {
    double sum = 0;
    for (double x : xs) {
        sum += x;
    }
    System.out.printf("sum was %.2f%n", sum);
}

---

顺便说一句：如果你知道你想要一个整数，你应该四舍五入到一个整数，而不是小数点后两位。

如果我对结果进行四舍五入，我得到一个整数

public static void main(String... ignored) {
    sum(5.1429, 5.1429, 5.1429, 5.1429, 5.1429, 5.1429, 5.1426);
    sum(0.8333, 0.8333, 0.8333, 0.8333, 0.8333, 0.8335);
}

private static void sum(double... xs) {
    double sum = 0;
    for (double x : xs) {
        sum += x;
    }
    System.out.printf("sum was %.2f%n", sum);
}

---

顺便说一句：如果你知道你期望的是一个整数，你应该四舍五入到一个整数，而不是小数点后两位。

你可以按你所做的那样求和，然后再对最后的和进行四舍五入。

你可以按你所做的那样求和，然后对最终的总和进行四舍五入。

您可以按原样对它们进行求和，然后对最终的总和进行四舍五入。

如果您通过减少第三个小数点对输入进行排序并将所有内容向下四舍五入，则会引入最小的绝对四舍五入误差，同时保持总和不变，除了能达到目标的人数

举个简单的例子：

输入0.257, 0.226, 0.385, 0.132

0.25, 0.22, 0.38, 0.13 // sums up to 0.98

0.26, 0.23, 0.38, 0.13 // sums up to 1.00

public void printRounded(double[] ds) {
    // create wrapper objects
    int n = ds.length;
    Wrapper[] ws = new Wrapper[n];
    for (int i = 0; i < n; i++)
        ws[i] = new Wrapper(i, (int)(ds[i] * 1000) % 10, (int)(ds[i] * 100));

    // sort by third decimal, descending
    Arrays.sort(ws, new Comparator<Wrapper>() {
        public int compare(Wrapper o1, Wrapper o2) {
            return o2.thirdDecimal.compareTo(o1.thirdDecimal);
        }
    });

    // find number of elements that must be rounded up and increment
    int sum = 0;
    for (int i = 0; i < n; i++)
        sum += ws[i].prefix;
    int numberToIncrement = 100 - (sum % 100);
    for (int i = 0; i < numberToIncrement ; i++)
        ws[i].prefix++;

    // sort back to input order
    Arrays.sort(ws, new Comparator<Wrapper>() {
        public int compare(Wrapper o1, Wrapper o2) {
            return o1.index.compareTo(o2.index);
        }
    });

    // print values
    for (int i = 0; i < n; i++) {
        System.out.println(ws[i].prefix / 100 + "." ws[i].prefix % 100);
    }
}

private class Wrapper {
    public Wrapper(int index, int thirdDecimal, int prefix) {
        this.index = index;
        this.thirdDecimal = thirdDecimal;
        this.prefix = prefix;
    }

    public int index;
    public int thirdDecimal;
    public int prefix;
}