Streams

Lambda

Simplifie l’écriture des classes internes anonymes
Java 8+

Interface fonctionnelle

Interface qui comporte une méthode unique
- Hors private, default et static
De préférence annotée @FunctionalInterface

Interface fonctionnelle

La méthode (donc l’interface) peut être assimilée à une fonction

Fonction

Interfaces fonctionnelles

Exemple de définition

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
}

Exemple d’utilisation

Comparator<String> c1 = new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        return s1.compareToIgnoreCase(s2);
    }
};

Comparator<String> c2 = (String s1, String s2) -> {
    return s1.compareToIgnoreCase(s2);
};

Simplification 1

Le type peut être omis

Comparator<String> c = (s1, s2) -> {
    return s1.compareToIgnoreCase(s2);
};

Simplification 2

Si le bloc est une simple expression :

Suppression du bloc
Omission du mot-clé return
Omission du ; final

Comparator<String> c = (s1, s2) -> s1.compareToIgnoreCase(s2);

Simplification 3 : Référence de méthode

Quand une expression appelle une méthode existante :

Forme abrégée <Type> + :: + <méthode>

Comparator<String> c = String::compareToIgnoreCase;

Simplification 4

Si il n’y a qu’un unique argument :

Suppression des parenthèses

Function<Integer,Integer> f = i -> i + 1;

Cas d’utilisation de streams

Soit une liste de Person
Calculer la moyenne de l’âge des personnes

Implémentation basique

List<Person> persons = ...

double sum = 0.0;
for (Person person: persons) {
    sum += person.getAge();
}

double average = sum / persons.size();

Problème

Beaucoup de boilerplate code

Focus sur le comment, pas sur le quoi
A l’inverse du tri, sort()

Autres cas d’utilisation

Capitaliser les noms de famille
Conserver uniquement les adultes
Combinaison de cas d’utilisation
etc.

Stream

Un stream est un pipeline de fonctions.

Stream en Java 8

Stream de départ
Opérations intermédiaires → *
Opérations terminales → 1
Peut-être infini

Opération intermédiaire

Retourne un stream
Lazily executed (à la demande)

Opération terminale

Retourne un type concret
- Ou produit des effets de bord
Eagerly executed (lors de l’appel)
Démarre le pipeline

Opérations intermédiaires

map()
filter()
limit()
skip()
distinct()
sorted()

Map

Transforme un stream de types T en un autre stream de types R
Via une instance de Function<T, R>

persons
    .stream()
    .map(new Function<Person,String>() {
        @Override
        public String apply(Person person) {
            return person.getFirstName();
        }
    })
    .map(new Function<String,String>() {
        @Override
        public String apply(String name) {
            return name.toUpperCase();
        }
    });

Utilisation de lambdas

persons
    .stream()
    .map(person -> person.getFirstName())
    .map(name -> name.toUpperCase());

Utilisation de références

persons
    .stream()
    .map(Person::getFirstName)
    .map(String::toUpperCase);

Filter

Transforme un stream de taille x en un autre stream de taille y < x
Via une instance de Predicate

persons
    .stream()
    .filter(person -> person.getAge() >= 18);

Limit

Transforme un stream de taille x en un autre stream de taille y < x
En conservant les n premiers éléments

persons
    .stream()
    .limit(15);

Skip

Transforme un stream de taille x en un autre stream de taille y < x
En omettant les n premiers éléments

persons
    .stream()
    .skip(15);

Distinct

Transforme un stream de taille x en un autre stream de taille y < x
En omettant les doublons

persons
    .stream()
    .distinct();

Sorted

Transforme un stream d’éléments en un stream d’éléments ordonnés
Via une instance de Comparator<T>
- Ou selon l’ordre naturel des éléments

persons
    .stream()
    .sorted((p1, p2) -> p1.getAge() - p2.getAge());

persons
    .stream()
    .sorted(Comparator.comparingInt(Person::getAge));

Opérations finales

collect()
forEach()
reduce()

Collect

Regroupe les éléments d’un stream dans une collection concrète
Via une instance de Collector<T, A, R>

Collector

stream.collect(Collectors.toList());
stream.collect(Collectors.toSet());
stream.collect(Collectors.toMap(
    person -> person.getId(),
    person -> person));
stream.collect(Collectors.toMap(
    Person::getId,
    Function.identity()));

For each

Invoque des effets de bord sur les éléments d’un stream
Via une instance de Consumer<T>

stream.forEach(person -> {
    System.out.println(person);
});
stream.forEach(System.out::println);

Reduce

Aggrège les éléments d’un stream dans un élément unique
Via une instance de BinaryOperator<T>

stream.mapToInt(Person::getAge).average();

Création de streams

Depuis une collection existante
Depuis un tableau existant
Depuis des éléments
Depuis une fonction

Depuis une collection existante

List<Person> persons = ...
Stream<Person> stream = persons.stream();

Depuis un tableau existant

Person[] persons = ...
Stream<Person> stream = Arrays.stream(persons);

Depuis des éléments

Stream<String> stream = Stream.of("one", "two", "three");

Depuis une fonction

Stream<String> stream = Stream.generate(() -> "X");
Stream<Integer> stream = Stream.iterate(0, i -> i + 1);

Fonctionnalités supplémentaires

Match

all: Tous les éléments du stream vérifient le prédicat
none: Aucun élément du stream ne vérifie le prédicat
any: Au moins 1 élément du stream vérifie le prédicat

Find

any: Renvoie un élément quelconque du stream
first: Renvoie le premier élément du stream (s’il est ordonné)

Peek

Permet d’accéder aux élément du stream sans le modifier
Exemple : log l’élément

Flat map

Assemble les éléments de n collections dans un stream unique

Exemple

Comment récupérer tous les produits commandés ?

Stream<List<Product>> streamOfList = orders
    .stream()
    .map(Order::getProducts);

Stream<Product> streamOfProducts = orders
    .stream()
    .flatMap(order -> order.getProducts().stream());

Divers

Stream de types primitifs

IntStream
DoubleStream
LongStream

Spécificités

Optional

Order order = repository.load(1L);

if (order != null) {
    // Do something with person
}

Optional<Order> optional = repository.load(1L);

optional.ifPresent(order -> {
    // Do something with person
});

Order order = repository.load(1L);

if (order == null) {
    order = new Order();
}

Optional<Order> optional = repository.load(1L);
Order order = optional.getOrElse(new Order());