Java 11 est la première version LTS publiée par Oracle depuis Java 8, marquant le passage au cycle de releases de 6 mois. Au programme : un client HTTP moderne, de nouvelles méthodes sur String et Files, l'exécution directe de scripts Java, et la suppression de modules obsolètes.

Depuis Java 11, Oracle publie une nouvelle version tous les 6 mois (mars et septembre). Les versions LTS (Long-Term Support) reçoivent un support étendu : Java 11, 17, 21, 25…

1. Nouvelles méthodes sur String

Java 11 ajoute plusieurs méthodes utilitaires à java.lang.String très attendues par la communauté.

Java 
// isBlank() — vide ou que des espaces
"   ".isBlank();   // true
"".isBlank();      // true
"abc".isBlank();   // false

// strip() — Unicode-aware (contrairement à trim())
"  hello  ".strip();          // "hello"
"  hello  ".stripLeading();   // "hello  "
"  hello  ".stripTrailing();  // "  hello"

// repeat(n) — répéter une chaîne
"ha".repeat(3);  // "hahaha"
"-".repeat(40); // "----------------------------------------"

// lines() — stream de lignes
"line1\nline2\nline3".lines()
    .map(String::trim)
    .filter(String::isNotBlank)
    .collect(Collectors.toList());
// → ["line1", "line2", "line3"]

2. Nouvelles méthodes sur Files

Lire et écrire des fichiers devient enfin aussi simple qu'en Python ou Node.js.

Java 
import java.nio.file.*;

Path fichier = Path.of("/tmp/data.txt");

// Lire tout le contenu en une ligne
String contenu = Files.readString(fichier);
String contenuUTF8 = Files.readString(fichier, StandardCharsets.UTF_8);

// Écrire en une ligne
Files.writeString(fichier, "Contenu du fichier");
Files.writeString(fichier, "Ajout\n", StandardOpenOption.APPEND);

// Avant Java 11 — verbose
String ancien = new String(
    Files.readAllBytes(Paths.get("/tmp/data.txt")),
    StandardCharsets.UTF_8
);

3. HTTP Client API (standardisé)

Le nouveau java.net.http.HttpClient remplace l'ancien HttpURLConnection et le client expérimental de Java 9. Il supporte HTTP/2, WebSocket, et les requêtes asynchrones.

Java 
import java.net.http.*;
import java.net.URI;

HttpClient client = HttpClient.newBuilder()
    .connectTimeout(Duration.ofSeconds(10))
    .followRedirects(HttpClient.Redirect.NORMAL)
    .build();

// Requête GET synchrone
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com/users"))
    .header("Accept", "application/json")
    .GET()
    .build();

HttpResponse<String> response =
    client.send(request, HttpResponse.BodyHandlers.ofString());

System.out.println(response.statusCode()); // 200
System.out.println(response.body());

// Requête POST asynchrone
client.sendAsync(
    HttpRequest.newBuilder()
        .uri(URI.create("https://api.example.com/users"))
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString("{\"name\":\"Kriss\"}"))
        .build(),
    HttpResponse.BodyHandlers.ofString()
).thenApply(HttpResponse::body)
 .thenAccept(System.out::println);

4. var dans les expressions Lambda (JEP 323)

Java 11 permet d'utiliser var dans les paramètres des expressions lambda, notamment pour pouvoir ajouter des annotations.

Java 
// Java 10 — var pour les variables locales
var liste = new ArrayList<String>();
var taille = liste.size();

// Java 11 — var dans les lambdas (pour annoter)
(var s) -> s.toUpperCase();  // équivalent à (String s) ->

// Cas d'usage : ajouter @NonNull dans un lambda
liste.stream()
    .map((@NonNull var s) -> s.toUpperCase())
    .collect(Collectors.toList());

5. Exécution directe de fichiers Java

Java 11 permet de lancer un programme Java mono-fichier sans compilation préalable — idéal pour les scripts.

Shell 
# Créer un fichier Hello.java
cat > Hello.java << 'EOF'
public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello depuis Java 11 !");
    }
}
EOF

# Exécuter directement — plus besoin de javac !
java Hello.java

# Avec un shebang sur Unix
#!/usr/bin/java --source 11

6. Ce qui a été supprimé

Java 11 effectue un grand ménage et supprime des modules jugés obsolètes ou appartenant à Java EE :

Si votre projet utilise des modules Java EE (JAXB pour XML, JAX-WS pour SOAP…), vous devez ajouter les dépendances manuellement dans votre pom.xml ou build.gradle avant de migrer vers Java 11+.

XML — pom.xml (remplacement JAXB) 
<!-- Ajouter si vous utilisez JAXB -->
<dependency>
    <groupId>jakarta.xml.bind</groupId>
    <artifactId>jakarta.xml.bind-api</artifactId>
    <version>4.0.0</version>
</dependency>
<dependency>
    <groupId>com.sun.xml.bind</groupId>
    <artifactId>jaxb-impl</artifactId>
    <version>4.0.3</version>
</dependency>

7. Z Garbage Collector (ZGC) — expérimental

Java 11 introduit ZGC, un garbage collector à faible latence capable de gérer des heaps de plusieurs téraoctets avec des pauses inférieures à 10ms. Il devient stable en Java 15.

Shell 
# Activer ZGC
java -XX:+UseZGC -Xmx16g -jar monapp.jar

8. Récapitulatif Java 11

🌐

HTTP Client

java.net.http — HTTP/2, async, WebSocket, fluent API.

📝

String amélioré

isBlank(), strip(), repeat(), lines() — les utilitaires manquants.

📁

Files readString/writeString

Lire/écrire un fichier en une seule ligne de code.

▶

Exécution directe

java MonFichier.java — scripts Java sans compilation.

🗑️

Suppression Java EE

JAXB, JAX-WS, CORBA retirés — à ajouter via Maven.

⚡

ZGC

Garbage collector ultra-faible latence (<10ms de pause).

Sources