Submit all code for code-java-string branch

2022-07-15 13:10:35 -04:00
parent c6df8af1e0
commit 27af9e2f8c
83 changed files with 3202 additions and 0 deletions
@@ -0,0 +1,16 @@
+## Core Java streams
+
+This module contains articles about the Stream API in Java.
+
+### Relevant Articles: 
+- [The Difference Between map() and flatMap()](https://www.baeldung.com/java-difference-map-and-flatmap)
+- [How to Use if/else Logic in Java 8 Streams](https://www.baeldung.com/java-8-streams-if-else-logic)
+- [The Difference Between Collection.stream().forEach() and Collection.forEach()](https://www.baeldung.com/java-collection-stream-foreach)
+- [Primitive Type Streams in Java 8](https://www.baeldung.com/java-8-primitive-streams)
+- [Debugging Java 8 Streams with IntelliJ](https://www.baeldung.com/intellij-debugging-java-streams)
+- [Add BigDecimals using the Stream API](https://www.baeldung.com/java-stream-add-bigdecimals)
+- [Should We Close a Java Stream?](https://www.baeldung.com/java-stream-close)
+- [Returning Stream vs. Collection](https://www.baeldung.com/java-return-stream-collection)
+- [Convert a Java Enumeration Into a Stream](https://www.baeldung.com/java-enumeration-to-stream)
+- [When to Use a Parallel Stream in Java](https://www.baeldung.com/java-when-to-use-parallel-stream)
+- More articles: [[<-- prev>]](/../core-java-streams-2)
@@ -0,0 +1,73 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>core-java-streams-3</artifactId>
+    <version>0.1.0-SNAPSHOT</version>
+    <name>core-java-streams-3</name>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${commons-lang3.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>${lombok.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-core</artifactId>
+            <version>${jmh-core.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-generator-annprocess</artifactId>
+            <version>${jmh-generator.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <finalName>core-java-streams-3</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                    <annotationProcessorPaths>
+                        <path>
+                            <groupId>org.openjdk.jmh</groupId>
+                            <artifactId>jmh-generator-annprocess</artifactId>
+                            <version>${jmh-generator.version}</version>
+                        </path>
+                    </annotationProcessorPaths>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <lombok.version>1.18.20</lombok.version>
+    </properties>
+
+</project>
@@ -0,0 +1,30 @@
+package com.baeldung.streams.closure;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.stream.Stream;
+
+/**
+ * Contains a couple of simple stream API usages.
+ */
+public class StreamClosureSnippets {
+
+    public static void main(String[] args) throws IOException {
+        // Collection based streams shouldn't be closed
+        Arrays.asList("Red", "Blue", "Green")
+          .stream()
+          .filter(c -> c.length() > 4)
+          .map(String::toUpperCase)
+          .forEach(System.out::print);
+
+        String[] colors = {"Red", "Blue", "Green"};
+        Arrays.stream(colors).map(String::toUpperCase).forEach(System.out::println);
+
+        // IO-Based Streams Should be Closed via Try with Resources
+        try (Stream<String> lines = Files.lines(Paths.get("/path/tp/file"))) {
+            // lines will be closed after exiting the try block
+        }
+    }
+}
@@ -0,0 +1,30 @@
+package com.baeldung.streams.conversion;
+
+import java.util.Enumeration;
+import java.util.Spliterators.AbstractSpliterator;
+import java.util.function.Consumer;
+
+public class EnumerationSpliterator<T> extends AbstractSpliterator<T> {
+
+    private final Enumeration<T> enumeration;
+
+    public EnumerationSpliterator(long est, int additionalCharacteristics, Enumeration<T> enumeration) {
+        super(est, additionalCharacteristics);
+        this.enumeration = enumeration;
+    }
+
+    @Override
+    public boolean tryAdvance(Consumer<? super T> action) {
+        if (enumeration.hasMoreElements()) {
+            action.accept(enumeration.nextElement());
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void forEachRemaining(Consumer<? super T> action) {
+        while (enumeration.hasMoreElements())
+            action.accept(enumeration.nextElement());
+    }
+}
@@ -0,0 +1,16 @@
+package com.baeldung.streams.conversion;
+
+import java.util.Enumeration;
+import java.util.Spliterator;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+public class EnumerationStreamConversion {
+
+    public static <T> Stream<T> convert(Enumeration<T> enumeration) {
+        EnumerationSpliterator<T> spliterator = new EnumerationSpliterator<T>(Long.MAX_VALUE, Spliterator.ORDERED, enumeration);
+        Stream<T> stream = StreamSupport.stream(spliterator, false);
+
+        return stream;
+    }
+}
@@ -0,0 +1,19 @@
+package com.baeldung.streams.debug.entity;
+
+public class Customer {
+    private final String name;
+    private final int age;
+
+    public Customer(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getAge() {
+        return age;
+    }
+}
@@ -0,0 +1,84 @@
+package com.baeldung.streams.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();
+    }
+}
@@ -0,0 +1,9 @@
+package com.baeldung.streams.parallel;
+
+public class BenchmarkRunner {
+
+    public static void main(String[] args) throws Exception {
+        org.openjdk.jmh.Main.main(args);
+    }
+
+}
@@ -0,0 +1,54 @@
+package com.baeldung.streams.parallel;
+
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.IntStream;
+
+public class DifferentSourceSplitting {
+
+    private static final List<Integer> arrayListOfNumbers = new ArrayList<>();
+    private static final List<Integer> linkedListOfNumbers = new LinkedList<>();
+
+    static {
+        IntStream.rangeClosed(1, 1_000_000).forEach(i -> {
+            arrayListOfNumbers.add(i);
+            linkedListOfNumbers.add(i);
+        });
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public static void differentSourceArrayListSequential() {
+        arrayListOfNumbers.stream().reduce(0, Integer::sum);
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public static void differentSourceArrayListParallel() {
+        arrayListOfNumbers.parallelStream().reduce(0, Integer::sum);
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public static void differentSourceLinkedListSequential() {
+        linkedListOfNumbers.stream().reduce(0, Integer::sum);
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public static void differentSourceLinkedListParallel() {
+        linkedListOfNumbers.parallelStream().reduce(0, Integer::sum);
+    }
+
+}
@@ -0,0 +1,52 @@
+package com.baeldung.streams.parallel;
+
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+
+import java.util.Arrays;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.IntStream;
+
+public class MemoryLocalityCosts {
+
+    private static final int[] intArray = new int[1_000_000];
+    private static final Integer[] integerArray = new Integer[1_000_000];
+
+    static {
+        IntStream.rangeClosed(1, 1_000_000).forEach(i -> {
+            intArray[i-1] = i;
+            integerArray[i-1] = i;
+        });
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public static void localityIntArraySequential() {
+        Arrays.stream(intArray).reduce(0, Integer::sum);
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public static void localityIntArrayParallel() {
+        Arrays.stream(intArray).parallel().reduce(0, Integer::sum);
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public static void localityIntegerArraySequential() {
+        Arrays.stream(integerArray).reduce(0, Integer::sum);
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public static void localityIntegerArrayParallel() {
+        Arrays.stream(integerArray).parallel().reduce(0, Integer::sum);
+    }
+
+}
@@ -0,0 +1,52 @@
+package com.baeldung.streams.parallel;
+
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class MergingCosts {
+
+    private static final List<Integer> arrayListOfNumbers = new ArrayList<>();
+
+    static {
+        IntStream.rangeClosed(1, 1_000_000).forEach(i -> {
+            arrayListOfNumbers.add(i);
+        });
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public static void mergingCostsSumSequential() {
+        arrayListOfNumbers.stream().reduce(0, Integer::sum);
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public static void mergingCostsSumParallel() {
+        arrayListOfNumbers.stream().parallel().reduce(0, Integer::sum);
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public static void mergingCostsGroupingSequential() {
+        arrayListOfNumbers.stream().collect(Collectors.toSet());
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public static void mergingCostsGroupingParallel() {
+        arrayListOfNumbers.stream().parallel().collect(Collectors.toSet());
+    }
+
+}
@@ -0,0 +1,15 @@
+package com.baeldung.streams.parallel;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class ParallelStream {
+
+    public static void main(String[] args) {
+        List<Integer> listOfNumbers = Arrays.asList(1, 2, 3, 4);
+        listOfNumbers.parallelStream().forEach(number ->
+          System.out.println(number + " " + Thread.currentThread().getName())
+        );
+    }
+
+}
@@ -0,0 +1,15 @@
+package com.baeldung.streams.parallel;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class SequentialStream {
+
+    public static void main(String[] args) {
+        List<Integer> listOfNumbers = Arrays.asList(1, 2, 3, 4);
+        listOfNumbers.stream().forEach(number ->
+          System.out.println(number + " " + Thread.currentThread().getName())
+        );
+    }
+
+}
@@ -0,0 +1,27 @@
+package com.baeldung.streams.parallel;
+
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+
+import java.util.concurrent.TimeUnit;
+import java.util.stream.IntStream;
+
+public class SplittingCosts {
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public static void sourceSplittingIntStreamSequential() {
+        IntStream.rangeClosed(1, 100).reduce(0, Integer::sum);
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public static void sourceSplittingIntStreamParallel() {
+        IntStream.rangeClosed(1, 100).parallel().reduce(0, Integer::sum);
+    }
+
+}
@@ -0,0 +1,23 @@
+package com.baeldung.streams.primitivestreams;
+
+import java.util.Arrays;
+import java.util.stream.IntStream;
+
+class PrimitiveStreams {
+
+    int min(int[] integers) {
+        return Arrays.stream(integers).min().getAsInt();
+    }
+
+    int max(int... integers) {
+        return IntStream.of(integers).max().getAsInt();
+    }
+
+    int sum(int... integers) {
+        return IntStream.of(integers).sum();
+    }
+
+    double avg(int... integers) {
+        return IntStream.of(integers).average().getAsDouble();
+    }
+}
@@ -0,0 +1,95 @@
+package com.baeldung.streams.streamvscollection;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class StreamVsCollectionExample {
+
+    static ArrayList<String> userNameSource = new ArrayList<>();
+
+    static {
+        userNameSource.add("john");
+        userNameSource.add("smith");
+        userNameSource.add("tom");
+        userNameSource.add("rob");
+        userNameSource.add("charlie");
+        userNameSource.add("alfred"); 
+    }
+
+    public static Stream<String> userNames() {
+        return userNameSource.stream();
+    }
+
+    public static List<String> userNameList() {
+        return userNames().collect(Collectors.toList());
+    }
+
+    public static Set<String> userNameSet() {
+        return userNames().collect(Collectors.toSet());
+    }
+
+    public static Map<String, String> userNameMap() {
+        return userNames().collect(Collectors.toMap(u1 -> u1.toString(), u1 -> u1.toString()));
+    }
+
+    public static Stream<String> filterUserNames() {
+        return userNames().filter(i -> i.length() >= 4);
+    }
+
+    public static Stream<String> sortUserNames() {
+        return userNames().sorted();
+    }
+
+    public static Stream<String> limitUserNames() {
+        return userNames().limit(3);
+    }
+
+    public static Stream<String> sortFilterLimitUserNames() {
+        return filterUserNames().sorted().limit(3);
+    }
+
+    public static void printStream(Stream<String> stream) {
+        stream.forEach(System.out::println);
+    }
+
+    public static void modifyList() {
+        userNameSource.remove(2);
+    }
+
+    public static Map<String, String> modifyMap() {
+        Map<String, String> userNameMap = userNameMap();
+        userNameMap.put("bob", "bob");
+        userNameMap.remove("alfred");
+
+        return userNameMap;
+    }
+
+    public static void tryStreamTraversal() {
+        Stream<String> userNameStream = userNames();
+        userNameStream.forEach(System.out::println);
+        
+        try {
+            userNameStream.forEach(System.out::println);
+        } catch(IllegalStateException e) {
+            System.out.println("stream has already been operated upon or closed");
+        }
+    }
+    
+    public static void main(String[] args) {
+        System.out.println(userNameMap());
+        System.out.println(modifyMap());      
+        tryStreamTraversal();
+        
+        Set<String> set = userNames().collect(Collectors.toCollection(TreeSet::new));
+        set.forEach(val -> System.out.println(val));  
+        
+    }
+    
+    
+}
@@ -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>
@@ -0,0 +1,42 @@
+package com.baeldung.streams.bigdecimals;
+
+import static org.junit.Assert.assertEquals;
+
+import java.math.BigDecimal;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+import org.junit.Test;
+
+public class AddNumbersUnitTest {
+
+    @Test
+    public void givenIntStream_whenSum_thenResultIsCorrect() {
+        IntStream intNumbers = IntStream.range(0, 3);
+        assertEquals(3, intNumbers.sum());
+    }
+
+    @Test
+    public void givenCollectionOfDouble_whenUsingMapToDoubleToSum_thenResultIsCorrect() {
+        List<Double> doubleNumbers = Arrays.asList(23.48, 52.26, 13.5);
+        double result = doubleNumbers.stream()
+            .mapToDouble(Double::doubleValue)
+            .sum();
+        assertEquals(89.24, result, .1);
+    }
+
+    public void givenStreamOfIntegers_whenUsingReduceToSum_thenResultIsCorrect() {
+        Stream<Integer> intNumbers = Stream.of(0, 1, 2);
+        int result = intNumbers.reduce(0, Integer::sum);
+        assertEquals(106, result);
+    }
+
+    public void givenStreamOfBigDecimals_whenUsingReduceToSum_thenResultIsCorrect() {
+        Stream<BigDecimal> bigDecimalNumber = Stream.of(BigDecimal.ZERO, BigDecimal.ONE, BigDecimal.TEN);
+        BigDecimal result = bigDecimalNumber.reduce(BigDecimal.ZERO, BigDecimal::add);
+        assertEquals(11, result);
+    }
+
+}
@@ -0,0 +1,41 @@
+package com.baeldung.streams.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));
+
+    }
+
+}
@@ -0,0 +1,35 @@
+package com.baeldung.streams.conversion;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.collection.IsIterableContainingInOrder.contains;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Vector;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.junit.Assert;
+import org.junit.jupiter.api.Test;
+
+public class EnumerationStreamConversionUnitTest {
+
+    @Test
+    public void givenEnumeration_whenConvertedToStream_thenNotNull() {
+        Vector<Integer> input = new Vector<>(Arrays.asList(1, 2, 3, 4, 5));
+
+        Stream<Integer> resultingStream = EnumerationStreamConversion.convert(input.elements());
+
+        Assert.assertNotNull(resultingStream);
+    }
+
+    @Test
+    public void whenConvertedToList_thenCorrect() {
+        Vector<Integer> input = new Vector<>(Arrays.asList(1, 2, 3, 4, 5));
+
+        Stream<Integer> stream = EnumerationStreamConversion.convert(input.elements());
+        List<Integer> list = stream.filter(e -> e >= 3)
+            .collect(Collectors.toList());
+        assertThat(list, contains(3, 4, 5));
+    }
+}
@@ -0,0 +1,18 @@
+package com.baeldung.streams.debug;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.stream.IntStream;
+
+import org.junit.Test;
+
+public class Example1 {
+    @Test
+    public void whenDebugging_thenInformationIsShown() {
+        int[] listOutputSorted = IntStream.of(-3, 10, -4, 1, 3)
+            .sorted()
+            .toArray();
+
+        assertThat(listOutputSorted).isSorted();
+    }
+}
@@ -0,0 +1,36 @@
+package com.baeldung.streams.debug;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import org.junit.Test;
+
+import com.baeldung.streams.debug.entity.Customer;
+
+public class Example2 {
+    @Test
+    public void whenDebugging_thenInformationIsShown() {
+        List<Optional<Customer>> customers = Arrays.asList(
+            Optional.of(new Customer("John P.", 15)),
+            Optional.of(new Customer("Sarah M.", 78)),
+            Optional.empty(),
+            Optional.of(new Customer("Mary T.", 20)),
+            Optional.empty(),
+            Optional.of(new Customer("Florian G.", 89)),
+            Optional.empty()
+        );
+
+        long numberOf65PlusCustomers = customers.stream()
+            .flatMap(c -> c.map(Stream::of)
+              .orElseGet(Stream::empty))
+            .mapToInt(Customer::getAge)
+            .filter(c -> c > 65)
+            .count();
+
+        assertThat(numberOf65PlusCustomers).isEqualTo(2);
+    }
+}
@@ -0,0 +1,46 @@
+package com.baeldung.streams.parallel;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ForkJoinPool;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class ForkJoinUnitTest {
+
+    @Test
+    void givenSequentialStreamOfNumbers_whenReducingSumWithIdentityFive_thenResultIsCorrect() {
+        List<Integer> listOfNumbers = Arrays.asList(1, 2, 3, 4);
+        int sum = listOfNumbers.stream().reduce(5, Integer::sum);
+        assertThat(sum).isEqualTo(15);
+    }
+
+    @Test
+    void givenParallelStreamOfNumbers_whenReducingSumWithIdentityFive_thenResultIsNotCorrect() {
+        List<Integer> listOfNumbers = Arrays.asList(1, 2, 3, 4);
+        int sum = listOfNumbers.parallelStream().reduce(5, Integer::sum);
+        assertThat(sum).isNotEqualTo(15);
+    }
+
+    @Test
+    void givenParallelStreamOfNumbers_whenReducingSumWithIdentityZero_thenResultIsCorrect() {
+        List<Integer> listOfNumbers = Arrays.asList(1, 2, 3, 4);
+        int sum = listOfNumbers.parallelStream().reduce(0, Integer::sum) + 5;
+        assertThat(sum).isEqualTo(15);
+    }
+
+    @Test
+    public void givenParallelStreamOfNumbers_whenUsingCustomThreadPool_thenResultIsCorrect()
+      throws InterruptedException, ExecutionException {
+        List<Integer> listOfNumbers = Arrays.asList(1, 2, 3, 4);
+        ForkJoinPool customThreadPool = new ForkJoinPool(4);
+        int sum = customThreadPool.submit(
+          () -> listOfNumbers.parallelStream().reduce(0, Integer::sum)).get();
+        customThreadPool.shutdown();
+        assertThat(sum).isEqualTo(10);
+    }
+
+}
@@ -0,0 +1,93 @@
+package com.baeldung.streams.primitivestreams;
+
+import org.junit.Test;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class PrimitiveStreamsUnitTest {
+
+    private PrimitiveStreams streams = new PrimitiveStreams();
+
+    @Test
+    public void givenAnArrayOfIntegersWhenMinIsCalledThenCorrectMinIsReturned() {
+        int[] integers = new int[] { 20, 98, 12, 7, 35 };
+        int min = streams.min(integers); // returns 7
+
+        assertEquals(7, min);
+    }
+
+    @Test
+    public void givenAnArrayOfIntegersWhenMaxIsCalledThenCorrectMaxIsReturned() {
+        int max = streams.max(20, 98, 12, 7, 35);
+
+        assertEquals(98, max);
+    }
+
+    @Test
+    public void givenAnArrayOfIntegersWhenSumIsCalledThenCorrectSumIsReturned() {
+        int sum = streams.sum(20, 98, 12, 7, 35);
+
+        assertEquals(172, sum);
+    }
+
+    @Test
+    public void givenAnArrayOfIntegersWhenAvgIsCalledThenCorrectAvgIsReturned() {
+        double avg = streams.avg(20, 98, 12, 7, 35);
+
+        assertTrue(34.4 == avg);
+    }
+
+    @Test
+    public void givenARangeOfIntegersWhenIntStreamSumIsCalledThenCorrectSumIsReturned() {
+        int sum = IntStream.range(1, 10).sum();
+
+        assertEquals(45, sum);
+    }
+
+    @Test
+    public void givenARangeClosedOfIntegersWhenIntStreamSumIsCalledThenCorrectSumIsReturned() {
+        int sum = IntStream.rangeClosed(1, 10).sum();
+
+        assertEquals(55, sum);
+    }
+
+    @Test
+    public void givenARangeWhenForEachIsCalledThenTheIndicesWillBePrinted() {
+        IntStream.rangeClosed(1, 5).parallel().forEach(System.out::println);
+    }
+
+    @Test
+    public void givenAnArrayWhenSumIsCalledThenTheCorrectSumIsReturned() {
+
+        int sum = Stream.of(33, 45).mapToInt(i -> i).sum();
+
+        assertEquals(78, sum);
+    }
+
+    @Test
+    public void givenAnIntStreamThenGetTheEvenIntegers() {
+        List<Integer> evenInts = IntStream.rangeClosed(1, 10).filter(i -> i % 2 == 0).boxed().collect(Collectors.toList());
+
+        List<Integer> expected = IntStream.of(2, 4, 6, 8, 10).boxed().collect(Collectors.toList());
+
+        assertEquals(expected, evenInts);
+    }
+
+    class Person {
+        private int age;
+
+        Person(int age) {
+            this.age = age;
+        }
+
+        int getAge() {
+            return age;
+        }
+    }
+}