From 6c753fb2042cd8db1f18ba3aaef7caef267d2bc7 Mon Sep 17 00:00:00 2001 From: Marcin Krykowski Date: Fri, 22 May 2020 22:30:57 +0100 Subject: [PATCH 01/13] Add Format Number implementation and tests --- .../baeldung/formatNumber/FormatNumber.java | 63 +++++++++++++++++++ .../formatNumber/FormatNumberTest.java | 42 +++++++++++++ 2 files changed, 105 insertions(+) create mode 100644 java-numbers/src/main/java/com/baeldung/formatNumber/FormatNumber.java create mode 100644 java-numbers/src/test/java/com/baeldung/formatNumber/FormatNumberTest.java diff --git a/java-numbers/src/main/java/com/baeldung/formatNumber/FormatNumber.java b/java-numbers/src/main/java/com/baeldung/formatNumber/FormatNumber.java new file mode 100644 index 0000000000..e76fa2cac9 --- /dev/null +++ b/java-numbers/src/main/java/com/baeldung/formatNumber/FormatNumber.java @@ -0,0 +1,63 @@ +package com.baeldung.formatNumber; + +import java.math.BigDecimal; +import java.math.RoundingMode; +import java.text.DecimalFormat; +import java.text.NumberFormat; +import java.util.Locale; + +public class FormatNumber { + private static final double D = 4.2352989244d; + private static final double F = 8.6994540927d; + + public static void main(String[] args) { + System.out.println(D + " with Big Decimal (2 places) is " + withBigDecimal(D, 2)); + System.out.println(D + " with Big Decimal (3 places) is " + withBigDecimal(D, 3)); + System.out.println(F + " with Big Decimal (2 places) is " + withBigDecimal(F, 2)); + System.out.println(F + " with Big Decimal (3 places) is " + withBigDecimal(F, 3)); + System.out.println(D + " with Math.round is (2 places) " + withMathRound(D, 2)); + System.out.println(D + " with Math.round is (3 places) " + withMathRound(D, 3)); + System.out.println(F + " with Math.round is (2 places) " + withMathRound(F, 2)); + System.out.println(F + " with Math.round is (3 places) " + withMathRound(F, 3)); + System.out.println(D + " with String Format is (2 places) " + withStringFormat(D, 2)); + System.out.println(D + " with String Format is (3 places) " + withStringFormat(D, 3)); + System.out.println(F + " with String Format is (2 places) " + withStringFormat(F, 2)); + System.out.println(F + " with String Format is (3 places) " + withStringFormat(F, 3)); + System.out.println(D + " with Decimal Format (local) is " + withDecimalFormat(D, 0)); + System.out.println(D + " with Decimal Format (2 places) is " + withDecimalFormat(D, 2)); + System.out.println(D + " with Decimal Format (3 places) is " + withDecimalFormat(D, 3)); + System.out.println(F + " with Decimal Format is (local) " + withDecimalFormat(F, 0)); + System.out.println(F + " with Decimal Format is (2 places) " + withDecimalFormat(F, 2)); + System.out.println(F + " with Decimal Format is (3 places) " + withDecimalFormat(F, 3)); + } + + public static double withBigDecimal(double value, int places) { + if (places < 0) + throw new IllegalArgumentException(); + + BigDecimal bigDecimal = new BigDecimal(value); + bigDecimal = bigDecimal.setScale(places, RoundingMode.HALF_UP); + return bigDecimal.doubleValue(); + } + + public static double withMathRound(double value, int places) { + double scale = Math.pow(10, places); + return Math.round(value * scale) / scale; + } + + public static double withDecimalFormat(double value, int places) { + DecimalFormat df = (DecimalFormat) NumberFormat.getNumberInstance(Locale.getDefault()); + DecimalFormat df2 = new DecimalFormat("#,###,###,##0.00"); + DecimalFormat df3 = new DecimalFormat("#,###,###,##0.000"); + if (places == 2) + return new Double(df2.format(value)); + else if (places == 3) + return new Double(df3.format(value)); + else + return new Double(df.format(value)); + } + + public static String withStringFormat(double value, int places) { + return String.format("%." + places + "f", value); + } +} diff --git a/java-numbers/src/test/java/com/baeldung/formatNumber/FormatNumberTest.java b/java-numbers/src/test/java/com/baeldung/formatNumber/FormatNumberTest.java new file mode 100644 index 0000000000..0cc035f246 --- /dev/null +++ b/java-numbers/src/test/java/com/baeldung/formatNumber/FormatNumberTest.java @@ -0,0 +1,42 @@ +package com.baeldung.formatNumber; + +import org.apache.commons.math3.util.Precision; +import org.decimal4j.util.DoubleRounder; +import org.junit.Assert; +import org.junit.Test; + +public class FormatNumberTest { + private double value = 2.03456d; + private int places = 2; + private double expected = 2.03d; + + @Test public void givenDecimalNumber_whenFormatNumberToNDecimalPlaces_thenGetExpectedResult() { + double delta = 0.0d; + Assert.assertEquals(expected, FormatNumber.withBigDecimal(value, places), delta); + Assert.assertEquals(expected, FormatNumber.withDecimalFormat(value, places), delta); + Assert.assertEquals(expected, FormatNumber.withMathRound(value, places), delta); + + places = 3; + expected = 2.035d; + + Assert.assertEquals(expected, FormatNumber.withBigDecimal(value, places), delta); + Assert.assertEquals(expected, FormatNumber.withDecimalFormat(value, places), delta); + Assert.assertEquals(expected, FormatNumber.withMathRound(value, places), delta); + + value = 256.024d; + places = 2; + expected = 256.02d; + + Assert.assertEquals(expected, FormatNumber.withBigDecimal(value, places), delta); + Assert.assertEquals(expected, FormatNumber.withDecimalFormat(value, places), delta); + Assert.assertEquals(expected, FormatNumber.withMathRound(value, places), delta); + + value = 260.773d; + places = 2; + expected = 260.77d; + + Assert.assertEquals(expected, FormatNumber.withBigDecimal(value, places), delta); + Assert.assertEquals(expected, FormatNumber.withDecimalFormat(value, places), delta); + Assert.assertEquals(expected, FormatNumber.withMathRound(value, places), delta); + } +} From 55c84a6855830e20b803426a7038cced088e9b52 Mon Sep 17 00:00:00 2001 From: Marcin Krykowski Date: Mon, 25 May 2020 09:04:14 +0100 Subject: [PATCH 02/13] Split format number with decimal format method into two separate methods --- .../baeldung/formatNumber/FormatNumber.java | 24 ++++++++++--------- 1 file changed, 13 insertions(+), 11 deletions(-) diff --git a/java-numbers/src/main/java/com/baeldung/formatNumber/FormatNumber.java b/java-numbers/src/main/java/com/baeldung/formatNumber/FormatNumber.java index e76fa2cac9..4ce93adae0 100644 --- a/java-numbers/src/main/java/com/baeldung/formatNumber/FormatNumber.java +++ b/java-numbers/src/main/java/com/baeldung/formatNumber/FormatNumber.java @@ -23,12 +23,12 @@ public class FormatNumber { System.out.println(D + " with String Format is (3 places) " + withStringFormat(D, 3)); System.out.println(F + " with String Format is (2 places) " + withStringFormat(F, 2)); System.out.println(F + " with String Format is (3 places) " + withStringFormat(F, 3)); - System.out.println(D + " with Decimal Format (local) is " + withDecimalFormat(D, 0)); - System.out.println(D + " with Decimal Format (2 places) is " + withDecimalFormat(D, 2)); - System.out.println(D + " with Decimal Format (3 places) is " + withDecimalFormat(D, 3)); - System.out.println(F + " with Decimal Format is (local) " + withDecimalFormat(F, 0)); - System.out.println(F + " with Decimal Format is (2 places) " + withDecimalFormat(F, 2)); - System.out.println(F + " with Decimal Format is (3 places) " + withDecimalFormat(F, 3)); + System.out.println(D + " with Decimal Format (local) is " + withDecimalFormatLocal(D)); + System.out.println(D + " with Decimal Format (2 places) is " + withDecimalFormatPattern(D, 2)); + System.out.println(D + " with Decimal Format (3 places) is " + withDecimalFormatPattern(D, 3)); + System.out.println(F + " with Decimal Format is (local) " + withDecimalFormatLocal(F)); + System.out.println(F + " with Decimal Format is (2 places) " + withDecimalFormatPattern(F, 2)); + System.out.println(F + " with Decimal Format is (3 places) " + withDecimalFormatPattern(F, 3)); } public static double withBigDecimal(double value, int places) { @@ -45,16 +45,18 @@ public class FormatNumber { return Math.round(value * scale) / scale; } - public static double withDecimalFormat(double value, int places) { - DecimalFormat df = (DecimalFormat) NumberFormat.getNumberInstance(Locale.getDefault()); + public static double withDecimalFormatPattern(double value, int places) { DecimalFormat df2 = new DecimalFormat("#,###,###,##0.00"); DecimalFormat df3 = new DecimalFormat("#,###,###,##0.000"); if (places == 2) return new Double(df2.format(value)); - else if (places == 3) + if (places == 3) return new Double(df3.format(value)); - else - return new Double(df.format(value)); + } + + public static double withDecimalFormatLocal(double value) { + DecimalFormat df = (DecimalFormat) NumberFormat.getNumberInstance(Locale.getDefault()); + return new Double(df.format(value)); } public static String withStringFormat(double value, int places) { From 46d4fdb4d73497443ec13140a641585f4e6ce0ae Mon Sep 17 00:00:00 2001 From: Marcin Krykowski Date: Mon, 25 May 2020 09:06:54 +0100 Subject: [PATCH 03/13] Add exception throwing to withDecimalFormatPattern() method --- .../src/main/java/com/baeldung/formatNumber/FormatNumber.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/java-numbers/src/main/java/com/baeldung/formatNumber/FormatNumber.java b/java-numbers/src/main/java/com/baeldung/formatNumber/FormatNumber.java index 4ce93adae0..a9925dee9d 100644 --- a/java-numbers/src/main/java/com/baeldung/formatNumber/FormatNumber.java +++ b/java-numbers/src/main/java/com/baeldung/formatNumber/FormatNumber.java @@ -50,8 +50,10 @@ public class FormatNumber { DecimalFormat df3 = new DecimalFormat("#,###,###,##0.000"); if (places == 2) return new Double(df2.format(value)); - if (places == 3) + else if (places == 3) return new Double(df3.format(value)); + else + throw new IllegalArgumentException(); } public static double withDecimalFormatLocal(double value) { From 4a3ad21147d6e234ae988607a2a1b10d0139f8f9 Mon Sep 17 00:00:00 2001 From: Marcin Krykowski Date: Mon, 25 May 2020 09:10:55 +0100 Subject: [PATCH 04/13] Correct tests --- .../java/com/baeldung/formatNumber/FormatNumberTest.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/java-numbers/src/test/java/com/baeldung/formatNumber/FormatNumberTest.java b/java-numbers/src/test/java/com/baeldung/formatNumber/FormatNumberTest.java index 0cc035f246..1e402e4dc9 100644 --- a/java-numbers/src/test/java/com/baeldung/formatNumber/FormatNumberTest.java +++ b/java-numbers/src/test/java/com/baeldung/formatNumber/FormatNumberTest.java @@ -13,14 +13,14 @@ public class FormatNumberTest { @Test public void givenDecimalNumber_whenFormatNumberToNDecimalPlaces_thenGetExpectedResult() { double delta = 0.0d; Assert.assertEquals(expected, FormatNumber.withBigDecimal(value, places), delta); - Assert.assertEquals(expected, FormatNumber.withDecimalFormat(value, places), delta); + Assert.assertEquals(expected, FormatNumber.withDecimalFormatPattern(value, places), delta); Assert.assertEquals(expected, FormatNumber.withMathRound(value, places), delta); places = 3; expected = 2.035d; Assert.assertEquals(expected, FormatNumber.withBigDecimal(value, places), delta); - Assert.assertEquals(expected, FormatNumber.withDecimalFormat(value, places), delta); + Assert.assertEquals(expected, FormatNumber.withDecimalFormatPattern(value, places), delta); Assert.assertEquals(expected, FormatNumber.withMathRound(value, places), delta); value = 256.024d; @@ -28,7 +28,7 @@ public class FormatNumberTest { expected = 256.02d; Assert.assertEquals(expected, FormatNumber.withBigDecimal(value, places), delta); - Assert.assertEquals(expected, FormatNumber.withDecimalFormat(value, places), delta); + Assert.assertEquals(expected, FormatNumber.withDecimalFormatPattern(value, places), delta); Assert.assertEquals(expected, FormatNumber.withMathRound(value, places), delta); value = 260.773d; @@ -36,7 +36,7 @@ public class FormatNumberTest { expected = 260.77d; Assert.assertEquals(expected, FormatNumber.withBigDecimal(value, places), delta); - Assert.assertEquals(expected, FormatNumber.withDecimalFormat(value, places), delta); + Assert.assertEquals(expected, FormatNumber.withDecimalFormatPattern(value, places), delta); Assert.assertEquals(expected, FormatNumber.withMathRound(value, places), delta); } } From 89f5691066cf77219947e66c5e78a10e9f49b0e8 Mon Sep 17 00:00:00 2001 From: Marcin Krykowski Date: Wed, 27 May 2020 16:34:21 +0100 Subject: [PATCH 05/13] Restructured test using AsserJ library --- .../baeldung/formatNumber/FormatNumber.java | 24 --------- .../formatNumber/FormatNumberTest.java | 51 +++++++++---------- 2 files changed, 23 insertions(+), 52 deletions(-) diff --git a/java-numbers/src/main/java/com/baeldung/formatNumber/FormatNumber.java b/java-numbers/src/main/java/com/baeldung/formatNumber/FormatNumber.java index a9925dee9d..a0a9e05e83 100644 --- a/java-numbers/src/main/java/com/baeldung/formatNumber/FormatNumber.java +++ b/java-numbers/src/main/java/com/baeldung/formatNumber/FormatNumber.java @@ -7,30 +7,6 @@ import java.text.NumberFormat; import java.util.Locale; public class FormatNumber { - private static final double D = 4.2352989244d; - private static final double F = 8.6994540927d; - - public static void main(String[] args) { - System.out.println(D + " with Big Decimal (2 places) is " + withBigDecimal(D, 2)); - System.out.println(D + " with Big Decimal (3 places) is " + withBigDecimal(D, 3)); - System.out.println(F + " with Big Decimal (2 places) is " + withBigDecimal(F, 2)); - System.out.println(F + " with Big Decimal (3 places) is " + withBigDecimal(F, 3)); - System.out.println(D + " with Math.round is (2 places) " + withMathRound(D, 2)); - System.out.println(D + " with Math.round is (3 places) " + withMathRound(D, 3)); - System.out.println(F + " with Math.round is (2 places) " + withMathRound(F, 2)); - System.out.println(F + " with Math.round is (3 places) " + withMathRound(F, 3)); - System.out.println(D + " with String Format is (2 places) " + withStringFormat(D, 2)); - System.out.println(D + " with String Format is (3 places) " + withStringFormat(D, 3)); - System.out.println(F + " with String Format is (2 places) " + withStringFormat(F, 2)); - System.out.println(F + " with String Format is (3 places) " + withStringFormat(F, 3)); - System.out.println(D + " with Decimal Format (local) is " + withDecimalFormatLocal(D)); - System.out.println(D + " with Decimal Format (2 places) is " + withDecimalFormatPattern(D, 2)); - System.out.println(D + " with Decimal Format (3 places) is " + withDecimalFormatPattern(D, 3)); - System.out.println(F + " with Decimal Format is (local) " + withDecimalFormatLocal(F)); - System.out.println(F + " with Decimal Format is (2 places) " + withDecimalFormatPattern(F, 2)); - System.out.println(F + " with Decimal Format is (3 places) " + withDecimalFormatPattern(F, 3)); - } - public static double withBigDecimal(double value, int places) { if (places < 0) throw new IllegalArgumentException(); diff --git a/java-numbers/src/test/java/com/baeldung/formatNumber/FormatNumberTest.java b/java-numbers/src/test/java/com/baeldung/formatNumber/FormatNumberTest.java index 1e402e4dc9..cb4e7631f7 100644 --- a/java-numbers/src/test/java/com/baeldung/formatNumber/FormatNumberTest.java +++ b/java-numbers/src/test/java/com/baeldung/formatNumber/FormatNumberTest.java @@ -1,42 +1,37 @@ package com.baeldung.formatNumber; -import org.apache.commons.math3.util.Precision; -import org.decimal4j.util.DoubleRounder; -import org.junit.Assert; import org.junit.Test; +import static com.baeldung.formatNumber.FormatNumber.*; +import static org.assertj.core.api.Assertions.*; + public class FormatNumberTest { - private double value = 2.03456d; - private int places = 2; - private double expected = 2.03d; + private static final double D = 4.2352989244d; + private static final double F = 8.6994540927d; @Test public void givenDecimalNumber_whenFormatNumberToNDecimalPlaces_thenGetExpectedResult() { - double delta = 0.0d; - Assert.assertEquals(expected, FormatNumber.withBigDecimal(value, places), delta); - Assert.assertEquals(expected, FormatNumber.withDecimalFormatPattern(value, places), delta); - Assert.assertEquals(expected, FormatNumber.withMathRound(value, places), delta); - places = 3; - expected = 2.035d; + assertThat(withBigDecimal(D, 2)).isEqualTo(4.24); + assertThat(withBigDecimal(D, 3)).isEqualTo(4.235); + assertThat(withBigDecimal(F, 2)).isEqualTo(8.7); + assertThat(withBigDecimal(F, 3)).isEqualTo(8.699); - Assert.assertEquals(expected, FormatNumber.withBigDecimal(value, places), delta); - Assert.assertEquals(expected, FormatNumber.withDecimalFormatPattern(value, places), delta); - Assert.assertEquals(expected, FormatNumber.withMathRound(value, places), delta); + assertThat(withMathRound(D, 2)).isEqualTo(4.24); + assertThat(withMathRound(D, 3)).isEqualTo(4.235); + assertThat(withMathRound(F, 2)).isEqualTo(8.7); + assertThat(withMathRound(F, 3)).isEqualTo(8.699); - value = 256.024d; - places = 2; - expected = 256.02d; + assertThat(withStringFormat(D, 2)).isEqualTo("4.24"); + assertThat(withStringFormat(D, 3)).isEqualTo("4.235"); + assertThat(withStringFormat(F, 2)).isEqualTo("8.70"); + assertThat(withStringFormat(F, 3)).isEqualTo("8.699"); - Assert.assertEquals(expected, FormatNumber.withBigDecimal(value, places), delta); - Assert.assertEquals(expected, FormatNumber.withDecimalFormatPattern(value, places), delta); - Assert.assertEquals(expected, FormatNumber.withMathRound(value, places), delta); + assertThat(withDecimalFormatLocal(D)).isEqualTo(4.235); + assertThat(withDecimalFormatLocal(F)).isEqualTo(8.699); - value = 260.773d; - places = 2; - expected = 260.77d; - - Assert.assertEquals(expected, FormatNumber.withBigDecimal(value, places), delta); - Assert.assertEquals(expected, FormatNumber.withDecimalFormatPattern(value, places), delta); - Assert.assertEquals(expected, FormatNumber.withMathRound(value, places), delta); + assertThat(withDecimalFormatPattern(D, 2)).isEqualTo(4.24); + assertThat(withDecimalFormatPattern(D, 3)).isEqualTo(4.235); + assertThat(withDecimalFormatPattern(F, 2)).isEqualTo(8.7); + assertThat(withDecimalFormatPattern(F, 3)).isEqualTo(8.699); } } From a34da64e71be4cac67dec37bf285fa46d0f3c5f9 Mon Sep 17 00:00:00 2001 From: Marcin Krykowski Date: Wed, 27 May 2020 16:41:11 +0100 Subject: [PATCH 06/13] Change test class name --- .../{FormatNumberTest.java => FormatNumberUnitTest.java} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename java-numbers/src/test/java/com/baeldung/formatNumber/{FormatNumberTest.java => FormatNumberUnitTest.java} (97%) diff --git a/java-numbers/src/test/java/com/baeldung/formatNumber/FormatNumberTest.java b/java-numbers/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java similarity index 97% rename from java-numbers/src/test/java/com/baeldung/formatNumber/FormatNumberTest.java rename to java-numbers/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java index cb4e7631f7..b5da1947a3 100644 --- a/java-numbers/src/test/java/com/baeldung/formatNumber/FormatNumberTest.java +++ b/java-numbers/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java @@ -5,7 +5,7 @@ import org.junit.Test; import static com.baeldung.formatNumber.FormatNumber.*; import static org.assertj.core.api.Assertions.*; -public class FormatNumberTest { +public class FormatNumberUnitTest { private static final double D = 4.2352989244d; private static final double F = 8.6994540927d; From d697e7f7d59641ea7e3122d634225908acd148a3 Mon Sep 17 00:00:00 2001 From: Marcin Krykowski Date: Sat, 30 May 2020 05:22:10 +0100 Subject: [PATCH 07/13] Change project from java-numbers to java-numbers-3 --- .../src/main/java/com/baeldung/formatNumber/FormatNumber.java | 1 + .../java/com/baeldung/formatNumber/FormatNumberUnitTest.java | 3 ++- 2 files changed, 3 insertions(+), 1 deletion(-) rename {java-numbers => java-numbers-3}/src/main/java/com/baeldung/formatNumber/FormatNumber.java (99%) rename {java-numbers => java-numbers-3}/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java (93%) diff --git a/java-numbers/src/main/java/com/baeldung/formatNumber/FormatNumber.java b/java-numbers-3/src/main/java/com/baeldung/formatNumber/FormatNumber.java similarity index 99% rename from java-numbers/src/main/java/com/baeldung/formatNumber/FormatNumber.java rename to java-numbers-3/src/main/java/com/baeldung/formatNumber/FormatNumber.java index a0a9e05e83..3470a8419a 100644 --- a/java-numbers/src/main/java/com/baeldung/formatNumber/FormatNumber.java +++ b/java-numbers-3/src/main/java/com/baeldung/formatNumber/FormatNumber.java @@ -41,3 +41,4 @@ public class FormatNumber { return String.format("%." + places + "f", value); } } + diff --git a/java-numbers/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java b/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java similarity index 93% rename from java-numbers/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java rename to java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java index b5da1947a3..4eb6e42f1a 100644 --- a/java-numbers/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java +++ b/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java @@ -9,7 +9,8 @@ public class FormatNumberUnitTest { private static final double D = 4.2352989244d; private static final double F = 8.6994540927d; - @Test public void givenDecimalNumber_whenFormatNumberToNDecimalPlaces_thenGetExpectedResult() { + @Test + public void givenDecimalNumber_whenFormatNumberToNDecimalPlaces_thenGetExpectedResult() { assertThat(withBigDecimal(D, 2)).isEqualTo(4.24); assertThat(withBigDecimal(D, 3)).isEqualTo(4.235); From 7640a306325be3b183fcb003f64f7d5c3cac936a Mon Sep 17 00:00:00 2001 From: Marcin Krykowski Date: Sat, 30 May 2020 05:32:54 +0100 Subject: [PATCH 08/13] Split up test method into smaller ones. Correct code formatting --- .../baeldung/formatNumber/FormatNumber.java | 56 +++++++++---------- .../formatNumber/FormatNumberUnitTest.java | 56 +++++++++++-------- 2 files changed, 60 insertions(+), 52 deletions(-) diff --git a/java-numbers-3/src/main/java/com/baeldung/formatNumber/FormatNumber.java b/java-numbers-3/src/main/java/com/baeldung/formatNumber/FormatNumber.java index 3470a8419a..6a16fffa7e 100644 --- a/java-numbers-3/src/main/java/com/baeldung/formatNumber/FormatNumber.java +++ b/java-numbers-3/src/main/java/com/baeldung/formatNumber/FormatNumber.java @@ -7,38 +7,38 @@ import java.text.NumberFormat; import java.util.Locale; public class FormatNumber { - public static double withBigDecimal(double value, int places) { - if (places < 0) - throw new IllegalArgumentException(); + public static double withBigDecimal(double value, int places) { + if (places < 0) + throw new IllegalArgumentException(); - BigDecimal bigDecimal = new BigDecimal(value); - bigDecimal = bigDecimal.setScale(places, RoundingMode.HALF_UP); - return bigDecimal.doubleValue(); - } + BigDecimal bigDecimal = new BigDecimal(value); + bigDecimal = bigDecimal.setScale(places, RoundingMode.HALF_UP); + return bigDecimal.doubleValue(); + } - public static double withMathRound(double value, int places) { - double scale = Math.pow(10, places); - return Math.round(value * scale) / scale; - } + public static double withMathRound(double value, int places) { + double scale = Math.pow(10, places); + return Math.round(value * scale) / scale; + } - public static double withDecimalFormatPattern(double value, int places) { - DecimalFormat df2 = new DecimalFormat("#,###,###,##0.00"); - DecimalFormat df3 = new DecimalFormat("#,###,###,##0.000"); - if (places == 2) - return new Double(df2.format(value)); - else if (places == 3) - return new Double(df3.format(value)); - else - throw new IllegalArgumentException(); - } + public static double withDecimalFormatPattern(double value, int places) { + DecimalFormat df2 = new DecimalFormat("#,###,###,##0.00"); + DecimalFormat df3 = new DecimalFormat("#,###,###,##0.000"); + if (places == 2) + return new Double(df2.format(value)); + else if (places == 3) + return new Double(df3.format(value)); + else + throw new IllegalArgumentException(); + } - public static double withDecimalFormatLocal(double value) { - DecimalFormat df = (DecimalFormat) NumberFormat.getNumberInstance(Locale.getDefault()); - return new Double(df.format(value)); - } + public static double withDecimalFormatLocal(double value) { + DecimalFormat df = (DecimalFormat) NumberFormat.getNumberInstance(Locale.getDefault()); + return new Double(df.format(value)); + } - public static String withStringFormat(double value, int places) { - return String.format("%." + places + "f", value); - } + public static String withStringFormat(double value, int places) { + return String.format("%." + places + "f", value); + } } diff --git a/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java b/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java index 4eb6e42f1a..ef3700e27a 100644 --- a/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java +++ b/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java @@ -6,33 +6,41 @@ import static com.baeldung.formatNumber.FormatNumber.*; import static org.assertj.core.api.Assertions.*; public class FormatNumberUnitTest { - private static final double D = 4.2352989244d; - private static final double F = 8.6994540927d; + private static final double D = 4.2352989244d; + private static final double F = 8.6994540927d; - @Test - public void givenDecimalNumber_whenFormatNumberToNDecimalPlaces_thenGetExpectedResult() { + @Test + public void givenDecimalNumber_whenFormatNumber_withBigDecimal_thenGetExpectedResult() { + assertThat(withBigDecimal(D, 2)).isEqualTo(4.24); + assertThat(withBigDecimal(D, 3)).isEqualTo(4.235); + assertThat(withBigDecimal(F, 2)).isEqualTo(8.7); + assertThat(withBigDecimal(F, 3)).isEqualTo(8.699); + } - assertThat(withBigDecimal(D, 2)).isEqualTo(4.24); - assertThat(withBigDecimal(D, 3)).isEqualTo(4.235); - assertThat(withBigDecimal(F, 2)).isEqualTo(8.7); - assertThat(withBigDecimal(F, 3)).isEqualTo(8.699); + @Test + public void givenDecimalNumber_whenFormatNumber_withDecimalFormat_thenGetExpectedResult() { + assertThat(withDecimalFormatLocal(D)).isEqualTo(4.235); + assertThat(withDecimalFormatLocal(F)).isEqualTo(8.699); - assertThat(withMathRound(D, 2)).isEqualTo(4.24); - assertThat(withMathRound(D, 3)).isEqualTo(4.235); - assertThat(withMathRound(F, 2)).isEqualTo(8.7); - assertThat(withMathRound(F, 3)).isEqualTo(8.699); + assertThat(withDecimalFormatPattern(D, 2)).isEqualTo(4.24); + assertThat(withDecimalFormatPattern(D, 3)).isEqualTo(4.235); + assertThat(withDecimalFormatPattern(F, 2)).isEqualTo(8.7); + assertThat(withDecimalFormatPattern(F, 3)).isEqualTo(8.699); + } - assertThat(withStringFormat(D, 2)).isEqualTo("4.24"); - assertThat(withStringFormat(D, 3)).isEqualTo("4.235"); - assertThat(withStringFormat(F, 2)).isEqualTo("8.70"); - assertThat(withStringFormat(F, 3)).isEqualTo("8.699"); + @Test + public void givenDecimalNumber_whenFormatNumber_withStringFormat_thenGetExpectedResult() { + assertThat(withStringFormat(D, 2)).isEqualTo("4.24"); + assertThat(withStringFormat(D, 3)).isEqualTo("4.235"); + assertThat(withStringFormat(F, 2)).isEqualTo("8.70"); + assertThat(withStringFormat(F, 3)).isEqualTo("8.699"); + } - assertThat(withDecimalFormatLocal(D)).isEqualTo(4.235); - assertThat(withDecimalFormatLocal(F)).isEqualTo(8.699); - - assertThat(withDecimalFormatPattern(D, 2)).isEqualTo(4.24); - assertThat(withDecimalFormatPattern(D, 3)).isEqualTo(4.235); - assertThat(withDecimalFormatPattern(F, 2)).isEqualTo(8.7); - assertThat(withDecimalFormatPattern(F, 3)).isEqualTo(8.699); - } + @Test + public void givenDecimalNumber_whenFormatNumber_withMathRound_thenGetExpectedResult() { + assertThat(withMathRound(D, 2)).isEqualTo(4.24); + assertThat(withMathRound(D, 3)).isEqualTo(4.235); + assertThat(withMathRound(F, 2)).isEqualTo(8.7); + assertThat(withMathRound(F, 3)).isEqualTo(8.699); + } } From f7ea514e47ba42e7b49159d1fc93e1df79c372ee Mon Sep 17 00:00:00 2001 From: Marcin Krykowski Date: Sat, 13 Jun 2020 23:40:19 +0100 Subject: [PATCH 09/13] Add formating methods for percentages, currencies and big numbers --- .../baeldung/formatNumber/FormatNumber.java | 29 +++++++++++++ .../formatNumber/FormatNumberUnitTest.java | 42 +++++++++++++++++++ 2 files changed, 71 insertions(+) diff --git a/java-numbers-3/src/main/java/com/baeldung/formatNumber/FormatNumber.java b/java-numbers-3/src/main/java/com/baeldung/formatNumber/FormatNumber.java index 6a16fffa7e..b7c54eb6be 100644 --- a/java-numbers-3/src/main/java/com/baeldung/formatNumber/FormatNumber.java +++ b/java-numbers-3/src/main/java/com/baeldung/formatNumber/FormatNumber.java @@ -40,5 +40,34 @@ public class FormatNumber { public static String withStringFormat(double value, int places) { return String.format("%." + places + "f", value); } + + public static String byPaddingOutZeros(int value, int paddingLength) { + return String.format("%0" + paddingLength + "d", value); + } + + public static double withTwoDecimalPlaces(double value) { + DecimalFormat df = new DecimalFormat("#.00"); + return new Double(df.format(value)); + } + + public static String withLongNumbers(double value) { + DecimalFormat df = new DecimalFormat("###,###,###"); + return df.format(value); + } + + public static String forPercentages(double value, Locale localisation) { + NumberFormat nf = NumberFormat.getPercentInstance(localisation); + return nf.format(value); + } + + public static String currencyWithChosenLocalisation(double value, Locale localisation) { + NumberFormat nf = NumberFormat.getCurrencyInstance(localisation); + return nf.format(value); + } + + public static String currencyWithDefaultLocalisation(double value) { + NumberFormat nf = NumberFormat.getCurrencyInstance(); + return nf.format(value); + } } diff --git a/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java b/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java index ef3700e27a..514ca45cdb 100644 --- a/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java +++ b/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java @@ -2,6 +2,8 @@ package com.baeldung.formatNumber; import org.junit.Test; +import java.util.Locale; + import static com.baeldung.formatNumber.FormatNumber.*; import static org.assertj.core.api.Assertions.*; @@ -43,4 +45,44 @@ public class FormatNumberUnitTest { assertThat(withMathRound(F, 2)).isEqualTo(8.7); assertThat(withMathRound(F, 3)).isEqualTo(8.699); } + + @Test + public void givenIntegerNumber_whenFormatNumber_byPaddingOutZeros_thenGetExpectedResult() { + int value = 1; + assertThat(byPaddingOutZeros(value, 3)).isEqualTo("001"); + } + + @Test + public void givenIntegerNumber_whenFormatNumber_withTwoDecimalPlaces_thenGetExpectedResult() { + int value = 12; + assertThat(withTwoDecimalPlaces(value)).isEqualTo(12.00); + } + + @Test + public void givenIntegerNumber_whenFormatNumber_withLongNumbers_thenGetExpectedResult() { + int value = 123456789; + assertThat(withLongNumbers(value)).isEqualTo("123,456,789"); + } + + @Test + public void givenDecimalNumber_whenFormatNumber_forPercentages_thenGetExpectedResult() { + double value = 25f / 100f; + assertThat(forPercentages(value, new Locale("en", "US"))).isEqualTo("25%"); + assertThat(forPercentages(value, new Locale("pl", "PL"))).isEqualTo("25%"); + } + + @Test + public void givenCurrency_whenFormatNumber_currencyWithChosenLocalisation_thenGetExpectedResult() { + double value = 23_500; + assertThat(currencyWithChosenLocalisation(value, new Locale("en", "US"))).isEqualTo("$23,500.00"); + assertThat(currencyWithChosenLocalisation(value, new Locale("zh", "CN"))).isEqualTo("￥23,500.00"); + assertThat(currencyWithChosenLocalisation(value, new Locale("pl", "PL"))).isEqualTo("23 500 zł"); + } + + @Test + public void givenCurrency_whenFormatNumber_currencyWithDefaultLocalisation_thenGetExpectedResult() { + double value = 23_500; + assertThat(currencyWithDefaultLocalisation(value)).isEqualTo("£23,500.00"); + } + } From 5edaf2cb292757fc6799fc619cf27dc3d767071c Mon Sep 17 00:00:00 2001 From: Marcin Krykowski Date: Sat, 13 Jun 2020 23:53:44 +0100 Subject: [PATCH 10/13] Rename method --- .../src/main/java/com/baeldung/formatNumber/FormatNumber.java | 2 +- .../java/com/baeldung/formatNumber/FormatNumberUnitTest.java | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/java-numbers-3/src/main/java/com/baeldung/formatNumber/FormatNumber.java b/java-numbers-3/src/main/java/com/baeldung/formatNumber/FormatNumber.java index b7c54eb6be..6b9806fe22 100644 --- a/java-numbers-3/src/main/java/com/baeldung/formatNumber/FormatNumber.java +++ b/java-numbers-3/src/main/java/com/baeldung/formatNumber/FormatNumber.java @@ -50,7 +50,7 @@ public class FormatNumber { return new Double(df.format(value)); } - public static String withLongNumbers(double value) { + public static String withLargeIntegers(double value) { DecimalFormat df = new DecimalFormat("###,###,###"); return df.format(value); } diff --git a/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java b/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java index 514ca45cdb..a0fe21b8d5 100644 --- a/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java +++ b/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java @@ -59,9 +59,9 @@ public class FormatNumberUnitTest { } @Test - public void givenIntegerNumber_whenFormatNumber_withLongNumbers_thenGetExpectedResult() { + public void givenIntegerNumber_whenFormatNumber_withLargeIntegers_thenGetExpectedResult() { int value = 123456789; - assertThat(withLongNumbers(value)).isEqualTo("123,456,789"); + assertThat(withLargeIntegers(value)).isEqualTo("123,456,789"); } @Test From 11e6f61f9dd10fa1152874ae51ef00a199ab4158 Mon Sep 17 00:00:00 2001 From: Marcin Krykowski Date: Sun, 14 Jun 2020 09:08:10 +0100 Subject: [PATCH 11/13] Remove test for current localisation as it was failing at prod due to different systems --- .../com/baeldung/formatNumber/FormatNumberUnitTest.java | 6 ------ 1 file changed, 6 deletions(-) diff --git a/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java b/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java index a0fe21b8d5..190a5aa8ba 100644 --- a/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java +++ b/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java @@ -79,10 +79,4 @@ public class FormatNumberUnitTest { assertThat(currencyWithChosenLocalisation(value, new Locale("pl", "PL"))).isEqualTo("23 500 zł"); } - @Test - public void givenCurrency_whenFormatNumber_currencyWithDefaultLocalisation_thenGetExpectedResult() { - double value = 23_500; - assertThat(currencyWithDefaultLocalisation(value)).isEqualTo("£23,500.00"); - } - } From 998dd8f7b647ea00dd83fdb3359a7570a15e641d Mon Sep 17 00:00:00 2001 From: Marcin Krykowski Date: Mon, 15 Jun 2020 22:48:06 +0100 Subject: [PATCH 12/13] Refactor method name --- .../src/main/java/com/baeldung/formatNumber/FormatNumber.java | 2 +- .../java/com/baeldung/formatNumber/FormatNumberUnitTest.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/java-numbers-3/src/main/java/com/baeldung/formatNumber/FormatNumber.java b/java-numbers-3/src/main/java/com/baeldung/formatNumber/FormatNumber.java index 6b9806fe22..1fdcdd4247 100644 --- a/java-numbers-3/src/main/java/com/baeldung/formatNumber/FormatNumber.java +++ b/java-numbers-3/src/main/java/com/baeldung/formatNumber/FormatNumber.java @@ -41,7 +41,7 @@ public class FormatNumber { return String.format("%." + places + "f", value); } - public static String byPaddingOutZeros(int value, int paddingLength) { + public static String byPaddingZeros(int value, int paddingLength) { return String.format("%0" + paddingLength + "d", value); } diff --git a/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java b/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java index 190a5aa8ba..6fc946f8ba 100644 --- a/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java +++ b/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java @@ -49,7 +49,7 @@ public class FormatNumberUnitTest { @Test public void givenIntegerNumber_whenFormatNumber_byPaddingOutZeros_thenGetExpectedResult() { int value = 1; - assertThat(byPaddingOutZeros(value, 3)).isEqualTo("001"); + assertThat(byPaddingZeros(value, 3)).isEqualTo("001"); } @Test From a83735a360e2e97a217d4077e3be9eec3a371a2d Mon Sep 17 00:00:00 2001 From: Marcin Krykowski Date: Tue, 23 Jun 2020 09:51:56 +0100 Subject: [PATCH 13/13] Correct test naming --- .../formatNumber/FormatNumberUnitTest.java | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java b/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java index 6fc946f8ba..4f0358c6a2 100644 --- a/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java +++ b/java-numbers-3/src/test/java/com/baeldung/formatNumber/FormatNumberUnitTest.java @@ -12,7 +12,7 @@ public class FormatNumberUnitTest { private static final double F = 8.6994540927d; @Test - public void givenDecimalNumber_whenFormatNumber_withBigDecimal_thenGetExpectedResult() { + public void givenDecimalNumber_whenFormatNumberWithBigDecimal_thenGetExpectedResult() { assertThat(withBigDecimal(D, 2)).isEqualTo(4.24); assertThat(withBigDecimal(D, 3)).isEqualTo(4.235); assertThat(withBigDecimal(F, 2)).isEqualTo(8.7); @@ -20,7 +20,7 @@ public class FormatNumberUnitTest { } @Test - public void givenDecimalNumber_whenFormatNumber_withDecimalFormat_thenGetExpectedResult() { + public void givenDecimalNumber_whenFormatNumberWithDecimalFormat_thenGetExpectedResult() { assertThat(withDecimalFormatLocal(D)).isEqualTo(4.235); assertThat(withDecimalFormatLocal(F)).isEqualTo(8.699); @@ -31,7 +31,7 @@ public class FormatNumberUnitTest { } @Test - public void givenDecimalNumber_whenFormatNumber_withStringFormat_thenGetExpectedResult() { + public void givenDecimalNumber_whenFormatNumberWithStringFormat_thenGetExpectedResult() { assertThat(withStringFormat(D, 2)).isEqualTo("4.24"); assertThat(withStringFormat(D, 3)).isEqualTo("4.235"); assertThat(withStringFormat(F, 2)).isEqualTo("8.70"); @@ -39,7 +39,7 @@ public class FormatNumberUnitTest { } @Test - public void givenDecimalNumber_whenFormatNumber_withMathRound_thenGetExpectedResult() { + public void givenDecimalNumber_whenFormatNumberWithMathRound_thenGetExpectedResult() { assertThat(withMathRound(D, 2)).isEqualTo(4.24); assertThat(withMathRound(D, 3)).isEqualTo(4.235); assertThat(withMathRound(F, 2)).isEqualTo(8.7); @@ -47,32 +47,32 @@ public class FormatNumberUnitTest { } @Test - public void givenIntegerNumber_whenFormatNumber_byPaddingOutZeros_thenGetExpectedResult() { + public void givenIntegerNumber_whenFormatNumberByPaddingOutZeros_thenGetExpectedResult() { int value = 1; assertThat(byPaddingZeros(value, 3)).isEqualTo("001"); } @Test - public void givenIntegerNumber_whenFormatNumber_withTwoDecimalPlaces_thenGetExpectedResult() { + public void givenIntegerNumber_whenFormatNumberWithTwoDecimalPlaces_thenGetExpectedResult() { int value = 12; assertThat(withTwoDecimalPlaces(value)).isEqualTo(12.00); } @Test - public void givenIntegerNumber_whenFormatNumber_withLargeIntegers_thenGetExpectedResult() { + public void givenIntegerNumber_whenFormatNumberWithLargeIntegers_thenGetExpectedResult() { int value = 123456789; assertThat(withLargeIntegers(value)).isEqualTo("123,456,789"); } @Test - public void givenDecimalNumber_whenFormatNumber_forPercentages_thenGetExpectedResult() { + public void givenDecimalNumber_whenFormatNumberForPercentages_thenGetExpectedResult() { double value = 25f / 100f; assertThat(forPercentages(value, new Locale("en", "US"))).isEqualTo("25%"); assertThat(forPercentages(value, new Locale("pl", "PL"))).isEqualTo("25%"); } @Test - public void givenCurrency_whenFormatNumber_currencyWithChosenLocalisation_thenGetExpectedResult() { + public void givenCurrency_whenFormatNumberCurrencyWithChosenLocalisation_thenGetExpectedResult() { double value = 23_500; assertThat(currencyWithChosenLocalisation(value, new Locale("en", "US"))).isEqualTo("$23,500.00"); assertThat(currencyWithChosenLocalisation(value, new Locale("zh", "CN"))).isEqualTo("￥23,500.00");