How to round to 2 decimal places in Java

import java.math.BigDecimal;
import java.math.RoundingMode;

public class Main {
    static BigDecimal round2(double x) {
        return BigDecimal.valueOf(x).setScale(2, RoundingMode.HALF_UP);
    }

    public static void main(String[] args) {
        System.out.println(round2(3.14159));
        System.out.println(round2(1.005));
        System.out.println(round2(2.675));
        System.out.println(round2(7));      // setScale pads: 7.00
        System.out.println(round2(-1.005)); // HALF_UP rounds ties away from zero

        // From a String: exact, and the natural choice for input and money
        BigDecimal price = new BigDecimal("19.995");
        System.out.println(price.setScale(2, RoundingMode.HALF_UP));

        // The trap: new BigDecimal(double) keeps the binary error
        System.out.println(new BigDecimal(2.675));
        System.out.println(new BigDecimal(2.675).setScale(2, RoundingMode.HALF_UP));
        System.out.println(BigDecimal.valueOf(2.675)); // uses Double.toString

        // Need a double back? Convert at the very end
        double rounded = round2(3.14159).doubleValue();
        System.out.println(rounded + 1);
    }
}

public class Main {
    static double round2(double x) {
        return Math.round(x * 100.0) / 100.0;
    }

    public static void main(String[] args) {
        System.out.println(round2(3.14159));
        System.out.println(round2(2.5));  // a double prints 2.5, never 2.50
        System.out.println(round2(7));

        // The floating-point trap: 1.005 is stored a hair below 1.005
        System.out.println(round2(1.005));
        System.out.println(1.005 * 100.0);

        // Math.round(-2.5) is -2: ties go toward positive infinity
        System.out.println(round2(-1.125) + " " + Math.round(-2.5));

        // Divide by 100 (an int) and you get integer division
        System.out.println(Math.round(3.14159 * 100) / 100);

        // Math.round returns a long, which caps at Long.MAX_VALUE
        System.out.println(round2(1e17));
    }
}

import java.util.Locale;

public class Main {
    public static void main(String[] args) {
        double x = 1234.5678;

        // Always pass a Locale: it decides the decimal separator
        System.out.println(String.format(Locale.ROOT, "%.2f", x));
        System.out.println(String.format(Locale.GERMANY, "%.2f", x));
        System.out.println(String.format(Locale.ROOT, "%,.2f", x));
        System.out.println(String.format(Locale.GERMANY, "%,.2f", x));

        // It pads to exactly two decimals and returns a String
        System.out.println(String.format(Locale.ROOT, "%.2f", 7.0));
        System.out.println(String.format(Locale.ROOT, "%.2f", 7.0) + 1);

        // It rounds HALF_UP from the shortest decimal form of the double
        System.out.println(String.format(Locale.ROOT, "%.2f %.2f %.2f", 1.005, 2.675, 0.125));

        // Java 15+: the same thing as an instance method (default locale)
        System.out.println("%.2f".formatted(Math.PI));

        // printf writes the formatted text directly
        System.out.printf(Locale.ROOT, "Total: %8.2f%n", 19.999);
    }
}

import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.util.Locale;

public class Main {
    public static void main(String[] args) {
        DecimalFormatSymbols us = DecimalFormatSymbols.getInstance(Locale.US);

        // "0.00": always two decimals. "#.##": at most two, no trailing zeros
        DecimalFormat fixed = new DecimalFormat("0.00", us);
        DecimalFormat upTo2 = new DecimalFormat("#.##", us);
        for (double x : new double[] {3.14159, 2.5, 7, 0.5}) {
            System.out.println(fixed.format(x) + "  " + upTo2.format(x));
        }

        // Grouping and the locale's own symbols
        System.out.println(new DecimalFormat("#,##0.00", us).format(1234567.891));
        DecimalFormatSymbols de = DecimalFormatSymbols.getInstance(Locale.GERMANY);
        System.out.println(new DecimalFormat("#,##0.00", de).format(1234567.891));

        // The default rounding mode is HALF_EVEN (banker's rounding)
        System.out.println(fixed.format(0.125) + " " + fixed.format(0.375));
        fixed.setRoundingMode(RoundingMode.HALF_UP);
        System.out.println(fixed.format(0.125) + " " + fixed.format(0.375));

        // DecimalFormat rounds the exact binary value, so 1.005 still goes down
        System.out.println(fixed.format(1.005));
    }
}

import java.math.BigDecimal;
import java.math.RoundingMode;

public class Main {
    public static void main(String[] args) {
        String[] inputs = {"2.345", "2.355", "-2.345", "2.341"};

        System.out.printf("%-10s", "mode");
        for (String s : inputs) System.out.printf("%8s", s);
        System.out.println();

        RoundingMode[] modes = {
            RoundingMode.HALF_UP, RoundingMode.HALF_EVEN, RoundingMode.HALF_DOWN,
            RoundingMode.UP, RoundingMode.DOWN, RoundingMode.CEILING, RoundingMode.FLOOR,
        };
        for (RoundingMode mode : modes) {
            System.out.printf("%-10s", mode);
            for (String s : inputs) {
                System.out.printf("%8s", new BigDecimal(s).setScale(2, mode));
            }
            System.out.println();
        }

        // UNNECESSARY asserts that no rounding is needed
        System.out.println(new BigDecimal("2.50").setScale(2, RoundingMode.UNNECESSARY));
        try {
            new BigDecimal("2.345").setScale(2, RoundingMode.UNNECESSARY);
        } catch (ArithmeticException e) {
            System.out.println("ArithmeticException: " + e.getMessage());
        }
    }
}

import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;

public class Main {
    public static void main(String[] args) {
        BigDecimal total = new BigDecimal("10.00");
        BigDecimal people = new BigDecimal("3");

        // 10 / 3 has no exact decimal answer, so divide() without a scale throws
        try {
            total.divide(people);
        } catch (ArithmeticException e) {
            System.out.println("ArithmeticException: " + e.getMessage());
        }

        // Fix: say how many decimals you want and how to round
        System.out.println(total.divide(people, 2, RoundingMode.HALF_UP));
        // ...or give a precision (significant digits) instead
        System.out.println(total.divide(people, MathContext.DECIMAL64));

        // Exact quotients still work without a scale
        System.out.println(total.divide(new BigDecimal("4")));

        // Trailing zeros: stripTrailingZeros, then toPlainString
        System.out.println(new BigDecimal("2.50").stripTrailingZeros());
        System.out.println(new BigDecimal("100.00").stripTrailingZeros());
        System.out.println(new BigDecimal("100.00").stripTrailingZeros().toPlainString());

        // The same trick prints a double without a pointless ".0"
        for (double d : new double[] {232.0, 0.18, 1e10}) {
            String plain = BigDecimal.valueOf(d).stripTrailingZeros().toPlainString();
            System.out.println(d + " -> " + plain);
        }

        // equals compares the scale too; compareTo compares the value
        BigDecimal a = new BigDecimal("2.5");
        BigDecimal b = new BigDecimal("2.50");
        System.out.println(a.equals(b) + " " + (a.compareTo(b) == 0));
    }
}