Licence Creative Commons

Ce document est mis à disposition selon les termes de la Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International.

1. Références

En français :
En anglais :

2. Lambdas

2.1. Reconnaissance d’interfaces fonctionnelles

Pour chaque interface suivante, déterminer s’il s’agit d’une interface fonctionnelle - qui peut être utilisée comme lambda et justifier votre réponse.

public interface Foo { } (1)
public interface Foo { (2)
    void foo();
}
public interface Foo { (3)
    int foo();
}
public interface Foo { (4)
    int foo(int someInt);
}
interface Foo { (5)
    void foo();
}
@FunctionalInterface
interface Foo { (6)
    void foo();
}
@FunctionalInterface
public interface Foo { (7)

    default public int bar(int someInt) {
        return 2 * someInt;
    }

    int foo(int someInt);
}
public interface Foo { }

public interface Bar extends Foo { (8)
    void bar();
}
public interface Foo {
    void foo();
}

public interface Bar extends Foo { (9)
    void bar();
}

2.2. Equivalence interface fonctionnelle lambda

Pour chacune des interfaces fonctionnelles suivantes, déterminer la lambda équivalente sans l’aide d’un AGL. Puis vérifier votre réponse à l’aide de celui-ci.

@FunctionalInterface
public interface Supplier<T> {
    T get();
}
@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}
@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}
@FunctionalInterface
public interface BiFunction<T, U, R> {
    R apply(T t, U u);
}
@FunctionalInterface
public interface ObjLongConsumer<T> {
    void accept(T t, long value);
}
@FunctionalInterface
public interface IntUnaryOperator {
    int applyAsInt(int operand);
}
@FunctionalInterface
public interface TemporalQuery<R> {
    R queryFrom(TemporalAccessor temporal);
}
@FunctionalInterface
public interface Callback<P,R> {
    R call(P param);
}
@FunctionalInterface
public interface BuilderFactory {
    Builder<?> getBuilder(Class<?> type);
}
@FunctionalInterface
public interface ChangeListener<T> {
    void changed(ObservableValue<? extends T> observable, T oldValue, T newValue);
}
@FunctionalInterface
public interface Recognizer {
    boolean recognize(int c);
}
@FunctionalInterface
public interface Interpolatable<T> {
    public T interpolate(T endValue, double t);
}

2.3. Equivalence lambda interface fonctionnelle

Pour chacune des lambdas suivantes, proposer une interface fonctionnelle du JDK équivalente.

() -> "Hello world"; (1)
s -> s; (2)
(String s1, String s2) -> s1.compareToIgnoreCase(s2); (3)
f -> "Hello".equals(f); (4)
() -> System.out.println("Hello world"); (5)
o -> o.hashCode(); (6)

  1. Rechercher dans les packages java.util et java.util.function

  2. Rechercher dans les interfaces annotés avec @FunctionalInterface

3. Streams

Soit la classe suivante :

public class Person {

    private final long id;
    private final String firstName;
    private final String lastName;
    private final LocalDate birthDate;

    public Person(long id, String firstName, String lastName, LocalDate birthDate) {
        this.id = id;
        this.firstName = firstName;
        this.lastName = lastName;
        this.birthDate = birthDate;
    }

    // Getters for fields
}

3.1. Opération sur les streams

A partir d’une instance de Stream<Person>, retourner une stream qui répond aux contraintes suivantes :

  1. Seules les personnes dont le nom de famille est "Doe"

  2. Seules les personnes dont l’age est supérieur à 18 à la date du jour

  3. Seules les personnes dont le nom de famille est le même que le prénom

  4. Seuls les noms de famille, en majuscules, sans doublons

  5. Toutes les personnes, ordonnées par date de naissance croissante

3.2. Opérations sur les collections

Implémenter les méthodes suivantes suivantes en utilisant uniquement les streams.

List<Person> onlyAdults(List<Person> persons) { }
double averageAge(List<Person> persons) { }
String lastNamesSeparatedWithSpace(List<Person> persons) { }
Map<String, List<Person>> groupByFirstName(List<Person> persons) { }

3.3. Divers

A l’aide de streams :

  1. Calculer la factorielle de 10

    • n! = n x (n - 1) pour n > 0

    • 0! = 1

  2. Calculer la suite de Fibonacci pour n = 5

    • Fibn = Fibn-1 + Fibn-2 pour n > 2

    • Fib1 = 1

    • Fib2 = 1,

4. Exercices supplémentaires

Lab Xebia à JFall 2014

Réaliser les exercices du dossier ./java8workshop/JFall Hands-On/java8-hands-on-jfall-2014/exercises en suivant les instructions données sur Github.