Java 8 STREAMS

Ümit ÜNAL - n11.com

Java 8 STREAMS

What is a Stream?

Streams have no storage.
The design of streams is based on internal iteration.
Streams are designed to support functional programming.
Streams support lazy operations.
Streams can be ordered or unordered.
Streams cannot be reused.

Java 8 STREAMS

Internal vs. External Iteration

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = 0;
for (int n : numbers) {
        if (n % 2 == 1) {
                int square = n * n;
                sum = sum + square;
        }
}

int sum = numbers.stream()
                 .filter(n -> n % 2 == 1)
                 .map(n -> n * n)
                 .reduce(0, Integer::sum);

Java 8 STREAMS

Stream Operations

Intermediate operations
Terminal operations

A stream supports two types of operations:

Java 8 STREAMS

Stream Operations

Java 8 STREAMS

Stream Operations

Step by step Stream

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
                 .filter(n -> n % 2 == 1)
                 .map(n -> n * n)
                 .reduce(0, Integer::sum);

Java 8 STREAMS

Stream Operations

Step by step Stream

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
                 .filter(n -> n % 2 == 1)
                 .map(n -> n * n)
                 .reduce(0, Integer::sum);

Java 8 STREAMS

Stream Operations

Step by step Stream

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
                 .filter(n -> n % 2 == 1)
                 .map(n -> n * n)
                 .reduce(0, Integer::sum);

Java 8 STREAMS

Stream Operations

Step by step Stream

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
                 .filter(n -> n % 2 == 1)
                 .map(n -> n * n)
                 .reduce(0, Integer::sum);

Java 8 STREAMS

Stream Operations

Step by step Stream

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
                 .filter(n -> n % 2 == 1)
                 .map(n -> n * n)
                 .reduce(0, Integer::sum);

Java 8 STREAMS

Architecture of the Streams API

Java 8 STREAMS

Creating Streams

Streams from Values

<T> Stream<T> of(T t)
<T> Stream<T> of(T...values)


// Creates a stream with one string elements
Stream<String> stream = Stream.of("Hello");

// Creates a stream with four strings
Stream<String> stream = Stream.of("Ken", "Jeff", "Chris", "Ellen");


// Compute the sum of the squares of all odd integers in the list
int sum = Stream.of(1, 2, 3, 4, 5)
                .filter(n -> n % 2 == 1)
                .map(n -> n * n)
                .reduce(0, Integer::sum);

System.out.println("Sum = " + sum);
// Result 
Sum = 35

Java 8 STREAMS

Creating Streams

Streams from Values

String[] names  = {"Ken", "Jeff", "Chris", "Ellen"};

// Creates a stream of four strings in the names array
Stream<String> stream = Stream.of(names);

Java 8 STREAMS

Creating Streams

Streams from Functions

Stream.iterate(1L, n -> n + 2).limit(5)
      .forEach(System.out::println);

// Result: 
1
3
5
7
9
////////////////////////////////////
Stream.generate(Math::random).limit(5)
      .forEach(System.out::println);
// Result:

0.05958352209327644
0.8122226657626394
0.5073323815997652
0.9327951597282766
0.4314430923877808

Java 8 STREAMS

Creating Streams

Streams from Arrays

// Creates a stream from an int array with elements 1, 2, and 3
IntStream numbers = Arrays.stream(new int[]{1, 2, 3});

// Creates a stream from a String array with elements "Ken", and "Jeff"
Stream<String> names = Arrays.stream(new String[] {"Ken", "Jeff"});

Java 8 STREAMS

Creating Streams

Streams from Collections

// Create and populate a set of strings
Set<String> names = new HashSet<>();
names.add("Ken");
names.add("jeff");

// Create a sequential stream from the set
Stream<String> sequentialStream = names.stream();

// Create a parallel stream from the set
Stream<String> parallelStream = names.parallelStream();

Java 8 STREAMS

Creating Streams

Streams from Other Sources

String str = "5 apples and 25 oranges";
str.chars()
   .filter(n -> !Character.isDigit((char)n) && !Character.isWhitespace((char)n))
   .forEach(n -> System.out.print((char)n));

// Result :
applesandoranges

String str = "Ken,Jeff,Lee";
Pattern.compile(",")
       .splitAsStream(str)
       .forEach(System.out::println);

// Result :
Ken
Jeff
Lee

Java 8 STREAMS

Applying Operations on Streams

Common Stream Operations

Intermediate

Distinct
filter
flatMap
limit
map
peek
skip
sorted

Terminal

allMatch
anyMatch
findAny
findFirst
noneMatch
forEach
reduce

Java 8 STREAMS

Applying Operations on Streams

Debugging a Stream Pipeline

int sum = Stream.of(1, 2, 3, 4, 5)
                .peek(e -> System.out.println("Taking integer: " + e))
                .filter(n -> n % 2 == 1)
                .peek(e -> System.out.println("Filtered integer: " + e))
                .map(n -> n * n)
                .peek(e -> System.out.println("Mapped integer: " + e))
                .reduce(0, Integer::sum);
System.out.println("Sum = " + sum);
//Result:
Taking integer: 1
Filtered integer: 1
Mapped integer: 1
Taking integer: 2
Taking integer: 3
Filtered integer: 3
Mapped integer: 9
Taking integer: 4
Taking integer: 5
Filtered integer: 5
Mapped integer: 25
Sum = 35

Java 8 STREAMS

Applying Operations on Streams

Applying the ForEach Operation

void forEach(Consumer<? super T> action)
void forEachOrdered(Consumer<? super T> action)

Person.persons()
      .stream()
      .filter(Person::isFemale)
      .forEach(System.out::println);

//Result:
(3, Donna, FEMALE, 1962-07-29, 8700.00)
(5, Laynie, FEMALE, 2012-12-13, 0.00)

Java 8 STREAMS

Applying Operations on Streams

Applying the ForEach Operation

// Get the list of persons
List<Person> persons = Person.persons();

// Print the list
System.out.println("Before increasing the income: " + persons);

// Increase the income of females by 10%
persons.stream()
       .filter(Person::isFemale)
       .forEach(p -> p.setIncome(p.getIncome() * 1.10));

// Print the list again
System.out.println("After increasing the income: " + persons);

Before increasing the income: [(1, Ken, MALE, 1970-05-04, 6000.00),
 (2, Jeff, MALE, 1970-07-15, 7100.00),(3, Donna, FEMALE, 1962-07-29, 8700.00),
 (4, Chris, MALE, 1993-12-16, 1800.00), (5, Laynie, FEMALE, 2012-12-13, 0.00), 
(6, Li, MALE, 2001-05-09, 2400.00)]

After increasing the income: [..(3, Donna, FEMALE, 1962-07-29, 9570.00)..]

Java 8 STREAMS

Applying Operations on Streams

Applying the Map Operation

<R> Stream<R> map(Function<? super T,? extends R> mapper)
DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper)
IntStream mapToInt(ToIntFunction<? super T> mapper)
LongStream mapToLong(ToLongFunction<? super T> mapper)

ToDoubleFunction:

@FunctionalInterface
public interface ToDoubleFunction<T> {

    /**
     * Applies this function to the given argument.
     *
     * @param value the function argument
     * @return the function result
     */
    double applyAsDouble(T value);
}

You can apply the map operation on a stream using one of the following methods of the Stream<T> interface

Java 8 STREAMS

Applying Operations on Streams

Applying the Map Operation

IntStream map(IntUnaryOperator mapper)
DoubleStream mapToDouble(IntToDoubleFunction mapper)
LongStream mapToLong(IntToLongFunction mapper)
<U> Stream<U> mapToObj(IntFunction<? extends U> mapper)

IntToDoubleFunction:

@FunctionalInterface
public interface IntToDoubleFunction {

    /**
     * Applies this function to the given argument.
     *
     * @param value the function argument
     * @return the function result
     */
    double applyAsDouble(int value);
}

Java 8 STREAMS

Applying Operations on Streams

Applying the Map Operation

IntStream.rangeClosed(1, 5).map(n -> n * n)
         .forEach(System.out::println);
//Result :
1
4
9
16
25

Person.persons().stream().map(Person::getName)
      .forEach(System.out::println);
//Result :
Ken
Jeff
Donna
Chris
Laynie
Li

Java 8 STREAMS

Applying Operations on Streams

Flattening Streams

Stream.of(1, 2, 3)
      .map(n -> Stream.of(n, n * n))
      .forEach(System.out::println);

java.util.stream.ReferencePipeline$Head@372f7a8d
java.util.stream.ReferencePipeline$Head@2f92e0f4
java.util.stream.ReferencePipeline$Head@28a418fc

Java 8 STREAMS

Applying Operations on Streams

Flattening Streams

Stream.of(1, 2, 3)
      .map(n -> Stream.of(n, n * n))
      .forEach(e -> e.forEach(System.out::println));

// Result :

1
1
2
4
3
9

Java 8 STREAMS

Applying Operations on Streams

Flattening Streams

Stream.of(1, 2, 3)
      .flatMap(n -> Stream.of(n, n * n))
      .forEach(System.out::println);
1
1
2
4
3
9

Java 8 STREAMS

Applying Operations on Streams

Applying the Filter Operation

You can apply a filter operation to a stream using the filter() method of the Stream, IntStream, LongStream, and DoubleStream interfaces. The method accepts an instance of the Predicate interface.

Java 8 STREAMS

Applying Operations on Streams

Applying the Filter Operation

Person.persons()
      .stream()
      .filter(Person::isFemale)
      .map(Person::getName)
      .forEach(System.out::println);

//Result :
Donna
Laynie

Person.persons()
      .stream()
      .filter(p -> p.isMale() && p.getIncome() > 5000.0)
      .map(Person::getName)
      .forEach(System.out::println);
//Result :
Ken
Jeff

Java 8 STREAMS