[BAEL-13506] - Split or move core-java-8 module (#7790)

core-java-modules/core-java-streams/src/main/java/com/baeldung/forEach/ReverseList.java

@@ -0,0 +1,84 @@
+package com.baeldung.forEach;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Consumer;
+
+class ReverseList extends ArrayList<String> {
+
+    List<String> list = Arrays.asList("A", "B", "C", "D");
+
+    Consumer<String> removeElement = s -> {
+        System.out.println(s + " " + list.size());
+        if (s != null && s.equals("A")) {
+            list.remove("D");
+        }
+    };
+
+    @Override
+    public Iterator<String> iterator() {
+
+        final int startIndex = this.size() - 1;
+        final List<String> list = this;
+        return new Iterator<String>() {
+
+            int currentIndex = startIndex;
+
+            @Override
+            public boolean hasNext() {
+                return currentIndex >= 0;
+            }
+
+            @Override
+            public String next() {
+                String next = list.get(currentIndex);
+                currentIndex--;
+                return next;
+            }
+
+            @Override
+            public void remove() {
+                throw new UnsupportedOperationException();
+            }
+        };
+    }
+
+    public void forEach(Consumer<? super String> action) {
+        for (String s : this) {
+            action.accept(s);
+        }
+    }
+
+    public void iterateParallel() {
+        list.forEach(System.out::print);
+        System.out.print(" ");
+        list.parallelStream().forEach(System.out::print);
+    }
+
+    public void iterateReverse() {
+        List<String> myList = new ReverseList();
+        myList.addAll(list);
+        myList.forEach(System.out::print);
+        System.out.print(" ");
+        myList.stream().forEach(System.out::print);
+    }
+
+    public void removeInCollectionForEach() {
+        list.forEach(removeElement);
+    }
+
+    public void removeInStreamForEach() {
+        list.stream().forEach(removeElement);
+    }
+
+    public static void main(String[] argv) {
+
+        ReverseList collectionForEach = new ReverseList();
+        collectionForEach.iterateParallel();
+        collectionForEach.iterateReverse();
+        collectionForEach.removeInCollectionForEach();
+        collectionForEach.removeInStreamForEach();
+    }
+}

core-java-modules/core-java-streams/src/main/resources/logback.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>

core-java-modules/core-java-streams/src/test/java/com/baeldung/collectors/Java8CollectorsUnitTest.java

@@ -0,0 +1,231 @@
+package com.baeldung.collectors;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.DoubleSummaryStatistics;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.BiConsumer;
+import java.util.function.BinaryOperator;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collector;
+
+import static com.google.common.collect.Sets.newHashSet;
+import static java.util.stream.Collectors.averagingDouble;
+import static java.util.stream.Collectors.collectingAndThen;
+import static java.util.stream.Collectors.counting;
+import static java.util.stream.Collectors.groupingBy;
+import static java.util.stream.Collectors.joining;
+import static java.util.stream.Collectors.maxBy;
+import static java.util.stream.Collectors.partitioningBy;
+import static java.util.stream.Collectors.summarizingDouble;
+import static java.util.stream.Collectors.summingDouble;
+import static java.util.stream.Collectors.toCollection;
+import static java.util.stream.Collectors.toList;
+import static java.util.stream.Collectors.toMap;
+import static java.util.stream.Collectors.toSet;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class Java8CollectorsUnitTest {
+
+    private final List<String> givenList = Arrays.asList("a", "bb", "ccc", "dd");
+    private final List<String> listWithDuplicates = Arrays.asList("a", "bb", "c", "d", "bb");
+
+    @Test
+    public void whenCollectingToList_shouldCollectToList() throws Exception {
+        final List<String> result = givenList.stream().collect(toList());
+
+        assertThat(result).containsAll(givenList);
+    }
+
+    @Test
+    public void whenCollectingToSet_shouldCollectToSet() throws Exception {
+        final Set<String> result = givenList.stream().collect(toSet());
+
+        assertThat(result).containsAll(givenList);
+    }
+
+    @Test
+    public void givenContainsDuplicateElements_whenCollectingToSet_shouldAddDuplicateElementsOnlyOnce() throws Exception {
+        final Set<String> result = listWithDuplicates.stream().collect(toSet());
+
+        assertThat(result).hasSize(4);
+    }
+
+    @Test
+    public void whenCollectingToCollection_shouldCollectToCollection() throws Exception {
+        final List<String> result = givenList.stream().collect(toCollection(LinkedList::new));
+
+        assertThat(result).containsAll(givenList).isInstanceOf(LinkedList.class);
+    }
+
+    @Test
+    public void whenCollectingToImmutableCollection_shouldThrowException() throws Exception {
+        assertThatThrownBy(() -> {
+            givenList.stream().collect(toCollection(ImmutableList::of));
+        }).isInstanceOf(UnsupportedOperationException.class);
+
+    }
+
+    @Test
+    public void whenCollectingToMap_shouldCollectToMap() throws Exception {
+        final Map<String, Integer> result = givenList.stream().collect(toMap(Function.identity(), String::length));
+
+        assertThat(result).containsEntry("a", 1).containsEntry("bb", 2).containsEntry("ccc", 3).containsEntry("dd", 2);
+    }
+
+    @Test
+    public void whenCollectingToMapwWithDuplicates_shouldCollectToMapMergingTheIdenticalItems() throws Exception {
+        final Map<String, Integer> result = listWithDuplicates.stream().collect(
+          toMap(
+            Function.identity(),
+            String::length,
+            (item, identicalItem) -> item
+          )
+        );
+
+        assertThat(result).containsEntry("a", 1).containsEntry("bb", 2).containsEntry("c", 1).containsEntry("d", 1);
+    }
+
+    @Test
+    public void givenContainsDuplicateElements_whenCollectingToMap_shouldThrowException() throws Exception {
+        assertThatThrownBy(() -> {
+            listWithDuplicates.stream().collect(toMap(Function.identity(), String::length));
+        }).isInstanceOf(IllegalStateException.class);
+    }
+
+    @Test
+    public void whenCollectingAndThen_shouldCollect() throws Exception {
+        final List<String> result = givenList.stream().collect(collectingAndThen(toList(), ImmutableList::copyOf));
+
+        assertThat(result).containsAll(givenList).isInstanceOf(ImmutableList.class);
+    }
+
+    @Test
+    public void whenJoining_shouldJoin() throws Exception {
+        final String result = givenList.stream().collect(joining());
+
+        assertThat(result).isEqualTo("abbcccdd");
+    }
+
+    @Test
+    public void whenJoiningWithSeparator_shouldJoinWithSeparator() throws Exception {
+        final String result = givenList.stream().collect(joining(" "));
+
+        assertThat(result).isEqualTo("a bb ccc dd");
+    }
+
+    @Test
+    public void whenJoiningWithSeparatorAndPrefixAndPostfix_shouldJoinWithSeparatorPrePost() throws Exception {
+        final String result = givenList.stream().collect(joining(" ", "PRE-", "-POST"));
+
+        assertThat(result).isEqualTo("PRE-a bb ccc dd-POST");
+    }
+
+    @Test
+    public void whenPartitioningBy_shouldPartition() throws Exception {
+        final Map<Boolean, List<String>> result = givenList.stream().collect(partitioningBy(s -> s.length() > 2));
+
+        assertThat(result).containsKeys(true, false).satisfies(booleanListMap -> {
+            assertThat(booleanListMap.get(true)).contains("ccc");
+
+            assertThat(booleanListMap.get(false)).contains("a", "bb", "dd");
+        });
+    }
+
+    @Test
+    public void whenCounting_shouldCount() throws Exception {
+        final Long result = givenList.stream().collect(counting());
+
+        assertThat(result).isEqualTo(4);
+    }
+
+    @Test
+    public void whenSummarizing_shouldSummarize() throws Exception {
+        final DoubleSummaryStatistics result = givenList.stream().collect(summarizingDouble(String::length));
+
+        assertThat(result.getAverage()).isEqualTo(2);
+        assertThat(result.getCount()).isEqualTo(4);
+        assertThat(result.getMax()).isEqualTo(3);
+        assertThat(result.getMin()).isEqualTo(1);
+        assertThat(result.getSum()).isEqualTo(8);
+    }
+
+    @Test
+    public void whenAveraging_shouldAverage() throws Exception {
+        final Double result = givenList.stream().collect(averagingDouble(String::length));
+
+        assertThat(result).isEqualTo(2);
+    }
+
+    @Test
+    public void whenSumming_shouldSum() throws Exception {
+        final Double result = givenList.stream().filter(i -> true).collect(summingDouble(String::length));
+
+        assertThat(result).isEqualTo(8);
+    }
+
+    @Test
+    public void whenMaxingBy_shouldMaxBy() throws Exception {
+        final Optional<String> result = givenList.stream().collect(maxBy(Comparator.naturalOrder()));
+
+        assertThat(result).isPresent().hasValue("dd");
+    }
+
+    @Test
+    public void whenGroupingBy_shouldGroupBy() throws Exception {
+        final Map<Integer, Set<String>> result = givenList.stream().collect(groupingBy(String::length, toSet()));
+
+        assertThat(result).containsEntry(1, newHashSet("a")).containsEntry(2, newHashSet("bb", "dd")).containsEntry(3, newHashSet("ccc"));
+    }
+
+    @Test
+    public void whenCreatingCustomCollector_shouldCollect() throws Exception {
+        final ImmutableSet<String> result = givenList.stream().collect(toImmutableSet());
+
+        assertThat(result).isInstanceOf(ImmutableSet.class).contains("a", "bb", "ccc", "dd");
+
+    }
+
+    private static <T> ImmutableSetCollector<T> toImmutableSet() {
+        return new ImmutableSetCollector<>();
+    }
+
+    private static class ImmutableSetCollector<T> implements Collector<T, ImmutableSet.Builder<T>, ImmutableSet<T>> {
+
+        @Override
+        public Supplier<ImmutableSet.Builder<T>> supplier() {
+            return ImmutableSet::builder;
+        }
+
+        @Override
+        public BiConsumer<ImmutableSet.Builder<T>, T> accumulator() {
+            return ImmutableSet.Builder::add;
+        }
+
+        @Override
+        public BinaryOperator<ImmutableSet.Builder<T>> combiner() {
+            return (left, right) -> left.addAll(right.build());
+        }
+
+        @Override
+        public Function<ImmutableSet.Builder<T>, ImmutableSet<T>> finisher() {
+            return ImmutableSet.Builder::build;
+        }
+
+        @Override
+        public Set<Characteristics> characteristics() {
+            return Sets.immutableEnumSet(Characteristics.UNORDERED);
+        }
+    }
+}

core-java-modules/core-java-streams/src/test/java/com/baeldung/stream/conditional/StreamForEachIfElseUnitTest.java

@@ -0,0 +1,41 @@
+package com.baeldung.stream.conditional;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class StreamForEachIfElseUnitTest {
+
+    @Test
+    public final void givenIntegerStream_whenCheckingIntegerParityWithIfElse_thenEnsureCorrectParity() {
+        List<Integer> ints = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+
+        ints.stream()
+            .forEach(i -> {
+                if (i.intValue() % 2 == 0) {
+                    Assert.assertTrue(i.intValue() + " is not even", i.intValue() % 2 == 0);
+                } else {
+                    Assert.assertTrue(i.intValue() + " is not odd", i.intValue() % 2 != 0);
+                }
+            });
+
+    }
+
+    @Test
+    public final void givenIntegerStream_whenCheckingIntegerParityWithStreamFilter_thenEnsureCorrectParity() {
+        List<Integer> ints = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+
+        Stream<Integer> evenIntegers = ints.stream()
+            .filter(i -> i.intValue() % 2 == 0);
+        Stream<Integer> oddIntegers = ints.stream()
+            .filter(i -> i.intValue() % 2 != 0);
+
+        evenIntegers.forEach(i -> Assert.assertTrue(i.intValue() + " is not even", i.intValue() % 2 == 0));
+        oddIntegers.forEach(i -> Assert.assertTrue(i.intValue() + " is not odd", i.intValue() % 2 != 0));
+
+    }
+
+}

core-java-modules/core-java-streams/src/test/resources/.gitignore

@@ -0,0 +1,13 @@
+*.class
+
+#folders#
+/target
+/neoDb*
+/data
+/src/main/webapp/WEB-INF/classes
+*/META-INF/*
+
+# Packaged files #
+*.jar
+*.war
+*.ear