 Java 8 :

Introduction des Lambdas, Streams, Optional, Date/Time API.

Les Functional Interfaces en Java

 Java 11 :

var en lambdas, amélioration des String, HttpClient.

 Java 17 :

switch avancé, records, sealed classes.

 Java 21 :

switch finalisé, virtual threads, sequenced collections, scoped values.

 Spring 5 : Introduction de WebFlux, support de Java 8+, programmation réactive.

 Spring 6 : Passage à Jakarta EE 9+, amélioration de la sécurité et observabilité.
 Spring Boot 2 : Performance accrue, WebFlux, Actuator amélioré.
 Spring Boot 3 : Support des Virtual Threads, GraalVM, OpenTelemetry.

 Angular 9-12 : Ivy devient le moteur par défaut, améliorations des performances.

 Angular 13-15 : Standalone Components, TypeScript 4.5+, simplification de la

configuration.

 Angular 16-18 : Signals API, Hydration SSR, nouvelles directives @for et @if.

Java 8 (2014) : Révolution Fonctionnelle

Java 8 a introduit des fonctionnalités majeures qui ont changé la manière d'écrire du code en
Java.

1. Lambda Expressions

Les expressions lambda permettent d'écrire des fonctions anonymes plus concises.
Exemple

// Avant Java 8
Comparator<String> comparator = new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return s1.length() - s2.length();
}
};

// Avec Java 8 (Lambda)

Comparator<String> comparatorLambda = (s1, s2) -> s1.length() - s2.length();

2. Streams API

Permet de manipuler des collections de données de manière fonctionnelle.

Exemple

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

// Filtrer les noms qui commencent par 'A' et les afficher

names.stream()
.filter(name -> name.startsWith("A"))
.forEach(System.out::println);

3. Default Methods dans les Interfaces

Les interfaces peuvent désormais avoir des méthodes avec implémentation par défaut.

interface Vehicle {
default void print() {
System.out.println("Ceci est un véhicule");
}
}

class Car implements Vehicle {}

public class Main {

public static void main(String[] args) {
new Car().print(); // Affiche : Ceci est un véhicule
}
}
4. Optional

Évite les NullPointerException en encourageant l'utilisation de valeurs optionnelles.

Exemple

Optional<String> optional = Optional.ofNullable(null);

System.out.println(optional.orElse("Valeur par défaut")); // Affiche : Valeur par défaut

5. API Date & Time (java.time)

Nouvelle API de gestion des dates plus robuste.

Exemple

LocalDate today = LocalDate.now();

System.out.println("Aujourd'hui : " + today);

LocalDate nextWeek = today.plusWeeks(1);

System.out.println("Semaine prochaine : " + nextWeek);

Les Functional Interfaces en Java

Une Functional Interface est une interface qui ne contient qu'une seule méthode abstraite. Elle
peut contenir des méthodes default ou static, mais ne doit avoir qu'une seule méthode
abstraite. Ces interfaces sont particulièrement utiles pour la programmation fonctionnelle et sont
souvent utilisées avec les expressions lambda et les références de méthode.

Java fournit plusieurs functional interfaces dans le package java.util.function, comme

Supplier, Consumer, Function, Predicate, BiFunction, BiPredicate, BiConsumer, etc.

1. Exemple avec Function<T, R> et andThen()

L'interface Function<T, R> prend un argument de type T et retourne un résultat de type R.

La méthode andThen(Function<R, V>) permet de chaîner deux fonctions.

✅ Exemple

import java.util.function.Function;
public class FunctionExample {
public static void main(String[] args) {
Function<Integer, Integer> multiplyByTwo = x -> x * 2;
Function<Integer, Integer> addThree = x -> x + 3;

// Combinaison des deux fonctions : d'abord multiplyByTwo puis

addThree
Function<Integer, Integer> combinedFunction =
multiplyByTwo.andThen(addThree);

System.out.println(combinedFunction.apply(5)); // (5 * 2) + 3 = 13
}
}

2. Exemple avec BiFunction<T, U, R> et andThen()

L'interface BiFunction<T, U, R> prend deux arguments (T, U) et retourne un résultat R.

La méthode andThen(Function<R, V>) permet d'appliquer une autre fonction après l'exécution
de la première.

✅ Exemple

import java.util.function.BiFunction;
import java.util.function.Function;

public class BiFunctionExample {

public static void main(String[] args) {
BiFunction<Integer, Integer, Integer> multiply = (a, b) -> a * b;
Function<Integer, String> convertToString = result -> "Résultat: " +
result;

// Chaînage avec andThen : d'abord multiply, puis convertToString

BiFunction<Integer, Integer, String> combined =
multiply.andThen(convertToString);

System.out.println(combined.apply(4, 5)); // Résultat: 20

}
}

3. Exemple avec Supplier<T>

Un Supplier<T> ne prend aucun paramètre et retourne une valeur de type T.

✅ Exemple

import java.util.function.Supplier;

public class SupplierExample {

public static void main(String[] args) {
Supplier<Double> randomSupplier = () -> Math.random();
 System.out.println(randomSupplier.get()); // Affiche un nombre
aléatoire
}
}

4. Exemple avec Consumer<T> et andThen()

Un Consumer<T> prend une valeur et n'en retourne aucune. Il est utilisé pour effectuer des
actions sur des objets.

✅ Exemple

import java.util.function.Consumer;

public class ConsumerExample {

public static void main(String[] args) {
Consumer<String> printUpperCase = s ->
System.out.println(s.toUpperCase());
Consumer<String> printLowerCase = s ->
System.out.println(s.toLowerCase());

// Chaînage avec andThen()

Consumer<String> combinedConsumer =
printUpperCase.andThen(printLowerCase);

combinedConsumer.accept("Java Functional Interfaces");

}
}

Sortie :

Nginx

JAVA FUNCTIONAL INTERFACES

java functional interfaces

5. Exemple avec Predicate<T> et or() / and()

Un Predicate<T> prend une valeur et retourne un boolean.

Les méthodes or(), and(), et negate() permettent de combiner plusieurs prédicats.

✅ Exemple

import java.util.function.Predicate;

public class PredicateExample {

public static void main(String[] args) {
Predicate<Integer> isEven = x -> x % 2 == 0;
 Predicate<Integer> isPositive = x -> x > 0;

Predicate<Integer> isEvenAndPositive = isEven.and(isPositive);

Predicate<Integer> isEvenOrPositive = isEven.or(isPositive);

System.out.println(isEvenAndPositive.test(4)); // true (4 est pair

et positif)
System.out.println(isEvenAndPositive.test(-4)); // false (-4 est pair
mais pas positif)
System.out.println(isEvenOrPositive.test(-4)); // true (-4 est pair)
System.out.println(isEvenOrPositive.test(3)); // true (3 est
positif)
}
}

✅ Résumé des méthodes principales

Interface Signature de la méthode principale Description

Function<T, R> R apply(T t) Transforme une valeur de T en R

BiFunction<T, U, R> R apply(T t, U u) Transforme deux valeurs (T, U) en R

Consumer<T> void accept(T t) Exécute une action sur T

BiConsumer<T, U> void accept(T t, U u) Exécute une action sur (T, U)

Supplier<T> T get() Retourne une valeur sans paramètre

Predicate<T> boolean test(T t) Teste une condition sur T

Java 11 (2018) : Améliorations et Performance
Java 11 a apporté des améliorations de syntaxe et de nouvelles API.

1. var dans les Lambdas

On peut utiliser var pour déclarer les paramètres d’une expression lambda.

Exemple

BiFunction<Integer, Integer, Integer> sum = (var a, var b) -> a + b;

System.out.println(sum.apply(5, 3)); // Affiche : 8

2. String API améliorée

 strip() : Supprime les espaces en début et fin (meilleur que trim()).

 lines() : Divise une chaîne en lignes.
 repeat(n) : Répète une chaîne n fois.

Exemple

String text = " Bonjour ";

System.out.println(text.strip()); // "Bonjour"

String multiline = "Ligne 1\nLigne 2\nLigne 3";

multiline.lines().forEach(System.out::println); // interface Fonctionel

System.out.println("Java ".repeat(3)); // "Java Java Java "

3. HttpClient

Nouvelle API pour effectuer des requêtes HTTP de manière plus moderne.

Exemple

HttpClient client = HttpClient.newHttpClient();

HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://jsonplaceholder.typicode.com/posts/1"))
.GET()
.build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
Java 17 (2021) : LTS et Simplicité
Java 17 a introduit des améliorations de la syntaxe et des performances.

1. Pattern Matching pour switch (Preview)

Permet d’écrire des switch plus lisibles.

Exemple

Object obj = 123;

String result = switch (obj) {

case Integer i -> "Nombre entier : " + i;
case String s -> "Chaîne : " + s;
default -> "Autre type";
};

System.out.println(result); // Affiche : Nombre entier : 123

2. Records (Simplification des POJO)

Les records permettent de créer des classes immuables sans code boilerplate.

Exemple

record Person(String name, int age) {}

Person person = new Person("Alice", 30);

System.out.println(person.name()); // Affiche : Alice

3. Sealed Classes

Permet de restreindre quelles classes peuvent hériter d’une classe.

Exemple

sealed class Vehicle permits Car, Truck {}

final class Car extends Vehicle {}

final class Truck extends Vehicle {}
Java 21 (2023) : Modernisation et Performance
Java 21 a introduit des améliorations majeures, notamment des fonctionnalités finalisées.

1. Pattern Matching pour switch (Finalisé)

Améliore la lisibilité avec des cas plus précis.

Exemple

static String format(Object obj) {

return switch (obj) {
case Integer i -> "Nombre entier : " + i;
case String s when s.length() > 5 -> "Longue chaîne : " + s;
case null -> "Valeur nulle";
default -> "Autre type";
};
}

System.out.println(format("HelloWorld")); // Affiche : Longue chaîne : HelloWorld

2. Virtual Threads (Performance)

Les virtual threads améliorent la gestion des threads en Java.

Exemple

ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();

executor.submit(() -> {
System.out.println("Hello depuis un Virtual Thread !");
});

executor.shutdown();

3. Sequenced Collections

Introduit une nouvelle API pour manipuler des collections de manière ordonnée.

Exemple

SequencedSet<Integer> numbers = new LinkedHashSet<>();

numbers.add(1);
 numbers.add(2);
numbers.addFirst(0);
numbers.addLast(3);

System.out.println(numbers); // Affiche : [0, 1, 2, 3]

4. Scoped Values (Gestion des Contextes)

Permet de partager des valeurs immuables entre threads de manière efficace.

Exemple

ScopedValue<String> user = ScopedValue.newInstance();

void process() {
ScopedValue.runWhere(user, "Alice", () -> {
System.out.println("Utilisateur : " + user.get());
});
}

process(); // Affiche : Utilisateur : Alice

🌱 Spring 5 (2017)
Spring 5 a introduit des améliorations majeures, notamment la compatibilité avec Java 8+ et le
support réactif.

1. Support de Java 8+ et Java 9

Spring 5 impose Java 8 minimum et apporte une compatibilité avec Java 9+.

Exemple : Utilisation de Optional dans un Service

@Service
public class UserService {
public Optional<User> findUserById(Long id) {
return userRepository.findById(id);
}
}

2. Programmation Réactive avec Spring WebFlux

Spring WebFlux permet de créer des applications réactives, en alternative à Spring MVC.

Exemple : Contrôleur WebFlux

@RestController
public class UserController {

@GetMapping("/users")
public Flux<User> getUsers() {
return userService.getAllUsers(); // Renvoie un Flux réactif
}
}

3. Utilisation de @Nullable et @NonNull

Ajoute une meilleure gestion de la nullabilité.

Exemple

public String sayHello(@Nullable String name) {

return name != null ? "Hello " + name : "Hello Guest!";
}
4. Amélioration du Functional Bean Registration

Possibilité de déclarer des beans via des lambdas.

Exemple

@Configuration
public class AppConfig {
@Bean
public Supplier<String> messageSupplier() {
return () -> "Hello from Spring 5!";
}
}

🚀 Spring 6 (2022)
Spring 6 a introduit le support de Jakarta EE 9+, des améliorations de sécurité et des
performances accrues.

1. Migration vers Jakarta EE 9+

Spring 6 utilise Jakarta EE 9+, ce qui signifie que les packages javax.* sont maintenant
jakarta.*.

Avant (Spring 5)

import javax.servlet.http.HttpServletRequest;
Après (Spring 6)

import jakarta.servlet.http.HttpServletRequest;

2. Amélioration de Spring Security

Support des Password Encoders et meilleure gestion des JWT.

Exemple : Configuration d’un Password Encoder

@Bean
public PasswordEncoder passwordEncoder() {
 return new BCryptPasswordEncoder();
}

3. Observabilité avec Micrometer

Spring 6 intègre Micrometer pour la télémétrie.

Exemple : Exposition des métriques

@Bean
MeterRegistryCustomizer<MeterRegistry> metricsCommonTags() {
return registry -> registry.config().commonTags("application", "MyApp");
}

🔥 Spring Boot 2 (2018)

Spring Boot 2 a apporté des améliorations en termes de performances, de sécurité et de
réactivité.

1. Migration vers Spring 5 et Java 8+

Spring Boot 2 repose sur Spring 5 et apporte WebFlux.

2. Meilleure Gestion des Properties

Possibilité d’utiliser @ConfigurationProperties avec des classes POJO.

Exemple

@ConfigurationProperties(prefix = "app")
public class AppConfig {
private String name;
// Getters et Setters
}

3. Actuator Amélioré

Ajout de nouvelles métriques et points de terminaison.

Exemple : Activer Actuator

Dans application.properties :

management.endpoints.web.exposure.include=health,info

⚡ Spring Boot 3 (2022)

Spring Boot 3 repose sur Spring 6 et apporte des améliorations majeures.

1. Passage à Jakarta EE

Les applications doivent migrer de javax.* vers jakarta.*.

2. Virtual Threads avec Spring Boot 3.2+

Spring Boot 3.2 prend en charge les Virtual Threads (Loom).

Exemple

@Bean
Executor virtualThreadExecutor() {
return Executors.newVirtualThreadPerTaskExecutor();
}

3. Spring AOT (Ahead-of-Time) Compilation

Optimise Spring pour GraalVM et les images natives.

4. Observabilité avec Micrometer et OpenTelemetry

Spring Boot 3 améliore les logs et les traces distribuées.

Exemple

@Bean
MeterRegistryCustomizer<MeterRegistry> metricsCommonTags() {
return registry -> registry.config().commonTags("application", "MyApp");
}
ANGULAR
🚀 Angular 9 (Février 2020)
1. Ivy par défaut

Le moteur de rendu Ivy devient le moteur de compilation et de rendu par défaut, améliorant les
performances et la réduction de la taille des bundles.

Exemple : Amélioration de la taille des bundles

Avant Angular 9, les composants inutilisés étaient inclus dans le bundle. Avec Ivy, le tree-
shaking supprime le code inutilisé.

⚡ Angular 10 (Juin 2020)

1. Support amélioré de TypeScript 3.9

Meilleure compatibilité et vérification de types plus stricte.

2. Nouvelle configuration stricte

Un nouveau flag --strict pour générer un projet avec des restrictions TypeScript et Angular
strictes.

ng new my-app --strict

🔥 Angular 11 (Novembre 2020)

1. Webpack 5 et Build plus rapide

Amélioration des builds et réduction du temps de compilation.

2. Mise à jour automatique avec ng update

ng update @angular/core @angular/cli

🚀 Angular 12 (Mai 2021)
1. Abandon de View Engine (Ivy only)

Le moteur View Engine est supprimé, Angular repose uniquement sur Ivy.

2. Support des Webpack 5 et TypeScript 4.2

Meilleure gestion des imports et des performances accrues.

⚡ Angular 13 (Novembre 2021)

1. Suppression de ViewEngine

Tout projet Angular doit utiliser Ivy.

2. Amélioration de la gestion des composants

Les composants n'ont plus besoin d'être déclarés dans les entryComponents.

🔥 Angular 14 (Juin 2022)

1. Standalone Components

Possibilité de créer des composants sans NgModule.

Exemple : Standalone Component

import { Component } from '@angular/core';

@Component({
standalone: true,
selector: 'app-hello',
template: `<h1>Hello Angular!</h1>`,
})
export class HelloComponent {}
🚀 Angular 15 (Novembre 2022)
1. Amélioration des Standalone APIs

On peut maintenant charger des routes sans NgModule.

Exemple : Déclaration de routes standalone

const routes: Routes = [

{ path: '', component: HomeComponent },
];

bootstrapApplication(AppComponent, {
providers: [provideRouter(routes)]
});

⚡ Angular 16 (Mai 2023)

1. Signals API

Les Signals permettent une gestion réactive des états sans RxJS.

Exemple : Utilisation de Signals

import { signal } from '@angular/core';

export class CounterComponent {

count = signal(0);

increment() {
this.count.set(this.count() + 1);
}
}

2. Hydration pour SSR

Amélioration du Server Side Rendering (SSR) avec hydration automatique.

🔥 Angular 17 (Novembre 2023)

1. Nouvelle syntaxe de Template ( @for / @if )
Les nouvelles directives structurales simplifient les templates.

Exemple : @for et @if

@Component({
selector: 'app-example',
template: `
@if (users.length > 0) {
<ul>
@for (user of users; track user.id) {
<li>{{ user.name }}</li>
}
</ul>
}
`,
})
export class ExampleComponent {
users = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
}

🚀 Angular 18 (Mai 2024 - à venir)

Angular 18 continue d'améliorer la performance et la DX (Developer Experience).
Les Signals deviennent la norme et les Standalone Components sont encore plus optimisés.