Java 25 : Toutes les nouveautés

Pourquoi Java 25 est une version clé ?

Java 25 est une version majeure du JDK publiée le 16 septembre 2025. Cette nouvelle version de Java est estampillée LTS (Long Term Support), ce qui signifie qu'Oracle et les autres distributeurs du JDK fourniront un support à long terme pendant au moins huit ans. Pour les entreprises et les développeurs Java, c'est la version vers laquelle migrer après Java 21.

Le JDK 25 marque une étape importante dans l'évolution de Java. Après Java 17 (septembre 2021) et Java 21 (septembre 2023), Java 25 est la troisième version LTS de la nouvelle cadence de release. Cette version apporte des améliorations significatives en termes de performances, de simplicité du code source et de nouvelles APIs pour les développeurs.

Cette release du JDK contient 18 JEPs (Java Enhancement Proposals) réparties ainsi :

• 12 fonctionnalités finalisées - prêtes pour la production
• 4 fonctionnalités en preview - à tester avant adoption définitive
• 1 fonctionnalité expérimentale - pour les early adopters
• 1 fonctionnalité en incubation - API en cours de stabilisation

Migration recommandée : Si vous êtes sur Java 17 ou Java 21, Java 25 apporte des gains de performance significatifs et de nouvelles fonctionnalités du langage Java qui simplifient le code source.

Les 18 JEPs de Java 25 : vue d'ensemble

Voici la liste complète des JEPs incluses dans le JDK 25. Chaque JEP représente une amélioration ou une nouvelle fonctionnalité de la plateforme Java. Ces propositions ont été développées par la communauté OpenJDK et validées pour cette version.

JEPs finalisées dans Java 25

• JEP 467 - Markdown Documentation Comments
• JEP 485 - Stream Gatherers (API Gatherer)
• JEP 506 - Scoped Values
• JEP 508 - Key Derivation Function API
• JEP 511 - Module Import Declarations
• JEP 512 - Compact Source Files and Instance Main Methods
• JEP 513 - Flexible Constructor Bodies
• JEP 514 - Ahead-of-Time Command-Line Ergonomics
• JEP 515 - Ahead-of-Time Method Profiling
• JEP 519 - Compact Object Headers
• JEP 521 - Generational Shenandoah
• JEP 518 - JFR Cooperative Sampling

JEPs en preview dans Java 25

• JEP 502 - Stable Values (Preview)
• JEP 505 - Structured Concurrency (5th Preview)
• JEP 507 - Primitive Types in Patterns (3rd Preview)
• JEP 470 - PEM Encodings of Cryptographic Objects (Preview)

JEP expérimentale

• JEP 509 - JFR CPU-Time Profiling (Experimental)

Nouveautés du langage Java 25

Java 25 introduit plusieurs évolutions syntaxiques majeures qui rendent le code Java plus concis, plus sûr et plus facile à maintenir. Ces nouvelles fonctionnalités du langage sont finalisées et peuvent être utilisées en production dès maintenant dans vos projets Java.

import module java.base;
import module java.sql;

// Tous les types de java.util, java.io, java.sql sont disponibles
// Plus besoin d'importer chaque classe individuellement

public class Utilisateur extends Personne {
    public Utilisateur(String email) {
        // Validation AVANT super() - nouveauté Java 25
        if (email == null || !email.contains("@")) {
            throw new IllegalArgumentException("Email invalide");
        }
        String emailNormalise = email.toLowerCase().trim();

        // Appel au constructeur parent après validation
        super(emailNormalise);
    }
}

// Fichier Hello.java - c'est tout le code nécessaire !
void main() {
    System.out.println("Bonjour Java 25 !");
}

// Ou avec des arguments
void main(String[] args) {
    System.out.println("Arguments: " + args.length);
}

// Déclaration d'une ScopedValue
private static final ScopedValue<User> CURRENT_USER = ScopedValue.newInstance();

void handleRequest(User user) {
    // Création d'un scope avec la valeur
    ScopedValue.runWhere(CURRENT_USER, user, () -> {
        // Toutes les méthodes appelées peuvent accéder à user
        processRequest();
        validatePermissions();
        saveAuditLog();
    });
}

void processRequest() {
    // Accès à la valeur dans le scope
    User user = CURRENT_USER.get();
    System.out.println("Traitement pour: " + user.getName());
}

/// Calcule le **total** de la commande avec remise.
///
/// Cette méthode applique la remise sur le prix total des articles.
///
/// ## Paramètres
/// - `items` : liste des articles de la commande
/// - `remise` : pourcentage de réduction (entre 0 et 100)
///
/// ## Retour
/// Le montant total après application de la remise
///
/// ## Exemple
/// ```java
/// double total = calculerTotal(articles, 10.0);
/// ```
public double calculerTotal(List<Item> items, double remise) {
    double sousTotal = items.stream()
        .mapToDouble(Item::getPrix)
        .sum();
    return sousTotal * (1 - remise / 100);
}

// Utilisation des Gatherers intégrés
// Fenêtre glissante de taille fixe
List<List<Integer>> fenetres = Stream.of(1, 2, 3, 4, 5, 6)
    .gather(Gatherers.windowFixed(2))
    .toList();
// Résultat: [[1, 2], [3, 4], [5, 6]]

// Fenêtre glissante
List<List<Integer>> sliding = Stream.of(1, 2, 3, 4, 5)
    .gather(Gatherers.windowSliding(3))
    .toList();
// Résultat: [[1, 2, 3], [2, 3, 4], [3, 4, 5]]

// Fold (accumulation avec état)
Optional<Integer> somme = Stream.of(1, 2, 3, 4, 5)
    .gather(Gatherers.fold(() -> 0, Integer::sum))
    .findFirst();
// Résultat: Optional[15]

Performances et améliorations de la JVM dans Java 25

Le JDK 25 met fortement l'accent sur les performances avec pas moins de 9 JEPs dédiées à l'optimisation de la JVM HotSpot et du temps d'exécution Java. Ces améliorations font partie du Project Leyden qui vise à réduire le temps de démarrage et l'empreinte mémoire des applications Java.

Compact Object Headers (JEP 519)

La JEP 519 réduit la taille des en-têtes d'objets Java de 12 à 8 octets sur les architectures 64 bits. Cette optimisation au niveau de la JVM apporte des économies de mémoire significatives pour toutes les applications Java, particulièrement celles qui créent beaucoup de petits objets.

• Réduction de 10-15% de l'empreinte mémoire typique des applications Java
• Testé en production chez Oracle et Amazon avec d'excellents résultats
• Aucun changement de code requis - activation automatique dans le JDK 25
• Amélioration des performances grâce à une meilleure utilisation du cache CPU

Les développeurs Java bénéficient automatiquement de cette amélioration lors de l'exécution de leur code sur le JDK 25. Cette JEP était en phase expérimentale dans Java 24 et est maintenant finalisée.

Ahead-of-Time (AOT) Compilation améliorée

Deux JEPs importantes améliorent la compilation Ahead-of-Time dans Java 25, réduisant significativement le temps de démarrage des applications Java :

• JEP 514 - AOT Command-Line Ergonomics : Simplifie la création de caches AOT avec de nouvelles options en ligne de commande. Les développeurs peuvent désormais créer un cache AOT en une seule commande, rendant cette optimisation accessible à tous les projets Java.
• JEP 515 - AOT Method Profiling : Permet d'inclure des profils d'exécution de méthodes dans le cache AOT. Le compilateur JIT peut ainsi démarrer immédiatement avec des informations de profilage, accélérant l'initialisation de l'application Java.

# Création d'un cache AOT pour une application Java
java -XX:AOTCache=app.aot -XX:AOTMode=record -jar monapp.jar

# Exécution avec le cache AOT
java -XX:AOTCache=app.aot -jar monapp.jar

Generational Shenandoah (JEP 521)

La JEP 521 transforme le garbage collector Shenandoah en collecteur générationnel. Cette amélioration apporte des gains de performance significatifs pour les applications Java avec beaucoup d'objets à courte durée de vie (ce qui est le cas de la majorité des applications).

Shenandoah générationnel offre :

• Des pauses GC encore plus courtes qu'avec Shenandoah classique
• Un meilleur débit pour les applications avec forte allocation
• Une meilleure utilisation de la mémoire grâce à la séparation young/old generation

JFR Cooperative Sampling (JEP 518)

La JEP 518 améliore Java Flight Recorder (JFR) avec un nouveau mode d'échantillonnage coopératif. Cette technique réduit l'overhead du profilage tout en maintenant une bonne précision des données collectées. Les développeurs Java peuvent ainsi profiler leurs applications en production avec un impact minimal sur les performances.

Nouvelles APIs de sécurité dans Java 25

Le JDK 25 renforce la sécurité avec de nouvelles APIs cryptographiques modernes :

Key Derivation Function API (JEP 508)

La JEP 508 introduit une nouvelle API pour les fonctions de dérivation de clés (KDF). Cette API Java permet de générer des clés cryptographiques à partir de secrets partagés ou de mots de passe de manière sécurisée et standardisée.

// Utilisation de HKDF pour dériver une clé
KeyDerivation kdf = KeyDerivation.getInstance("HKDF-SHA256");
SecretKey derivedKey = kdf.deriveKey(
    "AES",
    new HKDFParameterSpec(
        masterSecret,
        salt,
        info,
        256  // taille de la clé en bits
    )
);

PEM Encodings (JEP 470 - Preview)

La JEP 470 simplifie la manipulation des certificats et clés au format PEM, le format standard pour l'échange de matériel cryptographique. Cette API en preview facilite la lecture et l'écriture de clés publiques, privées et de certificats X.509 dans les applications Java.

Fonctionnalités en Preview dans Java 25

Plusieurs fonctionnalités sont disponibles en preview dans le JDK 25. Ces features peuvent être testées mais sont susceptibles d'évoluer avant leur finalisation. Activez-les avec l'option --enable-preview lors de la compilation et de l'exécution.

// Pattern matching avec types primitifs
Object valeur = 42;

String resultat = switch (valeur) {
    case int i when i > 0 -> "entier positif: " + i;
    case int i when i < 0 -> "entier négatif: " + i;
    case int i -> "zéro";
    case double d -> "décimal: " + d;
    case String s -> "chaîne: " + s;
    default -> "autre type";
};

// instanceof avec primitifs
if (valeur instanceof int i && i > 100) {
    System.out.println("Grand entier: " + i);
}

// Exécution de tâches concurrentes avec Structured Concurrency
Response fetchUserData(long userId) throws Exception {
    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
        // Lancement de tâches en parallèle
        Subtask<User> userTask = scope.fork(() -> fetchUser(userId));
        Subtask<List<Order>> ordersTask = scope.fork(() -> fetchOrders(userId));
        Subtask<Preferences> prefsTask = scope.fork(() -> fetchPreferences(userId));

        // Attente de toutes les tâches
        scope.join();
        scope.throwIfFailed();

        // Récupération des résultats
        return new Response(
            userTask.get(),
            ordersTask.get(),
            prefsTask.get()
        );
    }
}

// Avant Java 25 - double-checked locking (complexe et error-prone)
private volatile ExpensiveObject instance;
public ExpensiveObject getInstance() {
    if (instance == null) {
        synchronized (this) {
            if (instance == null) {
                instance = new ExpensiveObject();
            }
        }
    }
    return instance;
}

// Avec Java 25 - StableValue (simple et sûr)
private final StableValue<ExpensiveObject> instance =
    StableValue.of(() -> new ExpensiveObject());

public ExpensiveObject getInstance() {
    return instance.get();
}

Fonctionnalités supprimées dans Java 25

Le JDK 25 supprime définitivement certaines fonctionnalités obsolètes pour simplifier la plateforme Java et réduire la dette technique :

Security Manager (JEP 486)

Le Security Manager, déprécié depuis Java 17, est définitivement supprimé dans Java 25. Cette fonctionnalité était rarement utilisée pour sécuriser le code côté serveur et sa maintenance représentait un coût significatif pour l'équipe du JDK.

Impact pour les développeurs Java : Si votre application utilise le Security Manager, vous devez migrer vers des alternatives comme les conteneurs, les politiques de sécurité au niveau OS, ou des frameworks de sécurité Java modernes.

Ports x86 32 bits (JEP 503)

La JEP 503 supprime le support des architectures x86 32 bits du JDK. Les binaires Java 32 bits ne sont plus disponibles à partir de Java 25. Cette décision reflète la réalité du marché où les systèmes 64 bits sont désormais la norme.

Comment migrer vers Java 25 ?

La migration vers le JDK 25 est généralement simple pour les projets Java modernes. Voici les étapes recommandées pour une transition en douceur.

Étape 1 : Télécharger le JDK 25

Plusieurs options sont disponibles pour obtenir le JDK 25 :

• OpenJDK officiel - builds de référence
• Oracle JDK - avec support commercial
• SDKMAN - gestionnaire de versions pour les développeurs : sdk install java 25-open
• Adoptium - builds Eclipse Temurin avec support LTS
• Amazon Corretto - distribution AWS du JDK

Étape 2 : Mettre à jour les outils de build

Assurez-vous que vos outils supportent Java 25 :

• Maven : version 3.9.0 ou supérieure recommandée
• Gradle : version 8.5 ou supérieure
• IntelliJ IDEA : version 2025.2 ou supérieure
• Eclipse : version 2025-09 ou supérieure
• VS Code : extension Java mise à jour

Configuration Maven pour Java 25

<properties>
    <maven.compiler.source>25</maven.compiler.source>
    <maven.compiler.target>25</maven.compiler.target>
    <maven.compiler.release>25</maven.compiler.release>
</properties>

<!-- Pour utiliser les features preview -->
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.12.0</version>
            <configuration>
                <enablePreview>true</enablePreview>
            </configuration>
        </plugin>
    </plugins>
</build>

Configuration Gradle pour Java 25

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(25)
    }
}

// Pour activer les features preview
tasks.withType(JavaCompile) {
    options.compilerArgs += ['--enable-preview']
}

tasks.withType(Test) {
    jvmArgs += ['--enable-preview']
}

tasks.withType(JavaExec) {
    jvmArgs += ['--enable-preview']
}

Étape 3 : Vérifier la compatibilité

• Testez vos dépendances avec le JDK 25
• Vérifiez l'absence d'utilisation du Security Manager
• Mettez à jour les bibliothèques qui utilisent des APIs internes du JDK
• Exécutez votre suite de tests complète

Points d'attention pour la migration

• Security Manager : si votre application l'utilise, planifiez une migration vers une alternative
• Compact Object Headers : activé par défaut, testez les performances de votre application
• Virtual Threads + Scoped Values : remplacez ThreadLocal par ScopedValue pour de meilleures performances
• APIs dépréciées : vérifiez les warnings de compilation et planifiez les mises à jour

Historique des versions LTS de Java

Java 25 s'inscrit dans la continuité des versions LTS qui jalonnent l'histoire récente de Java :

• Java 8 (mars 2014) - Lambdas, Streams, nouvelle API Date/Time
• Java 11 (septembre 2018) - Première LTS post-Java 9, HttpClient
• Java 17 (septembre 2021) - Sealed classes, pattern matching
• Java 21 (septembre 2023) - Virtual Threads, Record Patterns
• Java 25 (septembre 2025) - Scoped Values, Flexible Constructors, Module Imports

Avec le cycle de release semestriel, une nouvelle version LTS est publiée tous les deux ans en septembre. La prochaine version LTS sera Java 29 en septembre 2027.

Ressources officielles pour Java 25

Pour approfondir vos connaissances sur Java 25 et le JDK, consultez ces ressources :

• Page officielle JDK 25 sur OpenJDK
• Téléchargement JDK 25
• Blog Inside.java - actualités Java par Oracle
• dev.java - tutoriels et documentation officielle
• Nos traductions de JEPs en français
• Tous nos articles Java

Prochaine version : Java 26 est prévu pour mars 2026. Cette version non-LTS devrait apporter de nouvelles améliorations issues des projets Valhalla (Value Types), Panama (Foreign Function & Memory API) et Loom.

Questions fréquentes sur Java 25

Java 25 est-il rétrocompatible ?

Oui, Java 25 maintient une excellente rétrocompatibilité avec les versions précédentes. Le code Java compilé pour Java 8 et supérieur fonctionne sans modification sur le JDK 25. Seules les applications utilisant le Security Manager nécessitent des adaptations.

Quand migrer vers Java 25 ?

En tant que version LTS, Java 25 est recommandé pour la production. Les entreprises sur Java 17 ou Java 21 peuvent planifier leur migration dès que leurs dépendances sont compatibles. Pour les nouveaux projets Java, Java 25 est le choix évident.

Quel est le support de Java 25 ?

Oracle fournit un support LTS d'au moins 8 ans pour Java 25. Les distributions comme Adoptium, Amazon Corretto et Azul proposent également un support long terme. C'est un investissement sûr pour les projets d'entreprise.