Merge branch 'eugenp:master' into danielmcnally285_return_first_non_null

2023-11-05 11:32:42 +00:00
parent a54e0ba8d2 0fc112e613
commit 9368968cea
152 changed files with 1808 additions and 1844 deletions
@@ -0,0 +1,113 @@
+package com.baeldung.rounddate;
+
+import java.time.DayOfWeek;
+import java.time.temporal.ChronoField;
+import java.time.temporal.TemporalAdjusters;
+import java.util.Calendar;
+import java.util.Date;
+import java.time.LocalDateTime;
+import java.time.ZonedDateTime;
+
+public class RoundDate {
+    public static Date getDate(int year, int month, int day, int hour, int minute) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.set(Calendar.YEAR, year);
+        calendar.set(Calendar.MONTH, month);
+        calendar.set(Calendar.DAY_OF_MONTH, day);
+        calendar.set(Calendar.HOUR_OF_DAY, hour);
+        calendar.set(Calendar.MINUTE, minute);
+        calendar.set(Calendar.SECOND, 0);
+        calendar.set(Calendar.MILLISECOND, 0);
+
+        return calendar.getTime();
+    }
+
+    public static Date roundToDay(Date date) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+        calendar.set(Calendar.HOUR_OF_DAY, 0);
+        calendar.set(Calendar.MINUTE, 0);
+        calendar.set(Calendar.SECOND, 0);
+        calendar.set(Calendar.MILLISECOND, 0);
+        return calendar.getTime();
+    }
+
+    public static Date roundToNearestUnit(Date date, int unit) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+
+        switch (unit) {
+            case Calendar.HOUR:
+                int minute = calendar.get(Calendar.MINUTE);
+                if (minute >= 0 && minute < 15) {
+                    calendar.set(Calendar.MINUTE, 0);
+                } else if (minute >= 15 && minute < 45) {
+                    calendar.set(Calendar.MINUTE, 30);
+                } else {
+                    calendar.set(Calendar.MINUTE, 0);
+                    calendar.add(Calendar.HOUR_OF_DAY, 1);
+                }
+                calendar.set(Calendar.SECOND, 0);
+                calendar.set(Calendar.MILLISECOND, 0);
+                break;
+
+            case Calendar.DAY_OF_MONTH:
+                int hour = calendar.get(Calendar.HOUR_OF_DAY);
+                if (hour >= 12) {
+                    calendar.add(Calendar.DAY_OF_MONTH, 1);
+                }
+                calendar.set(Calendar.HOUR_OF_DAY, 0);
+                calendar.set(Calendar.MINUTE, 0);
+                calendar.set(Calendar.SECOND, 0);
+                calendar.set(Calendar.MILLISECOND, 0);
+                break;
+
+            case Calendar.MONTH:
+                int day = calendar.get(Calendar.DAY_OF_MONTH);
+                if (day >= 15) {
+                    calendar.add(Calendar.MONTH, 1);
+                }
+                calendar.set(Calendar.DAY_OF_MONTH, 1);
+                calendar.set(Calendar.HOUR_OF_DAY, 0);
+                calendar.set(Calendar.MINUTE, 0);
+                calendar.set(Calendar.SECOND, 0);
+                calendar.set(Calendar.MILLISECOND, 0);
+                break;
+        }
+
+        return calendar.getTime();
+    }
+
+    public static LocalDateTime roundToStartOfMonthUsingLocalDateTime(LocalDateTime dateTime) {
+        return dateTime.withDayOfMonth(1).withHour(0).withMinute(0).withSecond(0).withNano(0);
+    }
+
+    public static LocalDateTime roundToEndOfWeekUsingLocalDateTime(LocalDateTime dateTime) {
+        return dateTime.with(TemporalAdjusters.next(DayOfWeek.SATURDAY))
+                .withHour(23)
+                .withMinute(59)
+                .withSecond(59)
+                .withNano(999);
+    }
+
+    public static ZonedDateTime roundToStartOfMonthUsingZonedDateTime(ZonedDateTime dateTime) {
+        return dateTime.withDayOfMonth(1)
+                .withHour(0)
+                .withMinute(0)
+                .withSecond(0)
+                .with(ChronoField.MILLI_OF_SECOND, 0)
+                .with(ChronoField.MICRO_OF_SECOND, 0)
+                .with(ChronoField.NANO_OF_SECOND, 0);
+    }
+
+    public static ZonedDateTime roundToEndOfWeekUsingZonedDateTime(ZonedDateTime dateTime) {
+        return dateTime.with(TemporalAdjusters.next(DayOfWeek.SATURDAY))
+                .withHour(23)
+                .withMinute(59)
+                .withSecond(59)
+                .with(ChronoField.MILLI_OF_SECOND, 999)
+                .with(ChronoField.MICRO_OF_SECOND, 999)
+                .with(ChronoField.NANO_OF_SECOND, 999);
+    }
+
+}
@@ -0,0 +1,63 @@
+package com.baeldung.rounddate;
+
+import org.junit.Test;
+
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.util.Calendar;
+import java.util.Date;
+
+import static org.junit.Assert.assertEquals;
+
+public class DateRoundingUnitTest {
+
+    @Test
+    public void givenDate_whenRoundToDay_thenBeginningOfDay() {
+        Date date = RoundDate.getDate(2023, Calendar.JANUARY, 27, 14, 30);
+        Date result = RoundDate.roundToDay(date);
+        assertEquals(RoundDate.getDate(2023, Calendar.JANUARY, 27, 0, 0), result);
+    }
+
+    @Test
+    public void givenDate_whenRoundToNearestUnit_thenNearestUnit() {
+        Date date = RoundDate.getDate(2023, Calendar.JANUARY, 27, 14, 12);
+        Date result = RoundDate.roundToNearestUnit(date, Calendar.DAY_OF_MONTH);
+        Date expected = RoundDate.getDate(2023, Calendar.JANUARY, 28, 0, 0);
+        assertEquals(expected, result);
+    }
+
+    @Test
+    public void givenLocalDateTime_whenRoundToStartOfMonth_thenStartOfMonth() {
+        LocalDateTime dateTime = LocalDateTime.of(2023, 1, 27, 14, 12);
+        LocalDateTime result = RoundDate.roundToStartOfMonthUsingLocalDateTime(dateTime);
+        LocalDateTime expected = LocalDateTime.of(2023, 1, 1, 0, 0, 0);
+        assertEquals(expected, result);
+    }
+
+
+    @Test
+    public void givenZonedDateTime_whenRoundToStartOfMonth_thenStartOfMonth() {
+        ZonedDateTime dateTime = ZonedDateTime.of(2023, 1, 27, 14, 12, 0, 0, ZoneId.systemDefault());
+        ZonedDateTime result = RoundDate.roundToStartOfMonthUsingZonedDateTime(dateTime);
+        ZonedDateTime expected = ZonedDateTime.of(2023, 1, 1, 0, 0, 0, 0, ZoneId.systemDefault());
+        assertEquals(expected, result);
+    }
+
+    @Test
+    public void givenLocalDateTime_whenRoundToEndOfWeek_thenEndOfWeek() {
+        LocalDateTime dateTime = LocalDateTime.of(2023, 1, 27, 14, 12);
+        LocalDateTime result = RoundDate.roundToEndOfWeekUsingLocalDateTime(dateTime);
+        LocalDateTime expected = LocalDateTime.of(2023, 1, 28, 23, 59, 59, 999);
+        assertEquals(expected, result);
+    }
+
+    @Test
+    public void givenZonedDateTime_whenRoundToEndOfWeek_thenEndOfWeek() {
+        ZonedDateTime dateTime = ZonedDateTime.of(2023, 1, 27, 14, 12, 0, 0, ZoneId.systemDefault());
+        ZonedDateTime result = RoundDate.roundToEndOfWeekUsingZonedDateTime(dateTime);
+        ZonedDateTime expected = ZonedDateTime.of(2023, 1, 28, 23, 59, 59, 999, ZoneId.systemDefault());
+        assertEquals(expected, result);
+    }
+
+}
@@ -0,0 +1,87 @@
+package com.baeldung.vectors;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Vector;
+
+import org.junit.Test;
+
+public class VectorOperationsUnitTest {
+
+    private static Vector<String> getVector() {
+        Vector<String> vector = new Vector<String>();
+        vector.add("Today");
+        vector.add("is");
+        vector.add("a");
+        vector.add("great");
+        vector.add("day!");
+
+        return vector;
+    }
+
+    @Test
+    public void givenAVector_whenAddElementsUsingAddMethod_thenElementsGetAddedAtEnd() {
+        Vector<String> vector = getVector();
+        vector.add("Hello");
+        assertEquals(6, vector.size());
+    }
+
+    @Test
+    public void givenAVector_whenUpdateElementAtIndex_thenElementAtIndexGetsUpdated() {
+        Vector<String> vector = getVector();
+        assertEquals(5, vector.size());
+        assertEquals("great", vector.get(3));
+        vector.set(3, "good");
+        assertEquals("good", vector.get(3));
+    }
+
+    @Test
+    public void givenAVector_whenRemoveAnElement_thenElementGetsRemovedFromTheVector() {
+        Vector<String> vector = getVector();
+        assertEquals(5, vector.size());
+
+        // remove a specific element
+        vector.remove("a");
+        assertEquals(4, vector.size());
+
+        // remove at specific index
+        vector.remove(2);
+        assertEquals("day!", vector.get(2));
+        assertEquals(3, vector.size());
+
+        assertEquals(false, vector.remove("SomethingThatDoesn'tExist"));
+    }
+
+    @Test(expected = ArrayIndexOutOfBoundsException.class)
+    public void givenAVector_whenIndexIsBeyondRange_thenRemoveMethodThrowsArrayIndexOutOfBoundsException() {
+        Vector<String> vector = getVector();
+        assertEquals(5, vector.size());
+        vector.remove(10);
+    }
+
+    @Test
+    public void givenAVector_whenGetElementWithinARange_thenGetMethodGetsAnElementFromTheVector() {
+        Vector<String> vector = getVector();
+        String fourthElement = vector.get(3);
+        assertEquals("great", fourthElement);
+    }
+
+    @Test(expected = ArrayIndexOutOfBoundsException.class)
+    public void givenAVector_whenGetElementBeyondARange_thenGetMethodThrowsArrayIndexOutOfBoundsException() {
+        Vector<String> vector = getVector();
+        assertEquals(5, vector.size());
+        vector.get(10);
+    }
+
+    @Test
+    public void givenAVector_whenAddElementFromACollection_thenAllElementsGetAdeddToTheVector() {
+        Vector<String> vector = getVector();
+        assertEquals(5, vector.size());
+        ArrayList<String> words = new ArrayList<>(Arrays.asList("Baeldung", "is", "cool!"));
+        vector.addAll(words);
+        assertEquals(8, vector.size());
+        assertEquals("cool!", vector.get(7));
+    }
+}
@@ -79,5 +79,18 @@
            <version>1.5</version>
        </dependency>
    </dependencies>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <configuration>
+                    <argLine>
+                        --add-opens java.base/java.util=ALL-UNNAMED
+                    </argLine>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>

 </project>
@@ -0,0 +1,85 @@
+package com.baeldung.map.linkedhashmapfirstandlastentry;
+
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Field;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map.Entry;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+public class GetFirstAndLastEntryFromLinkedHashMapUnitTest {
+    private static final LinkedHashMap<String, String> THE_MAP = new LinkedHashMap<>();
+
+    static {
+        THE_MAP.put("key one", "a1 b1 c1");
+        THE_MAP.put("key two", "a2 b2 c2");
+        THE_MAP.put("key three", "a3 b3 c3");
+        THE_MAP.put("key four", "a4 b4 c4");
+    }
+
+    @Test
+    void whenIteratingEntrySet_thenGetExpectedResult() {
+        Entry<String, String> firstEntry = THE_MAP.entrySet().iterator().next();
+        assertEquals("key one", firstEntry.getKey());
+        assertEquals("a1 b1 c1", firstEntry.getValue());
+
+        Entry<String, String> lastEntry = null;
+        Iterator<Entry<String, String>> it = THE_MAP.entrySet().iterator();
+        while (it.hasNext()) {
+            lastEntry = it.next();
+        }
+
+        assertNotNull(lastEntry);
+        assertEquals("key four", lastEntry.getKey());
+        assertEquals("a4 b4 c4", lastEntry.getValue());
+
+    }
+
+    @Test
+    void whenConvertingEntriesToArray_thenGetExpectedResult() {
+
+        Entry<String, String>[] theArray = new Entry[THE_MAP.size()];
+        THE_MAP.entrySet().toArray(theArray);
+
+        Entry<String, String> firstEntry = theArray[0];
+        assertEquals("key one", firstEntry.getKey());
+        assertEquals("a1 b1 c1", firstEntry.getValue());
+
+        Entry<String, String> lastEntry = theArray[THE_MAP.size() - 1];
+        assertEquals("key four", lastEntry.getKey());
+        assertEquals("a4 b4 c4", lastEntry.getValue());
+    }
+
+    @Test
+    void whenUsingStreamAPI_thenGetExpectedResult() {
+        Entry<String, String> firstEntry = THE_MAP.entrySet().stream().findFirst().get();
+        assertEquals("key one", firstEntry.getKey());
+        assertEquals("a1 b1 c1", firstEntry.getValue());
+
+        Entry<String, String> lastEntry = THE_MAP.entrySet().stream().skip(THE_MAP.size() - 1).findFirst().get();
+
+        assertNotNull(lastEntry);
+        assertEquals("key four", lastEntry.getKey());
+        assertEquals("a4 b4 c4", lastEntry.getValue());
+    }
+
+    @Test
+    void whenUsingReflection_thenGetExpectedResult() throws NoSuchFieldException, IllegalAccessException {
+        Field head = THE_MAP.getClass().getDeclaredField("head");
+        head.setAccessible(true);
+        Entry<String, String> firstEntry = (Entry<String, String>) head.get(THE_MAP);
+        assertEquals("key one", firstEntry.getKey());
+        assertEquals("a1 b1 c1", firstEntry.getValue());
+
+        Field tail = THE_MAP.getClass().getDeclaredField("tail");
+        tail.setAccessible(true);
+        Entry<String, String> lastEntry = (Entry<String, String>) tail.get(THE_MAP);
+        assertEquals("key four", lastEntry.getKey());
+        assertEquals("a4 b4 c4", lastEntry.getValue());
+    }
+
+
+}
@@ -0,0 +1,23 @@
+package com.baeldung.generictype;
+
+/**
+ * @param <T> The type of the first value in the {@code Pair<T,S>}.
+ * @param <S> The type of the second value in the {@code Pair<T,S>}.
+ */
+
+public class Pair<T, S> {
+    public T first;
+    public S second;
+
+    /**
+     * Constructs a new Pair object with the specified values.
+     *
+     * @param a The first value.
+     * @param b The second value.
+     */
+
+    public Pair(T a, S b) {
+        first = a;
+        second = b;
+    }
+}
@@ -56,7 +56,7 @@
        <source.version>11</source.version>
        <target.version>11</target.version>
        <json.version>20200518</json.version>
-        <opencsv.version>4.1</opencsv.version>
+        <opencsv.version>5.8</opencsv.version>
    </properties>

 </project>
@@ -0,0 +1,72 @@
+package com.baeldung.jndi;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.springframework.jdbc.datasource.DriverManagerDataSource;
+import org.springframework.jndi.JndiTemplate;
+import org.springframework.mock.jndi.SimpleNamingContextBuilder;
+
+import javax.naming.*;
+import javax.sql.DataSource;
+
+import java.util.Enumeration;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class JndiNamingUnitTest {
+
+    private static InitialContext context;
+    private static DriverManagerDataSource dataSource;
+
+    @BeforeAll
+    static void setUp() throws Exception {
+        SimpleNamingContextBuilder builder = new SimpleNamingContextBuilder();
+        dataSource = new DriverManagerDataSource("jdbc:h2:mem:mydb");
+        builder.activate();
+
+        JndiTemplate jndiTemplate = new JndiTemplate();
+        context = (InitialContext) jndiTemplate.getContext();
+        
+        dataSource.setDriverClassName("org.h2.Driver");
+        context.bind("java:comp/env/jdbc/datasource", dataSource);
+    }
+
+    @Test
+    void givenACompositeName_whenAddingAnElement_thenNameIsAdded() throws Exception {
+        Name objectName = new CompositeName("java:comp/env/jdbc");
+
+        Enumeration<String> items = objectName.getAll();
+        while(items.hasMoreElements()) {
+            System.out.println(items.nextElement());
+        }
+
+        objectName.add("New Name");
+
+        assertEquals("env", objectName.get(1));
+        assertEquals("New Name", objectName.get(objectName.size() - 1));
+    }
+
+    @Test
+    void givenContext_whenLookupByName_thenReturnsValidObject() throws Exception {
+        DataSource ds = (DataSource) context.lookup("java:comp/env/jdbc/datasource");
+
+        assertNotNull(ds);
+        assertNotNull(ds.getConnection());
+    }
+    
+    @Test
+    void givenSubContext_whenLookupByName_thenReturnsValidObject() throws Exception {
+        Context subContext = (Context) context.lookup("java:comp/env");
+        DataSource ds = (DataSource) subContext.lookup("jdbc/datasource");
+
+        assertNotNull(ds);
+        assertNotNull(ds.getConnection());
+    }
+    
+    @AfterAll
+    static void tearDown() throws Exception {
+       context.close();
+    }
+
+}
@@ -0,0 +1,122 @@
+package com.baeldung.genericnumberscomparator;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.BiFunction;
+import java.util.function.BiPredicate;
+import java.util.function.Function;
+
+import org.junit.jupiter.api.Test;
+
+class GenericNumbersComparatorUnitTest {
+
+    public int compareDouble(Number num1, Number num2) {
+        return Double.compare(num1.doubleValue(), num2.doubleValue());
+    }
+
+    @Test
+    void givenNumbers_whenUseCompareDouble_thenWillExecuteComparison() {
+        assertEquals(0, compareDouble(5, 5.0));
+    }
+
+    public int compareTo(Integer int1, Integer int2) {
+        return int1.compareTo(int2);
+    }
+
+    @Test
+    void givenNumbers_whenUseCompareTo_thenWillExecuteComparison() {
+        assertEquals(-1, compareTo(5, 7));
+    }
+
+    Map<Class<? extends Number>, BiFunction<Number, Number, Integer>> comparisonMap = new HashMap<>();
+
+    public int compareUsingMap(Number num1, Number num2) {
+        comparisonMap.put(Integer.class, (a, b) -> ((Integer) num1).compareTo((Integer) num2));
+
+        return comparisonMap.get(num1.getClass())
+            .apply(num1, num2);
+    }
+
+    @Test
+    void givenNumbers_whenUseCompareUsingMap_thenWillExecuteComparison() {
+        assertEquals(-1, compareUsingMap(5, 7));
+    }
+
+    public interface NumberComparator {
+        int compare(Number num1, Number num2);
+    }
+
+    @Test
+    void givenNumbers_whenUseProxy_thenWillExecuteComparison() {
+        NumberComparator proxy = (NumberComparator) Proxy.newProxyInstance(NumberComparator.class.getClassLoader(), new Class[] { NumberComparator.class },
+            (p, method, args) -> Double.compare(((Number) args[0]).doubleValue(), ((Number) args[1]).doubleValue()));
+        assertEquals(0, proxy.compare(5, 5.0));
+    }
+
+    public int compareUsingReflection(Number num1, Number num2) throws Exception {
+        Method method = num1.getClass()
+            .getMethod("compareTo", num1.getClass());
+        return (int) method.invoke(num1, num2);
+    }
+
+    @Test
+    void givenNumbers_whenUseCompareUsingReflection_thenWillExecuteComparison() throws Exception {
+        assertEquals(-1, compareUsingReflection(5, 7));
+    }
+
+    interface NumberComparatorFactory {
+        Comparator<Number> getComparator();
+    }
+
+    class IntegerComparatorFactory implements NumberComparatorFactory {
+        @Override
+        public Comparator<Number> getComparator() {
+            return (num1, num2) -> ((Integer) num1).compareTo((Integer) num2);
+        }
+    }
+
+    @Test
+    void givenNumbers_whenUseComparatorFactory_thenWillExecuteComparison() {
+        NumberComparatorFactory factory = new IntegerComparatorFactory();
+        Comparator<Number> comparator = factory.getComparator();
+        assertEquals(-1, comparator.compare(5, 7));
+    }
+
+    Function<Number, Double> toDouble = Number::doubleValue;
+    BiPredicate<Number, Number> isEqual = (num1, num2) -> toDouble.apply(num1)
+        .equals(toDouble.apply(num2));
+
+    @Test
+    void givenNumbers_whenUseIsEqual_thenWillExecuteComparison() {
+        assertEquals(true, isEqual.test(5, 5.0));
+    }
+
+    private Number someNumber = 5;
+    private Number anotherNumber = 5.0;
+
+    Optional<Number> optNum1 = Optional.ofNullable(someNumber);
+    Optional<Number> optNum2 = Optional.ofNullable(anotherNumber);
+    int comparisonResult = optNum1.flatMap(n1 -> optNum2.map(n2 -> Double.compare(n1.doubleValue(), n2.doubleValue())))
+        .orElse(0);
+
+    @Test
+    void givenNumbers_whenUseComparisonResult_thenWillExecuteComparison() {
+        assertEquals(0, comparisonResult);
+    }
+
+    private boolean someCondition = true;
+    Function<Number, ?> dynamicFunction = someCondition ? Number::doubleValue : Number::intValue;
+    Comparator<Number> dynamicComparator = (num1, num2) -> ((Comparable) dynamicFunction.apply(num1)).compareTo(dynamicFunction.apply(num2));
+
+    @Test
+    void givenNumbers_whenUseDynamicComparator_thenWillExecuteComparison() {
+        assertEquals(0, dynamicComparator.compare(5, 5.0));
+    }
+
+}
@@ -0,0 +1,6 @@
+package com.baeldung.optionalsasparameterrecords;
+
+import java.util.Optional;
+
+public record Product(String name, double price, Optional<String> description) {
+}
@@ -0,0 +1,17 @@
+package com.baeldung.optionalsasparameterrecords;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.Optional;
+
+public class OptionalAsRecordParameterUnitTest {
+
+    @Test
+    public void givenRecordCreationWithOptional_thenCreateItProperly() {
+        var emptyDescriptionProduct = new Product("television", 1699.99, Optional.empty());
+        Assertions.assertEquals("television", emptyDescriptionProduct.name());
+        Assertions.assertEquals(1699.99, emptyDescriptionProduct.price());
+        Assertions.assertNull(emptyDescriptionProduct.description().orElse(null));
+    }
+}
@@ -0,0 +1,100 @@
+package com.baeldung.streamtomapandmultimap;
+
+import com.google.common.collect.LinkedHashMultimap;
+import org.junit.Test;
+
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.assertEquals;
+
+public class StreamToMapAndMultiMapUnitTest {
+    @Test
+    public void givenStringStream_whenConvertingToMapWithMerge_thenExpectedMapIsGenerated() {
+        Stream<String> stringStream = Stream.of("one", "two", "three", "two");
+
+        Map<String, String> mergedMap = stringStream.collect(
+                Collectors.toMap(s -> s, s -> s, (s1, s2) -> s1 + ", " + s2)
+        );
+
+        // Define the expected map
+        Map<String, String> expectedMap = Map.of(
+                "one", "one",
+                "two", "two, two",
+                "three", "three"
+        );
+
+        assertEquals(expectedMap, mergedMap);
+    }
+
+    @Test
+    public void givenStringStream_whenConvertingToMultimap_thenExpectedMultimapIsGenerated() {
+        Stream<String> stringStream = Stream.of("one", "two", "three", "two");
+
+        LinkedHashMultimap<Object, Object> multimap = LinkedHashMultimap.create();
+
+        stringStream.collect(Collectors.groupingBy(
+                s -> s,
+                Collectors.mapping(s -> s, Collectors.toList())
+        )).forEach((key, value) -> multimap.putAll(key, value));
+
+        LinkedHashMultimap<Object, Object> expectedMultimap = LinkedHashMultimap.create();
+        expectedMultimap.put("one", "one");
+        expectedMultimap.put("two", "two");
+        expectedMultimap.put("three", "three");
+
+        assertEquals(expectedMultimap, multimap);
+    }
+
+    @Test
+    public void givenStringStream_whenConvertingToMultimapWithStreamReduce_thenExpectedMultimapIsGenerated() {
+        Stream<String> stringStream = Stream.of("one", "two", "three", "two");
+
+        Map<String, List<String>> multimap = stringStream.reduce(
+                new HashMap<>(),
+                (map, element) -> {
+                    map.computeIfAbsent(element, k -> new ArrayList<>()).add(element);
+                    return map;
+                },
+                (map1, map2) -> {
+                    map2.forEach((key, value) -> map1.merge(key, value, (list1, list2) -> {
+                        list1.addAll(list2);
+                        return list1;
+                    }));
+                    return map1;
+                }
+        );
+
+        Map<String, List<String>> expectedMultimap = new HashMap<>();
+        expectedMultimap.put("one", Collections.singletonList("one"));
+        expectedMultimap.put("two", Arrays.asList("two", "two"));
+        expectedMultimap.put("three", Collections.singletonList("three"));
+
+        assertEquals(expectedMultimap, multimap);
+    }
+
+    @Test
+    public void givenStringStream_whenConvertingToMapWithStreamReduce_thenExpectedMapIsGenerated() {
+        Stream<String> stringStream = Stream.of("one", "two", "three", "two");
+
+        Map<String, String> resultMap = stringStream.reduce(
+                new HashMap<>(),
+                (map, element) -> {
+                    map.put(element, element);
+                    return map;
+                },
+                (map1, map2) -> {
+                    map1.putAll(map2);
+                    return map1;
+                }
+        );
+
+        Map<String, String> expectedMap = new HashMap<>();
+        expectedMap.put("one", "one");
+        expectedMap.put("two", "two");
+        expectedMap.put("three", "three");
+
+        assertEquals(expectedMap, resultMap);
+    }
+}
@@ -1,7 +1,11 @@
 package com.baeldung.streams;

-import org.junit.Before;
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;

 import java.nio.file.Path;
 import java.nio.file.Paths;
@@ -11,14 +15,12 @@ import java.util.List;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;

-import static org.junit.Assert.*;
+class Java8StreamsUnitTest {

-public class Java8StreamsUnitTest {
+    private static List<String> list;

-    private List<String> list;
-
-    @Before
-    public void init() {
+    @BeforeAll
+    public static void init() {
        list = new ArrayList<>();
        list.add("One");
        list.add("OneAndOnly");
@@ -42,60 +44,73 @@ public class Java8StreamsUnitTest {
        Stream<String> streamOf = Stream.of("a", "b", "c");
        assertEquals(streamOf.count(), 3);

-        long count = list.stream().distinct().count();
+        long count = list.stream()
+            .distinct()
+            .count();
        assertEquals(count, 9);
    }

    @Test
-    public void checkStreamCount_whenOperationFilter_thanCorrect() {
-        Stream<String> streamFilter = list.stream().filter(element -> element.isEmpty());
+    void checkStreamCount_whenOperationFilter_thanCorrect() {
+        Stream<String> streamFilter = list.stream()
+            .filter(element -> element.isEmpty());
        assertEquals(streamFilter.count(), 2);
    }

    @Test
-    public void checkStreamCount_whenOperationMap_thanCorrect() {
+    void checkStreamCount_whenOperationMap_thanCorrect() {
        List<String> uris = new ArrayList<>();
        uris.add("C:\\My.txt");
-        Stream<Path> streamMap = uris.stream().map(uri -> Paths.get(uri));
+        Stream<Path> streamMap = uris.stream()
+            .map(uri -> Paths.get(uri));
        assertEquals(streamMap.count(), 1);

        List<Detail> details = new ArrayList<>();
        details.add(new Detail());
        details.add(new Detail());
-        Stream<String> streamFlatMap = details.stream().flatMap(detail -> detail.getParts().stream());
+        Stream<String> streamFlatMap = details.stream()
+            .flatMap(detail -> detail.getParts()
+                .stream());
        assertEquals(streamFlatMap.count(), 4);
    }

    @Test
-    public void checkStreamCount_whenOperationMatch_thenCorrect() {
-        boolean isValid = list.stream().anyMatch(element -> element.contains("h"));
-        boolean isValidOne = list.stream().allMatch(element -> element.contains("h"));
-        boolean isValidTwo = list.stream().noneMatch(element -> element.contains("h"));
+    void checkStreamCount_whenOperationMatch_thenCorrect() {
+        boolean isValid = list.stream()
+            .anyMatch(element -> element.contains("h"));
+        boolean isValidOne = list.stream()
+            .allMatch(element -> element.contains("h"));
+        boolean isValidTwo = list.stream()
+            .noneMatch(element -> element.contains("h"));
        assertTrue(isValid);
        assertFalse(isValidOne);
        assertFalse(isValidTwo);
    }

    @Test
-    public void checkStreamReducedValue_whenOperationReduce_thenCorrect() {
+    void checkStreamReducedValue_whenOperationReduce_thenCorrect() {
        List<Integer> integers = new ArrayList<>();
        integers.add(1);
        integers.add(1);
        integers.add(1);
-        Integer reduced = integers.stream().reduce(23, (a, b) -> a + b);
+        Integer reduced = integers.stream()
+            .reduce(23, (a, b) -> a + b);
        assertTrue(reduced == 26);
    }

    @Test
-    public void checkStreamContains_whenOperationCollect_thenCorrect() {
-        List<String> resultList = list.stream().map(element -> element.toUpperCase()).collect(Collectors.toList());
+    void checkStreamContains_whenOperationCollect_thenCorrect() {
+        List<String> resultList = list.stream()
+            .map(element -> element.toUpperCase())
+            .collect(Collectors.toList());
        assertEquals(resultList.size(), list.size());
        assertTrue(resultList.contains(""));
    }

    @Test
    public void checkParallelStream_whenDoWork() {
-        list.parallelStream().forEach(element -> doWork(element));
+        list.parallelStream()
+            .forEach(element -> doWork(element));
    }

    private void doWork(String string) {
@@ -58,7 +58,7 @@
    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
-        <opencsv.version>4.1</opencsv.version>
+        <opencsv.version>5.8</opencsv.version>
        <spring-core.version>5.3.13</spring-core.version>
        <apache-commons-lang3.version>3.12.0</apache-commons-lang3.version>
        <apache-commons-text.version>1.10.0</apache-commons-text.version>
@@ -12,6 +12,7 @@ import com.opencsv.CSVParser;
 import com.opencsv.CSVParserBuilder;
 import com.opencsv.CSVReader;
 import com.opencsv.CSVReaderBuilder;
+import com.opencsv.exceptions.CsvException;

 public class SplitCommaSeparatedString {

@@ -50,7 +51,7 @@ public class SplitCommaSeparatedString {
        return splitter.splitToList(input);
    }

-    public static List<String[]> splitMultiLineWithOpenCSV(String input) throws IOException {
+    public static List<String[]> splitMultiLineWithOpenCSV(String input) throws IOException, CsvException {
        CSVParser parser = new CSVParserBuilder().withSeparator(',')
            .build();

@@ -14,6 +14,8 @@ import java.util.List;

 import org.junit.Test;

+import com.opencsv.exceptions.CsvException;
+
 public class SplitCommaSeparatedStringUnitTest {
    
    @Test
@@ -27,7 +29,7 @@ public class SplitCommaSeparatedStringUnitTest {
    }
    
    @Test
-    public void givenMultiLineInput_whenParsing_shouldIgnoreCommasInsideDoubleQuotes() throws IOException {
+    public void givenMultiLineInput_whenParsing_shouldIgnoreCommasInsideDoubleQuotes() throws IOException, CsvException {
        String input = "baeldung,tutorial,splitting,text,\"ignoring this comma,\"" + System.lineSeparator()
        + "splitting,a,regular,line,no double quotes";

@@ -0,0 +1,34 @@
+package com.baeldung.mutablestrings;
+
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.CharacterCodingException;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CharsetEncoder;
+import java.nio.charset.CoderResult;
+
+public class CharsetUsageExample {
+
+    public ByteBuffer encodeString(String inputString) {
+        Charset charset = Charset.forName("UTF-8");
+        CharsetEncoder encoder = charset.newEncoder();
+
+        CharBuffer charBuffer = CharBuffer.wrap(inputString);
+        ByteBuffer byteBuffer = ByteBuffer.allocate(50);
+
+        encoder.encode(charBuffer, byteBuffer, true); // true indicates the end of input
+        byteBuffer.flip();
+        return byteBuffer;
+    }
+
+    public String decodeString(ByteBuffer byteBuffer) {
+        Charset charset = Charset.forName("UTF-8");
+        CharsetDecoder decoder = charset.newDecoder();
+        CharBuffer decodedCharBuffer = CharBuffer.allocate(50);
+        decoder.decode(byteBuffer, decodedCharBuffer, true);
+        decodedCharBuffer.flip();
+
+        return decodedCharBuffer.toString();
+    }
+}
@@ -0,0 +1,65 @@
+package com.baeldung.mutablestrings;
+
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CharsetEncoder;
+import java.nio.charset.CoderResult;
+import java.util.concurrent.atomic.AtomicReference;
+
+public class MutableStringUsingCharset {
+
+    private final AtomicReference<CharBuffer> cbRef = new AtomicReference<>();
+    private final Charset myCharset = new Charset("mycharset", null) {
+        @Override
+        public boolean contains(Charset cs) {
+            return false;
+        }
+
+        @Override
+        public CharsetDecoder newDecoder() {
+            return new CharsetDecoder(this, 1.0f, 1.0f) {
+                @Override
+                protected CoderResult decodeLoop(ByteBuffer in, CharBuffer out) {
+                    cbRef.set(out);
+                    while (in.remaining() > 0) {
+                        out.append((char) in.get());
+                    }
+                    return CoderResult.UNDERFLOW;
+                }
+            };
+        }
+
+        @Override
+        public CharsetEncoder newEncoder() {
+            CharsetEncoder cd = new CharsetEncoder(this, 1.0f, 1.0f) {
+                @Override
+                protected CoderResult encodeLoop(CharBuffer in, ByteBuffer out) {
+                    while (in.hasRemaining()) {
+                        if (!out.hasRemaining()) {
+                            return CoderResult.OVERFLOW;
+                        }
+                        char currentChar = in.get();
+                        if (currentChar > 127) {
+                            return CoderResult.unmappableForLength(1);
+                        }
+                        out.put((byte) currentChar);
+                    }
+                    return CoderResult.UNDERFLOW;
+                }
+            };
+            return cd;
+        }
+    };
+
+    public String createModifiableString(String s) {
+        return new String(s.getBytes(), myCharset);
+    }
+
+    public void modifyString() {
+        CharBuffer cb = cbRef.get();
+        cb.position(0);
+        cb.put("xyz");
+    }
+}
@@ -0,0 +1,24 @@
+package com.baeldung.mutablestrings;
+
+import java.lang.reflect.Field;
+import java.nio.charset.Charset;
+
+import com.google.errorprone.annotations.DoNotCall;
+
+public class MutableStrings {
+
+    /**
+     * This involves using Reflection to change String fields and it is not encouraged to use this in programs.
+     * @throws NoSuchFieldException
+     * @throws IllegalAccessException
+     */
+    @DoNotCall
+    public void mutableUsingReflection() throws NoSuchFieldException, IllegalAccessException {
+        String myString = "Hello World";
+        String otherString = new String("Hello World");
+        Field f = String.class.getDeclaredField("value");
+        f.setAccessible(true);
+        f.set(myString, "Hi World".toCharArray());
+        System.out.println(otherString);
+    }
+}
@@ -0,0 +1,17 @@
+package com.baeldung.mutablestring;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import com.baeldung.mutablestrings.CharsetUsageExample;
+
+public class CharsetUsageUnitTest {
+
+    @Test
+    public void givenCharset_whenStringIsEncodedAndDecoded_thenGivesCorrectResult() {
+        CharsetUsageExample ch = new CharsetUsageExample();
+        String inputString = "hello दुनिया";
+        String result = ch.decodeString(ch.encodeString(inputString));
+        Assertions.assertEquals(inputString, result);
+    }
+}
@@ -0,0 +1,24 @@
+package com.baeldung.mutablestring;
+
+import org.junit.Assert;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+
+import com.baeldung.mutablestrings.MutableStringUsingCharset;
+
+public class MutableStringUsingCharsetUnitTest {
+    @Test
+    @Disabled
+    /**
+     * This test is disabled as it works well for Java 8 and below
+     */
+    public void givenCustomCharSet_whenStringUpdated_StringGetsMutated() throws Exception {
+        MutableStringUsingCharset ms = new MutableStringUsingCharset();
+        String s = ms.createModifiableString("Hello");
+        Assert.assertEquals("Hello", s);
+        ms.modifyString();
+        Assert.assertEquals("something", s);
+    }
+
+}
+
@@ -14,3 +14,4 @@ Listed here there are only those articles that does not fit into other core-java
 - [Java String Interview Questions and Answers](https://www.baeldung.com/java-string-interview-questions)
 - [Java Multi-line String](https://www.baeldung.com/java-multiline-string)
 - [Reuse StringBuilder for Efficiency](https://www.baeldung.com/java-reuse-stringbuilder-for-efficiency)
+- [How to Iterate Over the String Characters in Java](https://www.baeldung.com/java-iterate-string-characters)
@@ -0,0 +1,42 @@
+package com.baeldung.stringIterator;
+
+import java.text.*; 
+import java.util.*;
+
+public class StringIterator {
+
+    public static String javaCharArray(String str){
+        StringBuilder result = new StringBuilder();
+        for (char c : str.toCharArray()) { 
+            result.append(c);
+        }
+        return result.toString();
+    }
+
+    public static String javaforLoop(String str) {
+        StringBuilder result = new StringBuilder();
+        for (int i = 0; i < str.length(); i++) {
+            char c = str.charAt(i);
+            result.append(c);
+        }
+        return result.toString();
+    }
+
+    public static String java8forEach(String str){
+        StringBuilder result = new StringBuilder();
+        str.chars().forEach(name -> {
+            result.append((char) name);
+        });
+        return result.toString();
+    }
+
+    public static String javaCharacterIterator(String str){
+        StringBuilder result = new StringBuilder();
+        CharacterIterator it = new StringCharacterIterator(str);  
+        while (it.current() != CharacterIterator.DONE) { 
+            result.append(it.current()); 
+            it.next(); 
+        }
+        return result.toString();
+    }
+}
@@ -0,0 +1,39 @@
+package com.baeldung.stringIterator;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class StringIteratorTest {
+  
+    @Test
+    public void whenUseCharArrayMethod_thenIterate() {
+        String input = "Hello, Baeldung!";
+        String expectedOutput = "Hello, Baeldung!";
+        String result = StringIterator.javaCharArray(input);
+        assertEquals(expectedOutput, result);
+    }
+  
+    @Test
+    public void whenUseJavaForLoop_thenIterate() {
+        String input = "Hello, Baeldung!";
+        String expectedOutput = "Hello, Baeldung!";
+        String result = StringIterator.javaForLoop(input);
+        assertEquals(expectedOutput, result);
+    }
+  
+    @Test
+    public void whenUseForEachMethod_thenIterate() {
+        String input = "Hello, Baeldung!";
+        String expectedOutput = "Hello, Baeldung!";
+        String result = StringIterator.java8ForEach(input);
+        assertEquals(expectedOutput, result);
+    }
+  
+    @Test
+    public void whenUseCharacterIterator_thenIterate() {
+        String input = "Hello, Baeldung!";
+        String expectedOutput = "Hello, Baeldung!";
+        String result = StringIterator.javaCharacterIterator(input);
+        assertEquals(expectedOutput, result);
+    }
+}
@@ -7,9 +7,9 @@
    <name>java-native</name>

    <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-modules</artifactId>
-        <version>1.0.0-SNAPSHOT</version>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
    </parent>

    <dependencies>
--- a/Show More
+++ b/Show More