Pause café #154. Trois types de boucles en Java. JDK 19 : nouvelles fonctionnalités de Java 19 à venir en septembre

Trois types de boucles en Java

Source : Medium Après avoir lu cet article, vous découvrirez différentes manières de boucler en Java. Une boucle est conçue pour exécuter un bloc de code jusqu'à ce qu'une condition devienne vraie. Il existe trois types de boucles en Java :

• alors que
• faire pendant
• pour

Boucle while

La boucle while se répète jusqu'à ce que la condition booléenne spécifiée soit vraie. Comme le montre le diagramme ci-dessous, l'instruction sera exécutée jusqu'à ce que le test de condition renvoie vrai.

Syntaxe

while (condition true) {
       // Блок codeа
}

Exemple

Ici, la boucle while sera exécutée jusqu'à ce que la condition soit vraie pour x inférieur à 3.

public class WhileLoop {
     static int x = 1;
     public static void main(String[] args) {
         while(x < 3) {
             System.out.println("x = "+x);
             x++;
         }
     }
}

Conclusion:

faire une boucle en attendant

Une boucle do-while est similaire à une boucle while avec une petite différence. La boucle do-while s'exécute toujours une fois avant de tester la condition.

Syntaxe

do {
     //  Блок codeа
   } while(condition);

Exemple

Dans cet exemple, vous pouvez voir que l'instruction do ou le bloc de code est toujours exécuté une fois avant de tester si la condition est vraie ou fausse.

static int x = 5;
        public static void main(String[] args) {
            do {
                System.out.println("x = "+x);
                x++;
            } while(x < 3);
        }

Conclusion

pour la boucle

La boucle for est très différente des boucles while et do-while. Dans une ligne d'instruction, nous définissons l'initialisation, la condition (vrai ou faux), l'incrémentation/décrémentation.

Syntaxe

For (initialization; condition; increment/decrement) {
    // Блок codeа
}

Exemple

public static void main(String[] args) {
     for(int i = 0 ; i < 2 ; i++) {
         System.out.println("i = " + i);
     }
}

Conclusion: Initialisation : int i = 0 est la condition d'initialisation de la boucle. Condition : vérifie si la condition d'exécution du bloc ou du code à l'intérieur de la boucle for est vraie. Si la condition est fausse, cela mettra fin à la boucle. Incrémenter/décrémenter : mettre à jour la variable pour la prochaine itération.

Boucle for étendue (pour chaque)

Il existe une autre version de la boucle for qui est plus compacte et plus lisible qu'une simple boucle for. C'est ce qu'on appelle une boucle for étendue (ou boucle for-each) et est utilisée pour parcourir des collections et des tableaux. Il est disponible pour tout objet qui implémente l'interface Iterable.

Exemple

class Main
{
    public static void main(String[] args)
    {
        int[] A = { 1, 2, 3, 4, 5 };

        for (int i: A) {
            System.out.println(i);
        }
    }
}

Conclusion:

JDK 19 : nouvelles fonctionnalités de Java 19 à venir en septembre

Source : Infoworld Voici une liste des nouvelles fonctionnalités qui apparaîtront dans la prochaine version du JDK. Sa sortie est prévue le 20 septembre 2022. Java Development Kit 19, une version de support à court terme prévue pour septembre, a atteint le stade de version candidate. Il y a sept fonctionnalités à surveiller : le parallélisme structuré, les modèles d'enregistrement, l'aperçu des API étrangères et de mémoire et la prise en charge de l'architecture de jeu d'instructions (ISA) open source Linux/RISC-V. Les nouvelles fonctionnalités étant déjà gelées pour le JDK 19, d'autres fonctionnalités prévues, telles que les génériques et les objets de valeur, sont reportées vers une version ultérieure de la plateforme. En règle générale, une nouvelle version de Java est publiée tous les six mois. La version candidate du JDK 19 a été publiée le 11 août, après deux versions réduites en juin et juillet. La deuxième release candidate est attendue le 25 août. Les premières versions du JDK 19 peuvent être téléchargées depuis jdk.java.net/19 . Les fonctionnalités du JDK 19 incluent :

• Parallélisme structuré (pendant la phase d'incubation). Il est conçu pour simplifier la programmation multithread à l’aide de l’API Structured Concurrency. Ce parallélisme traite plusieurs tâches exécutées sur différents threads comme une seule unité de travail. En conséquence, cela simplifiera la gestion et l’annulation des erreurs, et la fiabilité sera également améliorée.

• Aperçu des modèles d'enregistrement (pour analyser les valeurs d'enregistrement). Les modèles d'enregistrement et les modèles de type peuvent désormais être imbriqués, offrant ainsi une forme déclarative, puissante et composable de navigation et de manipulation de données. La nouvelle fonctionnalité inclut l'extension de la correspondance de modèles pour exprimer des requêtes de données composées plus complexes sans modifier la syntaxe ou la sémantique des modèles de type.

  Cette innovation s'appuie sur la correspondance de modèles, par exemple, introduite dans le JDK 16 en mars 2021. Les versions futures pourraient nécessiter que les modèles d'enregistrement soient étendus avec des fonctionnalités telles que les modèles de tableau et les modèles vararg.

  Les modèles de publication font partie du projet Amber , qui vise à explorer et développer de petites fonctionnalités Java orientées performances.

• Versions préliminaires des fonctions API étrangères et mémoire . La nouvelle version introduira une API qui permettra aux programmes Java d'interagir avec le code et les données en dehors du runtime Java. En appelant efficacement des fonctions tierces (c'est-à-dire du code extérieur à la JVM) et en accédant en toute sécurité à la mémoire étrangère (mémoire non gérée par la JVM), l'API permettra aux programmes Java d'appeler des bibliothèques natives et de traiter des données natives sans les inconvénients de Java. Interface native (JNI).

  L'API étrangère et l'API mémoire combinent deux API d'incubation antérieures : l'API d'accès à la mémoire externe et l'API de l'éditeur de liens externe. La fonction étrangère et l'API de mémoire ont été précédemment incubées dans le JDK 17 et réincubées dans le JDK 18.

• Aperçu des fils de discussion virtuels. Cette fonctionnalité introduit des threads légers qui réduisent considérablement les efforts d'écriture, de maintenance et de surveillance d'applications parallèles hautes performances. Le but de l'innovation est de fournir la possibilité de faire évoluer les applications serveur écrites dans un style simple thread par requête. La fonctionnalité cible le code qui utilise l'API java.lang Thread pour injecter des threads virtuels avec des modifications minimes et pour dépanner, déboguer et profiler les threads virtuels à l'aide des outils JDK existants.

• Troisième aperçu de la correspondance de modèles pour les expressions et instructions switch . Il étend la correspondance de modèles à switch, ce qui permettra de tester une expression par rapport à un certain nombre de modèles, chacun ayant un effet spécifique, afin que les requêtes complexes centrées sur les données puissent être exprimées de manière concise et sûre.

  Cette fonctionnalité a déjà été présentée en avant-première dans JDK 17 et JDK 18. La troisième version ajoute des améliorations, notamment le remplacement des modèles protected when par des clauses dans les blocs de commutation. De plus, la sémantique d'exécution du modèle de commutateur lorsque la valeur de l'expression du sélecteur est nulle prend désormais en charge la sémantique de commutateur héritée.

  L'innovation élargira l'expressivité et l'applicabilité des expressions et opérateurs de commutation en permettant aux modèles d'apparaître dans les étiquettes de cas. Cela donnera également aux développeurs la possibilité d'atténuer l'animosité historique envers les valeurs nulles et les commutateurs en cas de besoin, d'améliorer la sécurité des instructions switch et de garantir que les instructions switch et les instructions existantes continuent de se compiler sans modification et de s'exécuter avec une sémantique identique.

• Quatrième incubation du vecteur API . Il exprimera des calculs vectoriels qui se compileront de manière fiable au moment de l'exécution en instructions vectorielles optimales sur les architectures de processeur prises en charge. Cela offrira de meilleures performances que les calculs scalaires équivalents. Les développeurs utilisant l'API ont la possibilité d'écrire des algorithmes vectoriels complexes en Java à l'aide du vecteur automatique de HotSpot, mais avec un modèle personnalisé qui rend la vectorisation plus prévisible et plus fiable. L'API Vector a déjà été incubée dans JDK 16, JDK 17 et JDK 19.

  L'API Vector étendra les opérations linéaires intégrales au niveau du bit, y compris des opérations telles que compter le nombre de bits, inverser l'ordre des bits, et compresser et développer les bits.

• Le port Java Linux/RISC-V bénéficiera de la prise en charge des jeux d'instructions matériels qui sont déjà pris en charge par un large éventail de kits d'outils linguistiques. Le port Linux/RISC-V prendra désormais en charge la configuration RV64GV RISC-V, un ISA à usage général 64 bits qui inclut des instructions vectorielles.

  Le port prendra également en charge les options de machine virtuelle HotSpot suivantes : interpréteur de modèles, compilateur C1 JIT (client), compilateur C2 JIT (serveur) et tous les principaux ramasse-miettes actuels, notamment ZGC et Shenandoah.