Merge branch 'eugenp:master' into danielmcnally285_return_first_non_null

core-java-modules/core-java-17/src/main/java/com/baeldung/deserializationfilters/ContextSpecificDeserializationFilterFactory.java

@@ -0,0 +1,47 @@
+package com.baeldung.deserializationfilters;
+
+import java.io.ObjectInputFilter;
+import java.util.function.BinaryOperator;
+
+import com.baeldung.deserializationfilters.service.DeserializationService;
+import com.baeldung.deserializationfilters.service.LimitedArrayService;
+import com.baeldung.deserializationfilters.service.LowDepthService;
+import com.baeldung.deserializationfilters.service.SmallObjectService;
+import com.baeldung.deserializationfilters.utils.FilterUtils;
+
+public class ContextSpecificDeserializationFilterFactory implements BinaryOperator<ObjectInputFilter> {
+
+    @Override
+    public ObjectInputFilter apply(ObjectInputFilter current, ObjectInputFilter next) {
+        if (current == null) {
+            Class<?> caller = findInStack(DeserializationService.class);
+
+            if (caller == null) {
+                current = FilterUtils.fallbackFilter();
+            } else if (caller.equals(SmallObjectService.class)) {
+                current = FilterUtils.safeSizeFilter(190);
+            } else if (caller.equals(LowDepthService.class)) {
+                current = FilterUtils.safeDepthFilter(2);
+            } else if (caller.equals(LimitedArrayService.class)) {
+                current = FilterUtils.safeArrayFilter(3);
+            }
+        }
+
+        return ObjectInputFilter.merge(current, next);
+    }
+
+    private static Class<?> findInStack(Class<?> superType) {
+        for (StackTraceElement element : Thread.currentThread()
+            .getStackTrace()) {
+            try {
+                Class<?> subType = Class.forName(element.getClassName());
+                if (superType.isAssignableFrom(subType)) {
+                    return subType;
+                }
+            } catch (ClassNotFoundException e) {
+                return null;
+            }
+        }
+        return null;
+    }
+}

core-java-modules/core-java-17/src/main/java/com/baeldung/deserializationfilters/pojo/ContextSpecific.java

@@ -0,0 +1,7 @@
+package com.baeldung.deserializationfilters.pojo;
+
+import java.io.Serializable;
+
+public interface ContextSpecific extends Serializable {
+
+}

core-java-modules/core-java-17/src/main/java/com/baeldung/deserializationfilters/pojo/NestedSample.java

@@ -0,0 +1,19 @@
+package com.baeldung.deserializationfilters.pojo;
+
+public class NestedSample implements ContextSpecific {
+    private static final long serialVersionUID = 1L;
+
+    private Sample optional;
+
+    public NestedSample(Sample optional) {
+        this.optional = optional;
+    }
+
+    public Sample getOptional() {
+        return optional;
+    }
+
+    public void setOptional(Sample optional) {
+        this.optional = optional;
+    }
+}

core-java-modules/core-java-17/src/main/java/com/baeldung/deserializationfilters/pojo/Sample.java

@@ -0,0 +1,61 @@
+package com.baeldung.deserializationfilters.pojo;
+
+public class Sample implements ContextSpecific, Comparable<Sample> {
+    private static final long serialVersionUID = 1L;
+
+    private int[] array;
+    private String name;
+    private NestedSample nested;
+
+    public Sample(String name) {
+        this.name = name;
+    }
+
+    public Sample(int[] array) {
+        this.array = array;
+    }
+
+    public Sample(NestedSample nested) {
+        this.nested = nested;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int[] getArray() {
+        return array;
+    }
+
+    public void setArray(int[] array) {
+        this.array = array;
+    }
+
+    public NestedSample getNested() {
+        return nested;
+    }
+
+    public void setNested(NestedSample nested) {
+        this.nested = nested;
+    }
+
+    @Override
+    public String toString() {
+        return name;
+    }
+
+    @Override
+    public int compareTo(Sample o) {
+        if (name == null)
+            return -1;
+
+        if (o == null || o.getName() == null)
+            return 1;
+
+        return getName().compareTo(o.getName());
+    }
+}

core-java-modules/core-java-17/src/main/java/com/baeldung/deserializationfilters/pojo/SampleExploit.java

@@ -0,0 +1,25 @@
+package com.baeldung.deserializationfilters.pojo;
+
+public class SampleExploit extends Sample {
+    private static final long serialVersionUID = 1L;
+
+    public SampleExploit() {
+        super("exploit");
+    }
+
+    public static void maliciousCode() {
+        System.out.println("exploit executed");
+    }
+
+    @Override
+    public String toString() {
+        maliciousCode();
+        return "exploit";
+    }
+
+    @Override
+    public int compareTo(Sample o) {
+        maliciousCode();
+        return super.compareTo(o);
+    }
+}

core-java-modules/core-java-17/src/main/java/com/baeldung/deserializationfilters/service/DeserializationService.java

@@ -0,0 +1,11 @@
+package com.baeldung.deserializationfilters.service;
+
+import java.io.InputStream;
+import java.util.Set;
+
+import com.baeldung.deserializationfilters.pojo.ContextSpecific;
+
+public interface DeserializationService {
+
+    Set<ContextSpecific> process(InputStream... inputStreams);
+}

core-java-modules/core-java-17/src/main/java/com/baeldung/deserializationfilters/service/LimitedArrayService.java

@@ -0,0 +1,15 @@
+package com.baeldung.deserializationfilters.service;
+
+import java.io.InputStream;
+import java.util.Set;
+
+import com.baeldung.deserializationfilters.pojo.ContextSpecific;
+import com.baeldung.deserializationfilters.utils.DeserializationUtils;
+
+public class LimitedArrayService implements DeserializationService {
+
+    @Override
+    public Set<ContextSpecific> process(InputStream... inputStreams) {
+        return DeserializationUtils.deserializeIntoSet(inputStreams);
+    }
+}

core-java-modules/core-java-17/src/main/java/com/baeldung/deserializationfilters/service/LowDepthService.java

@@ -0,0 +1,20 @@
+package com.baeldung.deserializationfilters.service;
+
+import java.io.InputStream;
+import java.io.ObjectInputFilter;
+import java.util.Set;
+
+import com.baeldung.deserializationfilters.pojo.ContextSpecific;
+import com.baeldung.deserializationfilters.utils.DeserializationUtils;
+
+public class LowDepthService implements DeserializationService {
+
+    public Set<ContextSpecific> process(ObjectInputFilter filter, InputStream... inputStreams) {
+        return DeserializationUtils.deserializeIntoSet(filter, inputStreams);
+    }
+
+    @Override
+    public Set<ContextSpecific> process(InputStream... inputStreams) {
+        return process(null, inputStreams);
+    }
+}

core-java-modules/core-java-17/src/main/java/com/baeldung/deserializationfilters/service/SmallObjectService.java

@@ -0,0 +1,15 @@
+package com.baeldung.deserializationfilters.service;
+
+import java.io.InputStream;
+import java.util.Set;
+
+import com.baeldung.deserializationfilters.pojo.ContextSpecific;
+import com.baeldung.deserializationfilters.utils.DeserializationUtils;
+
+public class SmallObjectService implements DeserializationService {
+
+    @Override
+    public Set<ContextSpecific> process(InputStream... inputStreams) {
+        return DeserializationUtils.deserializeIntoSet(inputStreams);
+    }
+}

core-java-modules/core-java-17/src/main/java/com/baeldung/deserializationfilters/utils/DeserializationUtils.java

@@ -0,0 +1,50 @@
+package com.baeldung.deserializationfilters.utils;
+
+import java.io.InputStream;
+import java.io.InvalidClassException;
+import java.io.ObjectInputFilter;
+import java.io.ObjectInputStream;
+import java.util.Set;
+import java.util.TreeSet;
+
+import com.baeldung.deserializationfilters.pojo.ContextSpecific;
+
+public class DeserializationUtils {
+    private DeserializationUtils() {
+    }
+
+    public static Object deserialize(InputStream inStream) {
+        return deserialize(inStream, null);
+    }
+
+    public static Object deserialize(InputStream inStream, ObjectInputFilter filter) {
+        try (ObjectInputStream in = new ObjectInputStream(inStream)) {
+            if (filter != null) {
+                in.setObjectInputFilter(filter);
+            }
+            return in.readObject();
+        } catch (InvalidClassException e) {
+            return null;
+        } catch (Throwable e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public static Set<ContextSpecific> deserializeIntoSet(InputStream... inputStreams) {
+        return deserializeIntoSet(null, inputStreams);
+    }
+
+    public static Set<ContextSpecific> deserializeIntoSet(ObjectInputFilter filter, InputStream... inputStreams) {
+        Set<ContextSpecific> set = new TreeSet<>();
+
+        for (InputStream inputStream : inputStreams) {
+            Object object = deserialize(inputStream, filter);
+            if (object != null) {
+                set.add((ContextSpecific) object);
+            }
+        }
+
+        return set;
+    }
+}

core-java-modules/core-java-17/src/main/java/com/baeldung/deserializationfilters/utils/FilterUtils.java

@@ -0,0 +1,32 @@
+package com.baeldung.deserializationfilters.utils;
+
+import java.io.ObjectInputFilter;
+
+public class FilterUtils {
+
+    private static final String DEFAULT_PACKAGE_PATTERN = "java.base/*;!*";
+    private static final String POJO_PACKAGE = "com.baeldung.deserializationfilters.pojo";
+
+    private FilterUtils() {
+    }
+
+    private static ObjectInputFilter baseFilter(String parameter, int max) {
+        return ObjectInputFilter.Config.createFilter(String.format("%s=%d;%s.**;%s", parameter, max, POJO_PACKAGE, DEFAULT_PACKAGE_PATTERN));
+    }
+
+    public static ObjectInputFilter fallbackFilter() {
+        return ObjectInputFilter.Config.createFilter(String.format("%s", DEFAULT_PACKAGE_PATTERN));
+    }
+
+    public static ObjectInputFilter safeSizeFilter(int max) {
+        return baseFilter("maxbytes", max);
+    }
+
+    public static ObjectInputFilter safeArrayFilter(int max) {
+        return baseFilter("maxarray", max);
+    }
+
+    public static ObjectInputFilter safeDepthFilter(int max) {
+        return baseFilter("maxdepth", max);
+    }
+}

core-java-modules/core-java-17/src/main/java/com/baeldung/deserializationfilters/utils/SerializationUtils.java

@@ -0,0 +1,17 @@
+package com.baeldung.deserializationfilters.utils;
+
+import java.io.IOException;
+import java.io.ObjectOutputStream;
+import java.io.OutputStream;
+
+public class SerializationUtils {
+
+    private SerializationUtils() {
+    }
+
+    public static void serialize(Object object, OutputStream outStream) throws IOException {
+        try (ObjectOutputStream objStream = new ObjectOutputStream(outStream)) {
+            objStream.writeObject(object);
+        }
+    }
+}

core-java-modules/core-java-17/src/test/java/com/baeldung/deserializationfilters/ContextSpecificDeserializationFilterIntegrationTest.java

@@ -0,0 +1,119 @@
+package com.baeldung.deserializationfilters;
+
+import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputFilter;
+import java.util.Set;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import com.baeldung.deserializationfilters.pojo.ContextSpecific;
+import com.baeldung.deserializationfilters.pojo.NestedSample;
+import com.baeldung.deserializationfilters.pojo.Sample;
+import com.baeldung.deserializationfilters.pojo.SampleExploit;
+import com.baeldung.deserializationfilters.service.LimitedArrayService;
+import com.baeldung.deserializationfilters.service.LowDepthService;
+import com.baeldung.deserializationfilters.service.SmallObjectService;
+import com.baeldung.deserializationfilters.utils.DeserializationUtils;
+import com.baeldung.deserializationfilters.utils.FilterUtils;
+import com.baeldung.deserializationfilters.utils.SerializationUtils;
+
+public class ContextSpecificDeserializationFilterIntegrationTest {
+
+    private static ByteArrayOutputStream serialSampleA = new ByteArrayOutputStream();
+    private static ByteArrayOutputStream serialBigSampleA = new ByteArrayOutputStream();
+
+    private static ByteArrayOutputStream serialSampleB = new ByteArrayOutputStream();
+    private static ByteArrayOutputStream serialBigSampleB = new ByteArrayOutputStream();
+
+    private static ByteArrayOutputStream serialSampleC = new ByteArrayOutputStream();
+    private static ByteArrayOutputStream serialBigSampleC = new ByteArrayOutputStream();
+
+    private static ByteArrayInputStream bytes(ByteArrayOutputStream stream) {
+        return new ByteArrayInputStream(stream.toByteArray());
+    }
+
+    @BeforeAll
+    static void setup() throws IOException {
+        ObjectInputFilter.Config.setSerialFilterFactory(new ContextSpecificDeserializationFilterFactory());
+
+        SerializationUtils.serialize(new Sample("simple"), serialSampleA);
+        SerializationUtils.serialize(new SampleExploit(), serialBigSampleA);
+
+        SerializationUtils.serialize(new Sample(new int[] { 1, 2, 3 }), serialSampleB);
+        SerializationUtils.serialize(new Sample(new int[] { 1, 2, 3, 4, 5, 6 }), serialBigSampleB);
+
+        SerializationUtils.serialize(new Sample(new NestedSample(null)), serialSampleC);
+        SerializationUtils.serialize(new Sample(new NestedSample(new Sample("deep"))), serialBigSampleC);
+    }
+
+    @Test
+    void whenSmallObjectContext_thenCorrectFilterApplied() {
+        Set<ContextSpecific> result = new SmallObjectService().process( //
+            bytes(serialSampleA), //
+            bytes(serialBigSampleA));
+
+        assertEquals(1, result.size());
+        assertEquals("simple", ((Sample) result.iterator()
+            .next()).getName());
+    }
+
+    @Test
+    void whenLimitedArrayContext_thenCorrectFilterApplied() {
+        Set<ContextSpecific> result = new LimitedArrayService().process( //
+            bytes(serialSampleB), //
+            bytes(serialBigSampleB));
+
+        assertEquals(1, result.size());
+    }
+
+    @Test
+    void whenLowDepthContext_thenCorrectFilterApplied() {
+        Set<ContextSpecific> result = new LowDepthService().process( //
+            bytes(serialSampleC), //
+            bytes(serialBigSampleC));
+
+        assertEquals(1, result.size());
+    }
+
+    @Test
+    void givenExtraFilter_whenCombinedContext_thenMergedFiltersApplied() {
+        Set<ContextSpecific> result = new LowDepthService().process( //
+            FilterUtils.safeSizeFilter(190), //
+            bytes(serialSampleA), //
+            bytes(serialBigSampleA), //
+            bytes(serialSampleC), //
+            bytes(serialBigSampleC));
+
+        assertEquals(1, result.size());
+        assertEquals("simple", ((Sample) result.iterator()
+            .next()).getName());
+    }
+
+    @Test
+    void givenFallbackContext_whenUsingBaseClasses_thenRestrictiveFilterApplied() throws IOException {
+        String a = new String("a");
+        ByteArrayOutputStream outStream = new ByteArrayOutputStream();
+        SerializationUtils.serialize(a, outStream);
+
+        String deserializedA = (String) DeserializationUtils.deserialize(bytes(outStream));
+
+        assertEquals(a, deserializedA);
+    }
+
+    @Test
+    void givenFallbackContext_whenUsingAppClasses_thenRejected() throws IOException {
+        Sample a = new Sample("a");
+        ByteArrayOutputStream outStream = new ByteArrayOutputStream();
+        SerializationUtils.serialize(a, outStream);
+
+        Sample deserializedA = (Sample) DeserializationUtils.deserialize(bytes(outStream));
+
+        assertNull(deserializedA);
+    }
+}

core-java-modules/core-java-17/src/test/java/com/baeldung/sealed/classes/VehicleUnitTest.java

@@ -18,19 +18,19 @@ public class VehicleUnitTest {
     }
 
     @Test
-    public void givenCar_whenUsingReflectionAPI_thenSuperClassIsSealed() {
+    public void givenCar_whenUsingReflectionAPI_thenSuperClassIsSealed() throws ClassNotFoundException {
         Assertions.assertThat(car.getClass().isSealed()).isEqualTo(false);
         Assertions.assertThat(car.getClass().getSuperclass().isSealed()).isEqualTo(true);
         Assertions.assertThat(car.getClass().getSuperclass().getPermittedSubclasses())
-                .contains(ClassDesc.of(car.getClass().getCanonicalName()));
+                .contains(Class.forName(car.getClass().getCanonicalName()));
     }
 
     @Test
-    public void givenTruck_whenUsingReflectionAPI_thenSuperClassIsSealed() {
+    public void givenTruck_whenUsingReflectionAPI_thenSuperClassIsSealed() throws ClassNotFoundException {
         Assertions.assertThat(truck.getClass().isSealed()).isEqualTo(false);
         Assertions.assertThat(truck.getClass().getSuperclass().isSealed()).isEqualTo(true);
         Assertions.assertThat(truck.getClass().getSuperclass().getPermittedSubclasses())
-                .contains(ClassDesc.of(truck.getClass().getCanonicalName()));
+                .contains(Class.forName(truck.getClass().getCanonicalName()));
     }
 
     @Test

core-java-modules/core-java-17/src/test/java/com/baeldung/sealed/records/VehicleUnitTest.java

@@ -18,19 +18,19 @@ public class VehicleUnitTest {
     }
 
     @Test
-    public void givenCar_whenUsingReflectionAPI_thenInterfaceIsSealed() {
+    public void givenCar_whenUsingReflectionAPI_thenInterfaceIsSealed() throws ClassNotFoundException {
         Assertions.assertThat(car.getClass().isSealed()).isEqualTo(false);
         Assertions.assertThat(car.getClass().getInterfaces()[0].isSealed()).isEqualTo(true);
-        Assertions.assertThat(car.getClass().getInterfaces()[0].permittedSubclasses())
-                .contains(ClassDesc.of(car.getClass().getCanonicalName()));
+        Assertions.assertThat(car.getClass().getInterfaces()[0].getPermittedSubclasses())
+                .contains(Class.forName(car.getClass().getCanonicalName()));
     }
 
     @Test
-    public void givenTruck_whenUsingReflectionAPI_thenInterfaceIsSealed() {
+    public void givenTruck_whenUsingReflectionAPI_thenInterfaceIsSealed() throws ClassNotFoundException {
         Assertions.assertThat(truck.getClass().isSealed()).isEqualTo(false);
         Assertions.assertThat(truck.getClass().getInterfaces()[0].isSealed()).isEqualTo(true);
-        Assertions.assertThat(truck.getClass().getInterfaces()[0].permittedSubclasses())
-                .contains(ClassDesc.of(truck.getClass().getCanonicalName()));
+        Assertions.assertThat(truck.getClass().getInterfaces()[0].getPermittedSubclasses())
+                .contains(Class.forName(truck.getClass().getCanonicalName()));
     }
 
     @Test

core-java-modules/core-java-8-datetime-2/README.md

@@ -6,4 +6,5 @@
 - [How Many Days Are There in a Particular Month of a Given Year?](https://www.baeldung.com/days-particular-month-given-year)
 - [Difference Between Instant and LocalDateTime](https://www.baeldung.com/java-instant-vs-localdatetime)
 - [Add Minutes to a Time String in Java](https://www.baeldung.com/java-string-time-add-mins)
+- [Round the Date in Java](https://www.baeldung.com/java-round-the-date)
 - [[<-- Prev]](/core-java-modules/core-java-datetime-java8-1)

core-java-modules/core-java-8-datetime-2/pom.xml

@@ -55,7 +55,7 @@
     <properties>
         <maven.compiler.source>1.8</maven.compiler.source>
         <maven.compiler.target>1.8</maven.compiler.target>
-        <joda-time.version>2.10</joda-time.version>
+        <joda-time.version>2.12.5</joda-time.version>
     </properties>
 
 </project>

core-java-modules/core-java-8-datetime-2/src/main/java/com/baeldung/maxdate/DateComparison.java

@@ -0,0 +1,18 @@
+package com.baeldung.maxdate;
+
+import java.util.Date;
+
+public class DateComparison {
+    public int compareTodayWithMaxDate() {
+        Date today = new Date();
+        Date maxDate = new Date(Long.MAX_VALUE);
+
+        int comparisonResult = today.compareTo(maxDate);
+        return comparisonResult;
+    }
+
+    public static void main(String[] args) {
+        DateComparison comparator = new DateComparison();
+        System.out.println(comparator.compareTodayWithMaxDate());
+    }
+}

core-java-modules/core-java-8-datetime-2/src/main/java/com/baeldung/maxdate/MaxDateDisplay.java

@@ -0,0 +1,18 @@
+package com.baeldung.maxdate;
+
+import java.util.Date;
+import java.text.SimpleDateFormat;
+
+public class MaxDateDisplay {
+    public String getMaxDateValue() {
+        Date maxDate = new Date(Long.MAX_VALUE);
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
+        return "The maximum date value in Java is: " + sdf.format(maxDate);
+    }
+
+    public static void main(String[] args) {
+        MaxDateDisplay display = new MaxDateDisplay();
+        System.out.println(display.getMaxDateValue());
+    }
+}
+

core-java-modules/core-java-8-datetime-2/src/main/java/com/baeldung/parsingDates/SimpleParseDate.java

@@ -7,7 +7,7 @@ import java.util.List;
 
 public class SimpleParseDate {
 
-    public Date parseDate(String dateString, List<String> formatStrings) {
+    public static Date parseDate(String dateString, List<String> formatStrings) {
         for (String formatString : formatStrings) {
             try {
                 return new SimpleDateFormat(formatString).parse(dateString);

core-java-modules/core-java-8-datetime-2/src/test/java/com/baeldung/maxdate/DateComparisonUnitTest.java

@@ -0,0 +1,16 @@
+package com.baeldung.maxdate;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+class DateComparisonUnitTest {
+
+  @Test
+  void whenCompareTodayWithMaxDate_thenCorrectResult() {
+    DateComparison comparator = new DateComparison();
+    int result = comparator.compareTodayWithMaxDate();
+
+    assertTrue(result < 0);
+  }
+}

core-java-modules/core-java-8-datetime-2/src/test/java/com/baeldung/maxdate/MaxDateDisplayUnitTest.java

@@ -0,0 +1,18 @@
+package com.baeldung.maxdate;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+class MaxDateDisplayUnitTest {
+
+  @Test
+  void whenGetMaxDate_thenCorrectResult() {
+    MaxDateDisplay display = new MaxDateDisplay();
+    String result = display.getMaxDateValue();
+    assertEquals(
+      "The maximum date value in Java is: 292278994-08-17 07:12:55.807",
+      result
+    );
+  }
+}

core-java-modules/core-java-8-datetime-2/src/test/java/com/baeldung/parsingDates/SimpleParseDateUnitTest.java

@@ -1,43 +1,41 @@
 package com.baeldung.parsingDates;
 
-import com.baeldung.parsingDates.SimpleDateTimeFormat;
-import com.baeldung.parsingDates.SimpleDateTimeFormater;
-import com.baeldung.parsingDates.SimpleDateUtils;
-import com.baeldung.parsingDates.SimpleParseDate;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
 import java.time.format.DateTimeParseException;
 import java.util.Arrays;
-import org.junit.*;
-import static org.junit.Assert.*;
+
 import org.joda.time.LocalDate;
+import org.junit.jupiter.api.Test;
 
-public class SimpleParseDateUnitTest {
+class SimpleParseDateUnitTest {
 
     @Test
-    public void whenInvalidInput_thenGettingUnexpectedResult() {
-        SimpleParseDate simpleParseDate = new SimpleParseDate();
+    void whenInvalidInput_thenGettingUnexpectedResult() {
         String date = "2022-40-40";
-        assertEquals("Sat May 10 00:00:00 UTC 2025", simpleParseDate.parseDate(date, Arrays.asList("MM/dd/yyyy", "dd.MM.yyyy", "yyyy-MM-dd")).toString());
+        assertEquals("Sat May 10 00:00:00 UTC 2025", SimpleParseDate.parseDate(date, Arrays.asList("MM/dd/yyyy", "dd.MM.yyyy", "yyyy-MM-dd"))
+            .toString());
     }
 
     @Test
-    public void whenInvalidDate_thenAssertThrows() {
-        SimpleDateTimeFormater simpleDateTimeFormater = new SimpleDateTimeFormater();
-        assertEquals(java.time.LocalDate.parse("2022-12-04"), simpleDateTimeFormater.parseDate("2022-12-04"));
-        assertThrows(DateTimeParseException.class, () -> simpleDateTimeFormater.parseDate("2022-13-04"));
+    void whenInvalidDate_thenAssertThrows() {
+        assertEquals(java.time.LocalDate.parse("2022-12-04"), SimpleDateTimeFormater.parseDate("2022-12-04"));
+        assertThrows(DateTimeParseException.class, () -> SimpleDateTimeFormater.parseDate("2022-13-04"));
     }
 
     @Test
-    public void whenDateIsCorrect_thenParseCorrect() {
-        SimpleDateUtils simpleDateUtils = new SimpleDateUtils();
-        assertNull(simpleDateUtils.parseDate("53/10/2014"));
-        assertEquals("Wed Sep 10 00:00:00 UTC 2014", simpleDateUtils.parseDate("10/09/2014").toString());
+    void whenDateIsCorrect_thenParseCorrect() {
+        assertNull(SimpleDateUtils.parseDate("53/10/2014"));
+        assertEquals("Wed Sep 10 00:00:00 UTC 2014", SimpleDateUtils.parseDate("10/09/2014")
+            .toString());
     }
 
     @Test
-    public void whenDateIsCorrect_thenResultCorrect() {
-        SimpleDateTimeFormat simpleDateTimeFormat = new SimpleDateTimeFormat();
-        assertNull(simpleDateTimeFormat.parseDate("53/10/2014"));
-        assertEquals(LocalDate.parse("2014-10-10"), simpleDateTimeFormat.parseDate("2014-10-10"));
+    void whenDateIsCorrect_thenResultCorrect() {
+        assertNull(SimpleDateTimeFormat.parseDate("53/10/2014"));
+        assertEquals(LocalDate.parse("2014-10-10"), SimpleDateTimeFormat.parseDate("2014-10-10"));
     }
 
 }

core-java-modules/core-java-8-datetime/pom.xml

@@ -56,7 +56,7 @@
     <properties>
         <maven.compiler.source>1.8</maven.compiler.source>
         <maven.compiler.target>1.8</maven.compiler.target>
-        <joda-time.version>2.10</joda-time.version>
+        <joda-time.version>2.12.5</joda-time.version>
     </properties>
 
 </project>

core-java-modules/core-java-8/src/main/java/com/baeldung/streamreduce/application/Application.java

@@ -1,62 +0,0 @@
-package com.baeldung.streamreduce.application;
-
-import com.baeldung.streamreduce.entities.User;
-import com.baeldung.streamreduce.utilities.NumberUtils;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-public class Application {
-
-    public static void main(String[] args) {
-        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
-        int result1 = numbers.stream().reduce(0, (a, b) -> a + b);
-        System.out.println(result1);
-        
-        int result2 = numbers.stream().reduce(0, Integer::sum);
-        System.out.println(result2);
-
-        List<String> letters = Arrays.asList("a", "b", "c", "d", "e");
-        String result3 = letters.stream().reduce("", (a, b) -> a + b);
-        System.out.println(result3);
-        
-        String result4 = letters.stream().reduce("", String::concat);
-        System.out.println(result4);
-
-        String result5 = letters.stream().reduce("", (a, b) -> a.toUpperCase() + b.toUpperCase());
-        System.out.println(result5);
-        
-        List<User> users = Arrays.asList(new User("John", 30), new User("Julie", 35));
-        int result6 = users.stream().reduce(0, (partialAgeResult, user) -> partialAgeResult + user.getAge(), Integer::sum);
-        System.out.println(result6);
-        
-        String result7 = letters.parallelStream().reduce("", String::concat);
-        System.out.println(result7);
-        
-        int result8 = users.parallelStream().reduce(0, (partialAgeResult, user) -> partialAgeResult + user.getAge(), Integer::sum);
-        System.out.println(result8);
-        
-        List<User> userList = new ArrayList<>();
-        for (int i = 0; i <= 1000000; i++) {
-            userList.add(new User("John" + i, i));
-        }
-        
-        long t1 = System.currentTimeMillis();
-        int result9 = userList.stream().reduce(0, (partialAgeResult, user) -> partialAgeResult + user.getAge(), Integer::sum);
-        long t2 = System.currentTimeMillis();
-        System.out.println(result9);
-        System.out.println("Sequential stream time: " + (t2 - t1) + "ms");
-        
-        long t3 = System.currentTimeMillis();
-        int result10 = userList.parallelStream().reduce(0, (partialAgeResult, user) -> partialAgeResult + user.getAge(), Integer::sum);
-        long t4 = System.currentTimeMillis();
-        System.out.println(result10);
-        System.out.println("Parallel stream time: " + (t4 - t3) + "ms");
-        
-        int result11 = NumberUtils.divideListElements(numbers, 1);
-        System.out.println(result11);
-        
-        int result12 = NumberUtils.divideListElementsWithExtractedTryCatchBlock(numbers, 0);
-        System.out.println(result12);
-    }    
-}

core-java-modules/core-java-8/src/main/java/com/baeldung/streamreduce/entities/Rating.java

@@ -1,39 +0,0 @@
-package com.baeldung.streamreduce.entities;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class Rating {
-
-    double points;
-    List<Review> reviews = new ArrayList<>();
-
-    public Rating() {}
-
-    public void add(Review review) {
-        reviews.add(review);
-        computeRating();
-    }
-
-    private double computeRating() {
-        double totalPoints = reviews.stream().map(Review::getPoints).reduce(0, Integer::sum);
-        this.points = totalPoints / reviews.size();
-        return this.points;
-    }
-
-    public static Rating average(Rating r1, Rating r2) {
-        Rating combined = new Rating();
-        combined.reviews = new ArrayList<>(r1.reviews);
-        combined.reviews.addAll(r2.reviews);
-        combined.computeRating();
-        return combined;
-    }
-
-    public double getPoints() {
-        return points;
-    }
-
-    public List<Review> getReviews() {
-        return reviews;
-    }
-}

core-java-modules/core-java-8/src/main/java/com/baeldung/streamreduce/entities/Review.java

@@ -1,28 +0,0 @@
-package com.baeldung.streamreduce.entities;
-
-public class Review {
-
-    int points;
-    String review;
-
-    public Review(int points, String review) {
-        this.points = points;
-        this.review = review;
-    }
-
-    public int getPoints() {
-        return points;
-    }
-
-    public void setPoints(int points) {
-        this.points = points;
-    }
-
-    public String getReview() {
-        return review;
-    }
-
-    public void setReview(String review) {
-        this.review = review;
-    }
-}

core-java-modules/core-java-8/src/main/java/com/baeldung/streamreduce/entities/User.java

@@ -1,30 +0,0 @@
-package com.baeldung.streamreduce.entities;
-
-public class User {
-
-    private final String name;
-    private final int age;
-    private final Rating rating = new Rating();
-
-    public User(String name, int age) {
-        this.name = name;
-        this.age = age;
-    }
-
-    public String getName() {
-        return name;
-    }
-
-    public int getAge() {
-        return age;
-    }
-
-    public Rating getRating() {
-        return rating;
-    }
-
-    @Override
-    public String toString() {
-        return "User{" + "name=" + name + ", age=" + age + '}';
-    }
-}

core-java-modules/core-java-8/src/main/java/com/baeldung/streamreduce/utilities/NumberUtils.java

@@ -1,52 +0,0 @@
-package com.baeldung.streamreduce.utilities;
-
-import java.util.List;
-import java.util.function.BiFunction;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-public abstract class NumberUtils {
-
-    private static final Logger LOGGER = Logger.getLogger(NumberUtils.class.getName());
-
-    public static int divideListElements(List<Integer> values, Integer divider) {
-        return values.stream()
-                .reduce(0, (a, b) -> {
-                    try {
-                        return a / divider + b / divider;
-                    } catch (ArithmeticException e) {
-                        LOGGER.log(Level.INFO, "Arithmetic Exception: Division by Zero");
-                    }
-                    return 0;
-                });
-    }
-    
-    public static int divideListElementsWithExtractedTryCatchBlock(List<Integer> values, int divider) {
-        return values.stream().reduce(0, (a, b) -> divide(a, divider) + divide(b, divider));
-    }
-    
-    public static int divideListElementsWithApplyFunctionMethod(List<Integer> values, int divider) {
-        BiFunction<Integer, Integer, Integer> division = (a, b) -> a / b;
-        return values.stream().reduce(0, (a, b) -> applyFunction(division, a, divider) + applyFunction(division, b, divider));
-    }
-    
-    private static int divide(int value, int factor) {
-        int result = 0;
-        try {
-            result = value / factor;
-        } catch (ArithmeticException e) {
-            LOGGER.log(Level.INFO, "Arithmetic Exception: Division by Zero");
-        }
-        return result;
-    }
-    
-    private static int applyFunction(BiFunction<Integer, Integer, Integer> function, int a, int b) {
-        try {
-            return function.apply(a, b);
-        }
-        catch(Exception e) {
-            LOGGER.log(Level.INFO, "Exception occurred!");
-        }
-        return 0;
-    }
-}

core-java-modules/core-java-collections-4/pom.xml

@@ -34,7 +34,6 @@
 
     <properties>
         <commons-lang.version>2.2</commons-lang.version>
-        <commons-lang3.version>3.12.0</commons-lang3.version>
     </properties>
 
 </project>