From bf02e07d22eb9dfd5e62f2fa979459dedbc65a6f Mon Sep 17 00:00:00 2001 From: Eugene Kovko Date: Tue, 2 Sep 2025 18:14:35 +0200 Subject: [PATCH] BAEL-9300: Added simple examples with tests --- .../doublenonvalues/DoubleNonValues.java | 84 +++++++++++++++++++ .../DoubleNonValuesUnitTest.java | 80 ++++++++++++++++++ 2 files changed, 164 insertions(+) create mode 100644 core-java-modules/core-java-numbers-10/src/main/java/com/baeldung/doublenonvalues/DoubleNonValues.java create mode 100644 core-java-modules/core-java-numbers-10/src/test/java/com/baeldung/doublenonvalues/DoubleNonValuesUnitTest.java diff --git a/core-java-modules/core-java-numbers-10/src/main/java/com/baeldung/doublenonvalues/DoubleNonValues.java b/core-java-modules/core-java-numbers-10/src/main/java/com/baeldung/doublenonvalues/DoubleNonValues.java new file mode 100644 index 000000000000..873435fdd06a --- /dev/null +++ b/core-java-modules/core-java-numbers-10/src/main/java/com/baeldung/doublenonvalues/DoubleNonValues.java @@ -0,0 +1,84 @@ +package com.baeldung.doublenonvalues; + +public class DoubleNonValues { + + public static double findLargestThrowException(double[] array) { + if (array.length == 0) { + throw new IllegalArgumentException("Array cannot be empty"); + } + + double max = array[0]; + for (int i = 1; i < array.length; i++) { + if (array[i] > max) { + max = array[i]; + } + } + return max; + } + + public static double findLargestIgnoreNonValues(double[] array) { + double max = Double.NEGATIVE_INFINITY; + boolean foundValidValue = false; + + for (double value : array) { + if (!Double.isNaN(value) && !Double.isInfinite(value)) { + if (!foundValidValue || value > max) { + max = value; + foundValidValue = true; + } + } + } + + return foundValidValue ? max : -1.0; + } + + public static double findLargestReturnNegativeOne(double[] array) { + if (array.length == 0) { + return -1.0; + } + + double max = Double.NEGATIVE_INFINITY; + boolean foundValidValue = false; + + for (double value : array) { + if (!Double.isNaN(value) && !Double.isInfinite(value)) { + if (!foundValidValue || value > max) { + max = value; + foundValidValue = true; + } + } + } + + return foundValidValue ? max : -1.0; + } + + public static Double findLargestWithWrapper(double[] array) { + Double max = null; + + for (double value : array) { + if (!Double.isNaN(value) && !Double.isInfinite(value)) { + if (max == null || value > max) { + max = value; + } + } + } + + return max; + } + + public static double findLargestReturnNaN(double[] array) { + double max = Double.NEGATIVE_INFINITY; + boolean foundValidValue = false; + + for (double value : array) { + if (!Double.isNaN(value) && !Double.isInfinite(value)) { + if (!foundValidValue || value > max) { + max = value; + foundValidValue = true; + } + } + } + + return foundValidValue ? max : Double.NaN; + } +} diff --git a/core-java-modules/core-java-numbers-10/src/test/java/com/baeldung/doublenonvalues/DoubleNonValuesUnitTest.java b/core-java-modules/core-java-numbers-10/src/test/java/com/baeldung/doublenonvalues/DoubleNonValuesUnitTest.java new file mode 100644 index 000000000000..4f42f0c24cdd --- /dev/null +++ b/core-java-modules/core-java-numbers-10/src/test/java/com/baeldung/doublenonvalues/DoubleNonValuesUnitTest.java @@ -0,0 +1,80 @@ +package com.baeldung.doublenonvalues; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import org.junit.jupiter.api.Test; + +public class DoubleNonValuesUnitTest { + + @Test + public void testDemonstrateNaNBehavior() { + double nan1 = Double.NaN; + double nan2 = Double.NaN; + + // Test that NaN == NaN is always false + assertFalse(nan1 == nan2); + + // Test that Double.isNaN() correctly identifies NaN values + assertTrue(Double.isNaN(nan1)); + assertTrue(Double.isNaN(nan2)); + + // Test that the method returns the expected string + String result = DoubleNonValues.demonstrateNaNBehavior(); + assertTrue(result.contains("NaN comparison behavior:")); + assertTrue(result.contains("Double.NaN == Double.NaN: false")); + assertTrue(result.contains("Double.isNaN(Double.NaN): true")); + } + + @Test + public void testFindLargestThrowException() { + double[] validArray = {1.0, 5.0, 3.0, 9.0, 2.0}; + assertEquals(9.0, DoubleNonValues.findLargestThrowException(validArray)); + + // Test that it throws exception for empty array + assertThrows(IllegalArgumentException.class, () -> { + DoubleNonValues.findLargestThrowException(new double[]{}); + }); + } + + @Test + public void testFindLargestIgnoreNonValues() { + double[] arrayWithNaN = {1.0, Double.NaN, 5.0, Double.POSITIVE_INFINITY, 3.0}; + assertEquals(5.0, DoubleNonValues.findLargestIgnoreNonValues(arrayWithNaN)); + + double[] allInvalidArray = {Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY}; + assertEquals(-1.0, DoubleNonValues.findLargestIgnoreNonValues(allInvalidArray)); + } + + @Test + public void testFindLargestReturnNegativeOne() { + double[] arrayWithNaN = {1.0, Double.NaN, 5.0, Double.POSITIVE_INFINITY, 3.0}; + assertEquals(5.0, DoubleNonValues.findLargestReturnNegativeOne(arrayWithNaN)); + + double[] allInvalidArray = {Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY}; + assertEquals(-1.0, DoubleNonValues.findLargestReturnNegativeOne(allInvalidArray)); + + // Test empty array returns -1.0 + assertEquals(-1.0, DoubleNonValues.findLargestReturnNegativeOne(new double[]{})); + } + + @Test + public void testFindLargestWithWrapper() { + double[] arrayWithNaN = {1.0, Double.NaN, 5.0, Double.POSITIVE_INFINITY, 3.0}; + assertEquals(5.0, DoubleNonValues.findLargestWithWrapper(arrayWithNaN)); + + double[] allInvalidArray = {Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY}; + assertNull(DoubleNonValues.findLargestWithWrapper(allInvalidArray)); + } + + @Test + public void testFindLargestReturnNaN() { + double[] arrayWithNaN = {1.0, Double.NaN, 5.0, Double.POSITIVE_INFINITY, 3.0}; + assertEquals(5.0, DoubleNonValues.findLargestReturnNaN(arrayWithNaN)); + + double[] allInvalidArray = {Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY}; + assertTrue(Double.isNaN(DoubleNonValues.findLargestReturnNaN(allInvalidArray))); + } +}