{"id":742980,"date":"2026-10-01T16:08:33","date_gmt":"2026-10-01T15:08:33","guid":{"rendered":"https:\/\/blog.jetbrains.com\/?post_type=idea&p=742980"},"modified":"2026-10-01T16:09:43","modified_gmt":"2026-10-01T15:09:43","slug":"java-27-dans-intellij-idea","status":"publish","type":"idea","link":"https:\/\/blog.jetbrains.com\/fr\/idea\/2026\/10\/java-27-dans-intellij-idea\/","title":{"rendered":"Java\u00a027 dans IntelliJ IDEA"},"content":{"rendered":"

Conform\u00e9ment \u00e0 son cycle de publication semestriel, Java\u00a027 est sorti le 15\u00a0septembre 2026. Dans cet article, nous allons voir ce que contient cette version, comment IntelliJ IDEA continue de prendre en charge les derni\u00e8res versions de Java, et m\u00eame comment IntelliJ IDEA tire parti de certains des changements apport\u00e9s au JDK.<\/p>\n

Java\u00a027 apporte neuf JEP, dont quatre sont finalis\u00e9es. En compl\u00e9ment, quatre fonctionnalit\u00e9s en pr\u00e9version continuent leur maturation et une JEP demeure au stade d’incubation.<\/p>\n

M\u00eame si vous n’utilisez pas IntelliJ IDEA, vous pouvez profiter de son intelligence ailleurs\u00a0: L’extension LSP d’IntelliJ IDEA : l’intelligence de code Java et Kotlin arrive dans VS Code, Cursor et les workflows agentiques<\/em><\/a>. Cela fournit le m\u00eame niveau de prise en charge des derni\u00e8res versions et fonctionnalit\u00e9s de Java, y compris pour les versions en acc\u00e8s anticip\u00e9 et les fonctionnalit\u00e9s en pr\u00e9version.<\/p>\n

Dans cet article, nous allons commencer par configurer IntelliJ IDEA afin d’utiliser la derni\u00e8re version de Java.<\/p>\n

Utilisation de Java\u00a027 dans IntelliJ IDEA (configuration)\u00a0<\/h1>\n

Vous devrez d’abord t\u00e9l\u00e9charger le JDK\u00a027. Vous avez plusieurs fa\u00e7ons de faire\u00a0: vous pouvez le t\u00e9l\u00e9charger depuis IntelliJ IDEA, \u00e0 l’aide d’outils comme SDKMAN!<\/a> ou asdf<\/a>, ou l’installer vous-m\u00eame.<\/p>\n

T\u00e9l\u00e9chargement du JDK<\/h2>\n

Pour t\u00e9l\u00e9charger le JDK\u00a027 depuis IntelliJ IDEA, ouvrez Project Structure, <\/em>allez dans l’onglet Project Settings | Project<\/em>, ouvrez le menu d\u00e9roulant du champ SDK<\/em> et s\u00e9lectionnez Download JDK<\/em>. Dans la fen\u00eatre Download JDK<\/em> qui s’ouvre, d\u00e9finissez Version<\/em> sur 27<\/em>, puis, dans le champ Vendor<\/em>, s\u00e9lectionnez le fournisseur que vous souhaitez utiliser.<\/p>\n

\"\"
Download JDK<\/em><\/figcaption><\/figure>\n
\"\"<\/p>\n
Download JDK \u2013 Select vendor<\/em><\/figcaption>\n<\/figure>\n

Si vous avez d\u00e9j\u00e0 install\u00e9 le JDK, vous pouvez indiquer \u00e0 IntelliJ IDEA o\u00f9 se trouve votre installation. S\u00e9lectionnez plut\u00f4t Add JDK from Disk<\/em> dans le menu d\u00e9roulant.<\/p>\n

\"\"<\/p>\n
Add JDK from disk<\/em><\/figcaption>\n<\/figure>\n

La version du JDK sera automatiquement propag\u00e9e depuis les param\u00e8tres de votre projet vers le terminal, ce qui signifie que vous-m\u00eame et votre agent pourrez utiliser le bon JDK pour votre projet dans le terminal d’IntelliJ IDEA. Cette fonctionnalit\u00e9 a fait l’objet d’une d\u00e9monstration dans la vid\u00e9o Nouveaut\u00e9s d’IntelliJ IDEA\u00a02026.2<\/a>.<\/p>\n

Si vous utilisez SDKMAN!<\/a> ou asdf<\/a> pour g\u00e9rer vos JDK, IntelliJ IDEA peut lire le fichier .sdkmanrc<\/code> ou .tool-versions<\/code> dans votre projet et configurer le JDK automatiquement si vous l’avez d\u00e9j\u00e0 install\u00e9.<\/p>\n

Si vous utilisez SDKMAN! et que la version du JDK sp\u00e9cifi\u00e9e dans le fichier .sdkmanrc<\/code> n’est pas encore install\u00e9e, une indication en ligne appara\u00eetra dans le fichier pour vous permettre de la t\u00e9l\u00e9charger directement depuis l’IDE en ex\u00e9cutant la commande SDKMAN! correspondante. correspondante. Cela fonctionne m\u00eame si SDKMAN! n’est pas install\u00e9, ce qui signifie que cette fonctionnalit\u00e9 est \u00e9galement disponible pour les utilisateurs de Windows.<\/p>\n

Pour en savoir plus sur la configuration du JDK, consultez la documentation<\/a>.<\/p>\n

Configuration du niveau de langage<\/h2>\n

IntelliJ IDEA prend en charge Java\u00a027 d\u00e8s sa sortie. Dans Project Structure<\/em>, configurez Language level<\/em> sur 27 \u2013 No new language features<\/em>.<\/p>\n

\"\"<\/p>\n
27 \u2013 No new language features<\/em><\/figcaption>\n<\/figure>\n

Si vous utilisez des fonctionnalit\u00e9s en pr\u00e9version, choisissez 27 (Preview) \u2013 Primitive types in patterns, instanceof, and switch (5th preview).<\/em> Notez qu’IntelliJ IDEA met en \u00e9vidence l’utilisation des fonctionnalit\u00e9s en pr\u00e9version dans l’\u00e9diteur, afin que vous sachiez exactement o\u00f9 vous les utilisez.<\/p>\n

\"\"<\/p>\n
27 (Preview) \u2013 Primitive types in patterns, instanceof, and switch (5th preview)<\/em><\/figcaption>\n<\/figure>\n

Nouvelles fonctionnalit\u00e9s stables de Java\u00a027<\/h1>\n

Java\u00a027 inaugure 4\u00a0nouvelles fonctionnalit\u00e9s stables. Jetons un coup d’\u0153il.<\/p>\n

JEP\u00a0523\u00a0: Faire de G1 le ramasse-miettes par d\u00e9faut dans tous les environnements<\/a><\/h2>\n

Garbage-First (G1) est le ramasse-miettes par d\u00e9faut depuis Java\u00a09, \u00e0 une exception pr\u00e8s\u00a0: les machines disposant d’un seul CPU ou de moins de 1\u00a0792\u00a0Mo de RAM basculaient sur Serial GC. Cette JEP fait de G1 le ramasse-miettes par d\u00e9faut de la JVM HotSpot dans tous les environnements, et non plus uniquement dans les environnements serveur, en remplacement du garbage collector Serial.<\/p>\n

Le ramasse-miettes\u00a0G1 a b\u00e9n\u00e9fici\u00e9 d’am\u00e9liorations (notamment JEP\u00a0522\u00a0: Ramasse-miettes\u00a0G1\u00a0: am\u00e9liorer le d\u00e9bit en r\u00e9duisant la synchronisation dans Java\u00a026<\/a>), si bien que ses performances sont d\u00e9sormais suffisantes pour remplacer Serial. Pour les applications ex\u00e9cut\u00e9es dans des environnements aux ressources limit\u00e9es, qui offrent de meilleures performances avec Serial, celui-ci peut \u00eatre activ\u00e9 explicitement \u00e0 l\u2019aide de l\u2019option -XX:+UseSerialGC.<\/p>\n

JEP\u00a0527\u00a0: \u00c9change hybride post-quantique de cl\u00e9s pour TLS\u00a01.3<\/a><\/h2>\n

Cette JEP renforce la s\u00e9curit\u00e9 des applications Java n\u00e9cessitant des communications r\u00e9seau s\u00e9curis\u00e9es en impl\u00e9mentant des algorithmes d’\u00e9change de cl\u00e9s hybrides pour TLS\u00a01.3. Cela permet de se pr\u00e9munir contre les attaques de type \u00ab\u00a0harvest now, decrypt later\u00a0\u00bb (collecter maintenant, d\u00e9chiffrer plus tard), lors desquelles un attaquant enregistre aujourd\u2019hui du trafic chiffr\u00e9 dans le but de le d\u00e9chiffrer une fois que les ordinateurs quantiques seront suffisamment puissants.<\/p>\n

JEP\u00a0534\u00a0: En-t\u00eates d’objets compacts par d\u00e9faut<\/a><\/h2>\n

Cette JEP fait des en-t\u00eates d’objets compacts la disposition par d\u00e9faut des en-t\u00eates d’objets dans la JVM HotSpot.<\/p>\n

En r\u00e9duisant la taille des en-t\u00eates d’objet de 96 \u00e0 64\u00a0bits sur les architectures 64\u00a0bits, les en-t\u00eates d’objet compacts diminuent la taille du tas, am\u00e9liorent la densit\u00e9 de d\u00e9ploiement et augmentent la localit\u00e9 des donn\u00e9es.<\/p>\n

Les en-t\u00eates d’objets compacts ont \u00e9t\u00e9 introduits en tant que fonctionnalit\u00e9 exp\u00e9rimentale dans Java\u00a024, puis sont devenus une fonctionnalit\u00e9 activable dans Java 25. \u00c9tant donn\u00e9 que les en-t\u00eates d’objet compacts sont d\u00e9sormais activ\u00e9s par d\u00e9faut, il n’est plus n\u00e9cessaire de les activer \u00e0 l’aide d’une option de ligne de commande, comme c’\u00e9tait le cas avec le JDK\u00a025.\u00a0<\/p>\n

Les applications comportant un grand nombre d’objets b\u00e9n\u00e9ficieront particuli\u00e8rement de ce changement, car l’utilisation d’en-t\u00eates d’objets compacts r\u00e9duit l’empreinte m\u00e9moire de la JVM. Les JetBrains IDEs utilisent cette fonctionnalit\u00e9 et ont constat\u00e9 des \u00e9conomies de m\u00e9moire syst\u00e9matiques lorsqu’elle est activ\u00e9e. En savoir plus<\/a>.<\/p>\n

JEP\u00a0536\u00a0: Masquage des donn\u00e9es JFR internes au sein du processus<\/a><\/h2>\n

Cette JEP am\u00e9liore JDK Flight Recorder (JFR) en masquant les arguments de ligne de commande ainsi que les valeurs initiales des variables d’environnement et des propri\u00e9t\u00e9s syst\u00e8me dans les enregistrements avant qu’ils ne quittent le processus, afin d’\u00e9viter toute fuite d’informations sensibles.<\/p>\n

Fonctionnalit\u00e9s de Java\u00a027 en pr\u00e9version<\/h1>\n

Les fonctionnalit\u00e9s en pr\u00e9version permettent aux d\u00e9veloppeurs de tester de nouvelles fonctionnalit\u00e9s et d’apporter leur retour d’exp\u00e9rience avant leur finalisation. Les fonctionnalit\u00e9s en pr\u00e9version peuvent faire l’objet de plusieurs it\u00e9rations, avec ou sans modifications, avant d’\u00eatre finalis\u00e9es et de devenir une partie standard du langage.<\/p>\n

IntelliJ IDEA s’efforce de prendre en charge les fonctionnalit\u00e9s en pr\u00e9version, afin que vous puissiez exp\u00e9rimenter avant qu’elles ne deviennent la norme. Comme ces fonctionnalit\u00e9s sont toujours sujettes \u00e0 changement, IntelliJ IDEA ne prend en charge les fonctionnalit\u00e9s en pr\u00e9version que pour le JDK actuel. Pour activer les fonctionnalit\u00e9s en pr\u00e9version, d\u00e9finissez Language <\/em>level<\/em> sur 27 (Preview) \u2013 Primitive types in patterns, instanceof, and switch (5th preview).<\/em><\/p>\n

Java\u00a027 contient quatre fonctionnalit\u00e9s en pr\u00e9version et une fonctionnalit\u00e9 en incubation. Les fonctionnalit\u00e9s elles-m\u00eames sont identiques \u00e0 celles de Java\u00a026, mais certaines d’entre elles ont \u00e9t\u00e9 r\u00e9vis\u00e9es dans Java\u00a027.\u00a0<\/p>\n

JEP\u00a0531\u00a0: Lazy constants (troisi\u00e8me pr\u00e9version)<\/a><\/h2>\n

Les lazy constants (constantes \u00e0 initialisation diff\u00e9r\u00e9e) sont des objets qui contiennent des donn\u00e9es immuables. Comme leur nom l’indique, elles sont \u00e9valu\u00e9es de mani\u00e8re diff\u00e9r\u00e9e. Cela pr\u00e9sente des avantages par rapport aux champs final, qui sont \u00e9valu\u00e9s imm\u00e9diatement. Avec les lazy constants, les champs ne sont \u00e9valu\u00e9s qu’en cas de besoin, ce qui peut am\u00e9liorer le temps de d\u00e9marrage.<\/p>\n

Pour une explication un peu plus d\u00e9taill\u00e9e, consultez la section consacr\u00e9e aux Lazy constants dans Java\u00a026 avec IntelliJ IDEA<\/em><\/a>.<\/p>\n

Les lazy constants ont \u00e9t\u00e9 inaugur\u00e9es dans Java\u00a025 (en tant que valeurs stables<\/a>) et ont connu des modifications importantes dans Java\u00a026. L’API a fait l’objet de nouvelles r\u00e9visions avec Java\u00a027.\u00a0\u00a0<\/p>\n

JEP\u00a0532\u00a0: Types primitifs dans les patterns, instanceof et switch (5e\u00a0pr\u00e9version)<\/a><\/h2>\n

Comme expliqu\u00e9<\/a> dans Java\u00a026 dans IntelliJ IDEA<\/em><\/a>, cette fonctionnalit\u00e9 \u00e9tend la correspondance de motifs afin de prendre en charge tous les types primitifs dans les contextes de motifs, notamment avec instanceof<\/code> et switch<\/code>. Cette fonctionnalit\u00e9 supprime certaines limitations de la correspondance de motifs, permettant de comparer, tester et convertir des valeurs de types primitifs dans ces constructions en toute s\u00e9curit\u00e9. La suppression des casts manuels non s\u00e9curis\u00e9s (susceptibles de provoquer des bugs subtils) et des v\u00e9rifications de plage a am\u00e9lior\u00e9 la s\u00e9curit\u00e9 et la lisibilit\u00e9 du code. Cette fonctionnalit\u00e9 est toujours en pr\u00e9version dans Java\u00a027, sans changement par rapport \u00e0 la version de Java\u00a026.<\/p>\n

Exemple rapide<\/h3>\n

Examinons rapidement un exemple d\u2019utilisation des types primitifs dans des expressions switch avec des patterns de garde.<\/p>\n

int itemDiscountPercentage(int items) {\n   return switch (items) {\n       case 2 -> 5;\n       case 3, 4 -> 10;\n       case int i when i >= 5 -> 20;\n       default -> 0;\n   };\n}<\/pre>\n
Nous pouvons ajouter une Javadoc \u00e0 cette m\u00e9thode pour expliquer son fonctionnement. Depuis Java\u00a023 (JEP\u00a0467<\/a>), on peut \u00e9crire de la Javadoc en Markdown. Si votre projet utilise JDK\u00a023 ou une version ult\u00e9rieure, IntelliJ IDEA ins\u00e9rera par d\u00e9faut des commentaires de documentation Markdown lorsque vous utilisez l’action contextuelle Add Javadoc<\/em>.<\/p>\n\n\n
Add JavaDoc<\/em><\/figcaption><\/figure>\n\n\n
Remarque\u00a0: si vous pr\u00e9f\u00e9rez utiliser des commentaires classiques plut\u00f4t que le Markdown, ouvrez Settings<\/em>, allez dans Editor | Code Style | Java | Code Generation | Comment Code<\/em>, puis d\u00e9cochez l’option Prefer documentation line comments<\/em>.<\/p>\n\n\n
\"\"
Prefer documentation line comments<\/em><\/figcaption><\/figure>\n\n\n
IntelliJ IDEA peut convertir les commentaires Javadoc en Markdown gr\u00e2ce \u00e0 l’action contextuelle Convert to Markdown documentation comment<\/em>.<\/p>\n\n\n
Convert to Markdown documentation comment<\/em><\/figcaption><\/figure>\n\n\n
Vous trouverez une explication plus d\u00e9taill\u00e9e de cette fonctionnalit\u00e9 dans cette section<\/a> de Java\u00a023 et IntelliJ IDEA<\/em><\/a>.<\/p>\n
JEP\u00a0533\u00a0: Concurrence structur\u00e9e (7e\u00a0pr\u00e9version)<\/a><\/h2>\n
Comme expliqu\u00e9<\/a> dans Java\u00a026 dans IntelliJ IDEA<\/em><\/a>, la concurrence structur\u00e9e nous offre de meilleurs \u00ab\u00a0idiomes\u00a0\u00bb pour le code multithread, ce qui permet au code de mieux correspondre au mod\u00e8le mental de l\u2019utilisateur.\u00a0<\/p>\n
La concurrence structur\u00e9e consid\u00e8re les groupes de t\u00e2ches li\u00e9es s\u2019ex\u00e9cutant dans diff\u00e9rents threads comme des unit\u00e9s de travail uniques. Cela am\u00e9liore la lisibilit\u00e9 et l’observabilit\u00e9\u00a0; le code concurrent est donc plus facile \u00e0 comprendre et \u00e0 appr\u00e9hender. Cela permet \u00e9galement d’\u00e9liminer les fuites de threads et les d\u00e9lais d’annulation.\u00a0<\/p>\n
Pour en savoir plus sur la concurrence structur\u00e9e et son fonctionnement avec les autres fonctionnalit\u00e9s du projet Loom, consultez mon pr\u00e9c\u00e9dent article de blog, Project Loom in IntelliJ IDEA\u00a0: Virtual Threads, Scoped Values, and Structured Concurrency<\/em><\/a> (Projet Loom dans IntelliJ IDEA\u00a0: threads virtuels, valeurs \u00e0 port\u00e9e limit\u00e9e et concurrence structur\u00e9e).<\/p>\n
Comme mentionn\u00e9 dans cet article, il existe un live template permettant de g\u00e9n\u00e9rer rapidement la structure de base d\u2019un StructuredTaskScope<\/code>. Vous pouvez afficher la liste des live templates<\/a> disponibles dans IntelliJ IDEA \u00e0 l\u2019aide du raccourci (\u2318J<\/em> sur macOS \/ Ctrl+J<\/em> sous Windows et Linux).<\/p>\n
Vous pouvez \u00e9galement utiliser la compl\u00e9tion des commandes<\/a> : saisissez ..<\/code> pour afficher la liste de toutes les commandes pertinentes dans le contexte actuel. Vous pouvez m\u00eame saisir une partie du nom de la commande (par exemple \u00ab live \u00bb pour la commande Afficher les mod\u00e8les dynamiques), et la commande correspondante appara\u00eetra parmi les r\u00e9sultats de la compl\u00e9tion classique.<\/p>\n
href=”https:\/\/www.jetbrains.com\/help\/idea\/using-live-templates.html” target=”_blank” rel=”noopener”>live templates<\/a> disponibles dans IntelliJ IDEA \u00e0 l’aide du raccourci (\u2318J<\/em> sous macOS\/Ctrl+J<\/em> sous Windows et Linux). Vous pouvez \u00e9galement utiliser la compl\u00e9tion des commandes<\/a>\u00a0: saisissez .. et une liste de toutes les commandes pertinentes dans votre contexte actuel s’affichera. Vous pouvez m\u00eame saisir une partie du nom de la commande (par exemple \u00ab\u00a0live\u00a0\u00bb pour Show live templates), et la commande correspondante s’affichera parmi les suggestions de saisie semi-automatique.<\/p>\n
Vous pouvez lancer des recherches dans la liste des live templates, aussi bien par nom que par description. Si l’on cherche \u00ab\u00a0structured\u00a0\u00bb, on trouvera le live template sts<\/code>.<\/p>\n\n\n
Use command completion to Show live templates<\/em><\/figcaption><\/figure>\n\n\n
Pour en savoir plus sur la compl\u00e9tion de commande, consultez mon pr\u00e9c\u00e9dent article : Universal Entry Point\u00a0: A Single Entry Point for Context-Aware Coding Assistance<\/em><\/a> (Point d’entr\u00e9e universel\u00a0: un point d’entr\u00e9e unique pour une assistance au codage contextuelle).<\/p>\n
JEP\u00a0538\u00a0: Encodages PEM des objets cryptographiques (3e\u00a0pr\u00e9version)<\/a><\/h2>\n
Comme d\u00e9crit<\/a> dans Java\u00a026 dans IntelliJ IDEA<\/em><\/a>, cette JEP fournit une API en pr\u00e9version pour l’encodage et le d\u00e9codage d’objets cryptographiques (cl\u00e9s, certificats et listes de r\u00e9vocation de certificats) vers et depuis le format PEM (Privacy-Enhanced Mail).<\/p>\n
L’API a fait l’objet de nouvelles modifications dans Java\u00a027 par rapport \u00e0 la version pr\u00e9c\u00e9dente.<\/p>\n
Fonctionnalit\u00e9s de Java\u00a027 en incubation<\/h1>\n
Les modules d’incubation<\/a> sont des API exp\u00e9rimentales. Il s’agit explicitement d’API et d’outils non finalis\u00e9s, mis \u00e0 la disposition des d\u00e9veloppeurs \u00e0 des fins d’essai. Contrairement aux fonctionnalit\u00e9s en pr\u00e9version, les fonctionnalit\u00e9s en incubation peuvent faire l’objet de modifications importantes, voire \u00eatre supprim\u00e9es dans les versions futures. Elles ne sont pas destin\u00e9es \u00e0 un usage en production.<\/p>\n
Pour utiliser une fonctionnalit\u00e9 en incubation, vous devez explicitement ajouter le module lors de l’ex\u00e9cution du code, en utilisant l’option de ligne de commande --add-modules<\/code> pour ce module sp\u00e9cifique.<\/p>\n
Si vous ex\u00e9cutez le code \u00e0 partir d’IntelliJ IDEA, vous pouvez ajouter des options de ligne de commande aux configurations d’ex\u00e9cution de votre application. S\u00e9lectionnez la configuration d’ex\u00e9cution de votre programme, puis cliquez sur les trois points pour acc\u00e9der \u00e0 More Actions<\/em>. S\u00e9lectionnez Edit<\/em> pour ouvrir Run\/Debug Configurations<\/em>. Cliquez sur le lien Modify Options<\/em>, puis, dans la fen\u00eatre contextuelle Add Run Options<\/em>, s\u00e9lectionnez Add VM Options<\/em>. Un nouveau champ s’affichera avec l’indication VM Options. Ajoutez l’option de ligne de commande \u00e0 ce champ.<\/p>\n\n\n
Add VM Options<\/em><\/figcaption><\/figure>\n\n\n
JEP\u00a0537\u00a0: API Vector (12e\u00a0incubation)<\/a><\/h2>\n
Comme indiqu\u00e9<\/a> dans Java\u00a026 dans IntelliJ IDEA<\/em><\/a>, cette JEP introduit une API qui permet aux d\u00e9veloppeurs d’exprimer des calculs vectoriels qui se compilent de mani\u00e8re fiable en instructions vectorielles optimales sur les processeurs pris en charge. Les op\u00e9rations vectorielles permettent d’effectuer davantage de travail au cours d\u2019un m\u00eame cycle CPU, ce qui peut entra\u00eener des gains de performance significatifs.<\/p>\n
Comme il s’agit d’un module en incubation, vous devrez utiliser une option de ligne de commande pour ajouter le module explicitement, comme d\u00e9crit ci-dessus. Pour utiliser l’API Vector, ajoutez l’option de ligne de commande suivante\u00a0: --add-modules jdk.incubator.vector<\/code>.<\/p>\n
L’API Vector n’a connu aucun changement dans Java\u00a027 par rapport \u00e0 Java\u00a026. Cette fonctionnalit\u00e9 restera en incubation jusqu’\u00e0 ce que les fonctionnalit\u00e9s requises du Projet Valhalla<\/a> passent en pr\u00e9version.<\/p>\n
Autres changements\u00a0: am\u00e9liorations du d\u00e9bogueur<\/h1>\n
Outre les JEP, le JDK\u00a027 apporte des corrections de bugs, comme JDK-6960970<\/a>. Le d\u00e9bogueur \u00e9tait tr\u00e8s lent lors de l\u2019ex\u00e9cution pas \u00e0 pas. Ce probl\u00e8me a \u00e9t\u00e9 corrig\u00e9 dans le JDK\u00a027 et l\u2019ex\u00e9cution pas \u00e0 pas dans le d\u00e9bogueur est d\u00e9sormais plus rapide. Nos ing\u00e9nieurs ont r\u00e9troport\u00e9 ce correctif dans JetBrains Runtime (JBR) 25<\/a>, afin d\u2019acc\u00e9l\u00e9rer l\u2019ex\u00e9cution pas \u00e0 pas lors du d\u00e9bogage du code d\u2019IntelliJ IDEA lui-m\u00eame. Cela montre qu’il est possible de r\u00e9troporter cette modification vers Java\u00a025 et qu’elle fonctionne correctement. Si vous souhaitez profiter de cette modification, vous pouvez utiliser JBR\u00a025 ou demander \u00e0 votre fournisseur de r\u00e9troporter cette modification.<\/p>\n
Futures orientations<\/h1>\n
Des fonctionnalit\u00e9s du projet Valhalla commencent \u00e0 faire leur apparition dans Java. Les objets valeurs (JEP\u00a0401)<\/a> et l’initialisation stricte des champs dans la JVM (JEP\u00a0539)<\/a> ont tous deux \u00e9t\u00e9 retenus comme fonctionnalit\u00e9s en pr\u00e9version du JDK\u00a028<\/a>. Si vous souhaitez essayer ces fonctionnalit\u00e9s, il n’est donc plus n\u00e9cessaire de t\u00e9l\u00e9charger une distribution Valhalla sp\u00e9cifique. Vous pouvez t\u00e9l\u00e9charger la version EA du JDK\u00a028 (acc\u00e8s anticip\u00e9). Cette version est disponible au t\u00e9l\u00e9chargement directement depuis IntelliJ IDEA.<\/p>\n
Si vous avez d\u00e9j\u00e0 t\u00e9l\u00e9charg\u00e9 le JDK 28\u00a0EA, indiquer \u00e0 IntelliJ IDEA o\u00f9 se trouve votre installation.<\/p>\n
Conclusion<\/h1>\n
Bien qu’il ne s’agisse pas d’une version LTS, Java\u00a027 apporte des am\u00e9liorations en mati\u00e8re de s\u00e9curit\u00e9 et de performances, et a fait \u00e9voluer plusieurs fonctionnalit\u00e9s en pr\u00e9version importantes. IntelliJ IDEA prend en charge Java\u00a027 d\u00e8s sa sortie, et continuera de prendre en charge les derni\u00e8res fonctionnalit\u00e9s Java. N’h\u00e9sitez pas \u00e0 nous faire part de vos commentaires.<\/p>\n
Auteur de l’article original en anglais<\/em> :<\/p>\n\n    
\n        
\n            
\n                
\n                    \"Marit\n                <\/div>\n                
\n                                            
Marit van Dijk<\/h4>\n                                                        <\/div>\n            <\/div>\n        <\/div>\n    <\/div>\n","protected":false},"author":813,"featured_media":743200,"comment_status":"closed","ping_status":"closed","template":"","categories":[5088,89],"tags":[40,155,9265],"cross-post-tag":[],"class_list":["post-742980","idea","type-idea","status-publish","has-post-thumbnail","hentry","category-java","category-news","tag-intellij-idea","tag-java","tag-java-27"],"acf":[],"_links":{"self":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/idea\/742980","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/idea"}],"about":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/types\/idea"}],"author":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/users\/813"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/comments?post=742980"}],"version-history":[{"count":10,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/idea\/742980\/revisions"}],"predecessor-version":[{"id":743993,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/idea\/742980\/revisions\/743993"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/media\/743200"}],"wp:attachment":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/media?parent=742980"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/categories?post=742980"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/tags?post=742980"},{"taxonomy":"cross-post-tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/cross-post-tag?post=742980"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}