Commençant par Versions du JDK 5, Il existe deux formes de boucle for en Java. La première est la forme traditionnelle, utilisée depuis version originale Java. Le second est le nouveau formulaire « pour chaque ». Nous examinerons les deux types de boucles for, en commençant par la forme traditionnelle.

Forme générale de l'opérateur traditionnel pour comme suit:

Si une seule instruction est répétée en boucle, croisillons peut être omis.

Faire du vélo pour fonctionne de la manière suivante. Lorsque la boucle est démarrée pour la première fois, le programme exécute initialisation partie du cycle. En général, il s'agit d'une expression qui définit la valeur d'une variable de contrôle de boucle, qui agit comme un compteur contrôlant la boucle. Il est important de comprendre que l'expression initialisation exécuté une seule fois. Le programme calcule ensuite condition ce qui devrait être booléen expression. Généralement, l'expression conditions compare la valeur de la variable de contrôle avec valeur cible. Si cette valeur est vraie, le programme exécute corps faire du vélo. Si c'est faux, l'exécution de la boucle est interrompue.. Le programme exécute ensuite corps boucle et seulement après cela, la partie est exécutée répétition faire du vélo. Répétition il s'agit généralement d'une expression qui augmente ou diminue la valeur d'une variable de contrôle. Le programme répète ensuite la boucle, à chaque passage, en calculant d'abord conditionnel expression, puis faire corps boucle et exécution de l'expression répétitions . Le processus est répété jusqu'à ce que la valeur de l'expression conditions ne deviendra pas faux.

Puisque la plupart des boucles utilisent uniquement leurs variables dans la boucle, la boucle pour permet l'expression initialisation était une déclaration de variable complète. Ainsi, la variable est limitée au corps de la boucle et est invisible de l'extérieur.

Voici quelques exemples qui expliquent tout ce qui précède :

Dans cet exemple, la variable je déclaré en dehors de la boucle (ligne 7), il est donc également disponible après son achèvement (ligne 12).

D'après la sortie de ce programme, on peut voir que l'expression répétitions cycle, à savoir l'incrément de préfixe ( ++je) variable je exécuté après l'exécution du corps de la boucle, c'est-à-dire après l'exécution de la ligne 10, qui imprime le message d'accueil.

Ce point est très important à comprendre afin d’avoir une bonne compréhension du fonctionnement du cycle. pour.

Examinons maintenant le résultat de ce programme avec et sans arguments de ligne de commande :

Comme le montre la sortie de ce programme, l'incrément de la variable je se produit après l'exécution de la dernière commande de la boucle, qui imprime le message d'accueil (ligne 10).

Déclarons maintenant une variable à l'intérieur de la boucle (instruction for) :

Comme vous pouvez le voir, Eclipse nous a immédiatement signalé l'erreur que la variable j, déclaré à la ligne 15, n'est pas visible en dehors de la boucle car sa portée, ou portée, s'étend uniquement au corps de la boucle dans laquelle il a été déclaré.

Pour que le programme fonctionne, vous devez commenter la ligne 19.

La sortie de ce code est similaire à la sortie du code que nous venons d'examiner, sauf qu'au lieu de « Bonjour », il affiche « Bonjour ». Eh bien, après la boucle, il n'est pas possible d'afficher la valeur d'une variable j.

Lors de la déclaration d'une variable dans une boucle pour il faut rappeler la circonstance importante suivante : la superficie et la durée de vie de cette variable coïncident complètement avec la superficie et l'époque d'existence de l'opérateur pour .

Syntaxe de boucle pour ne se limite pas aux boucles avec une seule variable. Comme dans l'expression initialisation , et dans l'expression répétitions peut être utilisé virgule pour séparer plusieurs expressions initialisation Et répétitions .

Par exemple:

Dans cet exemple en initialisation une partie de la boucle, nous définissons les valeurs initiales des deux variables de contrôle un Et b. Les deux déclarations séparées par des virgules dans itératif les parties sont exécutées à chaque fois que la boucle est répétée.

Ce code génère la sortie suivante :

Faire du vélo pour prend en charge plusieurs saveurs qui améliorent ses capacités et son applicabilité. La flexibilité de ce cycle tient au fait qu’il comprend trois parties : initialisation , vérification des conditions Et itératif ne doit pas être utilisé uniquement aux fins prévues. En fait, chacune des sections de la déclaration pour peut être utilisé à n'importe quelle fin. Par exemple:

L’exemple est bien sûr un peu déroutant, mais au fond il est simple. La première partie de l'instruction initialise la variable b, le second le vérifie et le troisième affiche un message sur la console.

Essentiellement, ce programme fait la même chose en saluant les arguments s'ils existent. S’ils ne sont pas là, cela ne produit rien. Permettez-moi immédiatement de donner un exemple de son résultat :

Comme le montre la sortie de ce programme, la partie itération est exécutée, comme déjà mentionné, après l'exécution du corps de la boucle. Dans ce cas c'est l'opérateur imprimer à la ligne 9. L'instruction for dans ce code s'étend sur deux lignes 9 et 10 car elle est assez longue. J'ai fait cela pour démontrer que chaque partie de l'instruction for peut être utilisée à des fins différentes. Il convient également de noter que l'incrément de la variable je se produit à la ligne 12 et définit également une condition pour continuer ou quitter la boucle, qui est vérifiée à la ligne 9.

Un autre exemple similaire, une boucle for peut être utilisée pour parcourir les éléments d'une liste chaînée :

Il convient également de noter que n'importe quelle partie du cycle pour (initialisation, condition Et itératif) ou vous pouvez même tout sauter. Par exemple, vous pouvez créer une boucle infinie de cette façon :

( ;; ){
//cycle sans fin
}

Une expression d'initialisation ou d'itération, ou les deux, peut être manquante :

Dans cet exemple initialisation Et itératif les expressions sont déplacées en dehors de la définition de l'opérateur pour. En conséquence, les parties correspondantes de la déclaration pour vide.

Pour rendre plus claire la séquence d'exécution des parties de l'instruction for, je vais donner un petit exemple. Bien que nous n'ayons pas encore étudié les méthodes, j'espère que vous comprendrez l'idée de​​ce programme. Son objectif est de montrer clairement la séquence d'exécution de toutes les parties de l'instruction for.

D'après le résultat du programme, il est clair que initialisation partie du programme ( Méthode initTest()) n'est exécuté qu'une seule fois.

Ensuite le contrôle est effectué conditions , représenté par la méthode condTest().

Après vérification conditions , exécuté corps faire du vélo.

Et après ça la partie est exécutée répétition , représenté par la méthode recTest().

La méthode condTest() vérifie la condition de continuation de la boucle. Dans ce cas, la variable i est comparée à 4, et tant que la variable i est inférieure à 4, le corps de la boucle est exécuté.

Le corps de la boucle est exécuté quatre fois puisque la variable i a été initialisée à zéro par défaut.

Opérateur pour chaque

À partir du JDK 5, Java peut utiliser une deuxième forme de boucle for, qui implémente une boucle dans le style pour chaque ("pour chaque"). Faites du vélo avec style pour chaque est destiné à l'exécution strictement séquentielle d'actions répétées en relation avec des collections d'objets, telles que des tableaux. En Java, la possibilité d'utiliser une boucle pour chaque mis en œuvre en améliorant le cycle pour. Formulaire version générale pour chaque faire du vélo pour a la forme suivante :

pour (type de variable d'itération : collection) instructions de bloc

Taper c'est le type de la variable, variable d'itération — le nom d'une variable itérative qui prendra séquentiellement les valeurs de collections , du premier au dernier. L'élément de collection spécifie la collection sur laquelle effectuer une boucle. Avec cycle pour peut être utilisé Divers types collections, mais pour l'instant, nous n'utiliserons que des tableaux, d'ailleurs, que nous n'avons pas encore essayés, mais au moins il y a déjà eu de nombreux exemples avec des salutations à partir d'un tableau de chaînes, où vont les arguments de ligne de commande.

Sur une note : opérateur pour chaque s'applique aux tableaux et aux classes qui implémentent l'interface java.lang.Iterable.

A chaque itération de la boucle, le programme récupère l'élément suivant de la collection et le stocke dans une variable d'itération. La boucle s'exécute jusqu'à ce que tous les éléments de la collection aient été récupérés.

Même si le cycle se répète pour dans le style pour chaque est exécuté jusqu'à ce que tous les éléments du tableau (collection) aient été traités ; la boucle peut être interrompue plus tôt à l'aide de l'opérateur casser.

Parce qu'une variable d'itération reçoit des valeurs d'une collection, son type doit correspondre (ou être compatible avec) le type des éléments stockés dans la collection. Ainsi, lors d'une boucle sur des tableaux, le type doit être compatible avec le type sous-jacent du tableau.

Comprendre la motivation pour utiliser des boucles dans le style pour chaque , considérez le type de cycle pour, que ce style est destiné à remplacer.

Reprenons notre exemple de salutation des arguments depuis la ligne de commande :

N'est-ce pas beaucoup plus élégant que d'utiliser d'autres opérateurs de boucle à cette fin ?

En fait, ce programme a un résultat simple :

Nous l'avons déjà vu à plusieurs reprises dans différentes options, mais la répétition est la mère de l’apprentissage.

Pour plus de clarté, regardons quelques exemples supplémentaires.

Chaque fois que la boucle passe, la variable x se voit automatiquement attribuer une valeur égale à la valeur de l'élément suivant du tableau nums. Ainsi, à la première itération x contient 1, à la seconde - 2, etc. Cela simplifie la syntaxe du programme et élimine la possibilité d'aller au-delà du tableau.

Le résultat de cette partie du programme est :

Même si le cycle se répète pour dans le style pour chaque est exécuté jusqu'à ce que tous les éléments du tableau aient été traités ; la boucle peut être interrompue plus tôt à l'aide de l'opérateur casser. Par exemple:

DANS dans cet exemple la boucle n'exécutera que trois itérations, après quoi la boucle se terminera selon la condition de l'opérateur si, ce qui déclenchera l'opérateur casser.

Il est également important de comprendre que la variable d'itération reçoit les valeurs de la collection (tableau) à chaque itération. Par conséquent, même si sa valeur est modifiée dans le corps de la boucle, à l'itération suivante, elle prendra à nouveau la suivante. valeur de la collection. De plus, ses modifications n'affectent en rien les valeurs de la collection (éléments du tableau dans cet exemple).

Ce code affichera ce qui suit :

Toute méthode qui renvoie un tableau peut être utilisée avec pour chaque . Par exemple, la classe String contient une méthode toCharArray qui renvoie un tableau de caractères. Exemple:

Ce code imprimera simplement la chaîne Hello World!

C'est là que nous pouvons en finir avec ces opérateurs. La seule chose qui mérite d'être mentionnée est que dans la partie initialisation, vous ne pouvez déclarer que des variables du même type, ou initialiser des variables. différents types, mais tel qu'on peut le réduire à un type général selon la règle de transtypage que nous avons examinée plus tôt.

Enfin, je vais donner quelques exemples supplémentaires d'opérateur avancé pour. Dans l'ensemble, il ne s'agit que d'un code refactorisé de l'exemple que j'ai déjà donné.

N'est-il pas vrai que ce code est devenu plus lisible et compréhensible que celui que j'ai déjà fourni ? Ou ce n'est pas clair ? Eh bien, regardons un autre exemple de code qui fait la même chose.

N'est-ce pas encore clair ?

Ces deux codes produisent le même résultat :

Bien entendu, à condition que les arguments avancés ligne de commande il y avait Vasya et Petya.

Cela se termine avec l'opérateur for et son ombre foreach.

Une boucle Java While Do est une instruction qui vous permet d'exécuter le même morceau de code plusieurs fois. Cette boucle peut être utilisée pour répéter des actions lorsque les conditions sont remplies.

Boucle while

La boucle while est la plus simple à construire dans le langage Java. Il se compose d'une clé while, d'une condition de boucle et d'un corps de boucle :

while (condition) ( // corps de la boucle)

Chaque exécution distincte du corps de la boucle est considérée comme une itération. Avant chaque itération, les conditions de boucle sont évaluées. Son corps n'est exécuté que si la condition de boucle est évaluée à true .

Les itérations de la boucle changent quelque chose et, à un certain moment, l'évaluation de la condition renvoie false , auquel cas la boucle se termine. Une boucle dont la condition ne renvoie jamais false est exécutée un nombre infini de fois. De tels cycles sont appelés sans fin.

Exemple

numéro int = 0 ; tandis que (numéro< 10) { System.out.println(num); num++; }

Cet exemple imprime les nombres de 0 à 9. Passons en revue le code étape par étape. Nous initialisons d’abord la variable num avec une valeur de 0. Ce sera le compteur de boucles. Lorsque le programme atteint while , les conditions de la boucle sont évaluées. Dans notre cas 0< 10 возвращает значение true и исполняется тело цикла. Внутри цикла выводится переменная num , а затем увеличивается на 1 . На этом завершается первая итерация.

Après la première "exécution", la condition de la boucle Java While est évaluée une seconde fois. 1< 10 по-прежнему возвращает true , после чего запускается следующая итерация цикла. Один и тот же процесс повторяется несколько раз.

L'itération finale commence lorsque la valeur de num est égale à 9 . Le compteur de boucle s'affiche une dernière fois et la valeur est incrémentée jusqu'à 10. Cette fois, une nouvelle itération ne peut pas être démarrée car la condition de boucle est évaluée à false . Puisque 10 n’est pas inférieur à 10.

Ainsi, la boucle s’exécute tant que la condition de boucle est satisfaite. Armé de ces connaissances, vous pouvez créer des boucles plus complexes et fonctionnelles. Parcourons le tableau :

Noms de chaîne = ("Doc", "Dopey", "Timide", "Grumpy", "Sneezy", "Sleepy", "Happy"); indice int = 0 ; tandis que (index< names.length) { System.out.println(names); index++; }

Le concept de cet exemple est similaire au précédent. Nous initialisons le compteur de boucles et parcourons le tableau jusqu'à ce que tous les éléments soient imprimés. Par conséquent, itérer sur des tableaux est un cas assez courant, et Java a une meilleure construction pour cela : la boucle For.

faire une boucle en attendant

La boucle Java while do est similaire à while , mais présente une différence significative : contrairement à while , la condition est vérifiée à la fin de chaque itération. Cela signifie que faire une boucle en attendant toujours exécuté au moins une fois :

do ( // corps de la boucle ) while (condition);

Exemple

do-while exécute d'abord le corps de la boucle, puis évalue ses conditions. En fonction du résultat obtenu, la boucle s'arrête ou l'itération suivante démarre. considérons jeu simple"devinez le nom":

Scanner scanner = nouveau scanner (System.in); Devinette de chaîne ; do ( System.out.print("Devinez le nom : "); supposez = scanner.nextLine(); ) while (!"Daffy Duck".equals(devinez)); System.out.println("Félicitations ! Vous avez deviné mon nom !");

Ceci tandis que l'exemple Java utilise Scanner pour analyser les entrées de system.ini . Ce canal standard entrée, qui dans la plupart des cas interagit avec le clavier. En termes simples, nous lisons simplement le texte que le joueur saisit.

Dans le jeu, vous devez demander à l'utilisateur au moins une fois, et ce tant que le joueur entre les bonnes réponses. La boucle do-while est idéale pour de tels cas. Dans le corps de la boucle, nous obtenons la valeur utilisateur puis vérifions l'exactitude de la réponse. La boucle doit s'exécuter jusqu'à ce que la valeur saisie par l'utilisateur soit égale à Daffy Duck. Si la bonne réponse est reçue, la boucle s'arrête et nous félicitons le joueur pour sa victoire.

En conclusion

Les boucles while true de Java vous permettent de réutiliser des morceaux de code plusieurs fois. Aujourd'hui, nous avons découvert les boucles Java while et do-while. Ils sont similaires dans le sens où ils vérifient les conditions et exécutent le corps de la boucle si la condition est évaluée à true . Mais ils ont une différence significative : la condition boucle while est vérifiée avant l'itération, et la condition de boucle do-while est vérifiée à la fin de chaque itération. Cela signifie que la boucle do-while est toujours exécutée au moins une fois.

Traduction de l’article « Les boucles While et Do-While de Java en cinq minutes» a été préparé par l’équipe sympathique du projet.

Java, comme presque tous les langages de programmation, dispose d'outils permettant de garantir qu'un certain morceau de code est répété plusieurs fois, ou boucles, comme on les appelle communément. Les boucles en Java sont représentées par des instructions telles que for et while, ainsi que leurs variantes. En règle générale, les boucles sont utilisées pour parcourir des tableaux unidimensionnels et multidimensionnels et des structures de données itérables (y compris les collections) afin de trouver certains éléments et d'effectuer des opérations ultérieures sur eux. Cependant, ce n’est pas la seule façon d’utiliser un outil comme la boucle Java. Des exemples d’utilisation seront fournis au fur et à mesure de leur révision.

Java : description et exemples

L'opérateur de boucle fondamental en Java est while. Le fragment de code enfermé dans son corps sera répété jusqu'à ce que la condition de l'expression entre parenthèses après avoir satisfait la valeur logique de la vérité. La forme générale de l'instruction while est la suivante :

pendant que(condition) (

//corps de la boucle

Dès que la valeur de la condition logique cesse d'être vraie, le code inclus dans le corps de la boucle cessera de s'exécuter et le contrôle sera transféré à la ligne qui le suit immédiatement.

Si le corps de la boucle ne contient qu'une seule instruction, les accolades peuvent être omises, mais cela est considéré comme une bonne forme si elles sont toujours présentes. La figure ci-dessus montre un schéma fonctionnel du fonctionnement de cet opérateur.

Pour plus de clarté, regardons l'exemple présenté dans la figure ci-dessous :

La variable déclarée count a initialement la valeur 1. Ensuite, nous voyons une expression logique entre parenthèses après le nom de l'opérateur. Ce sera vrai, c'est-à-dire renvoie true tant que la valeur de la variable count est inférieure ou égale à 10. Dans le corps de la boucle, à chaque passage (itération), la valeur de la variable est augmentée de 1 et affichée sur l'écran de la console. Notez que lorsque la variable atteint 11, la boucle s'arrête.

Si la valeur de la variable count était initialement égale à 11, alors la condition de boucle serait fausse et le programme n'entrerait même pas dans son corps.

Il convient de noter que la syntaxe Java vous permet d'utiliser une instruction while sans corps. Donnons un exemple. Disons que nous avons deux variables i = 100 et j = 200, nous sommes confrontés à la tâche de calculer par programme leur moyenne arithmétique - pour cela, nous pouvons utiliser le « creux » while :

pendant que(++i< --j);

En conséquence, la valeur de l’une des deux variables sera égale à la moyenne de leurs valeurs d’origine. Comme vous pouvez le voir, la boucle a parfaitement fonctionné sans corps et a tout complété actions nécessaires en termes conditionnels.

faire une boucle en attendant

Dans les exemples précédents, si l'expression conditionnelle renvoyait initialement false, alors l'exécution du programme ignorerait le corps de la boucle et continuerait. Cependant, il arrive souvent que l'exécution du code contenu dans le corps de la boucle soit requise au moins une fois, quelle que soit la véracité de l'expression conditionnelle. En d'autres termes, il arrive que vérifier la véracité d'une expression conditionnelle ne soit pas nécessaire au début, mais à la fin de la boucle. Une variante de la boucle while appelée do-while peut fournir cette fonctionnalité. Il a la forme suivante :

faire(
//corps de la boucle

) tandis que(condition);

Comme nous pouvons le voir, le corps de la boucle est d'abord exécuté, puis seulement la véracité de la condition est vérifiée - et ainsi de suite à chaque itération.

Le code ci-dessus fonctionnera à peu près de la même manière qu'avec un while normal. Cependant, si nous définissons count sur 11, le corps de la boucle sera quand même exécuté une fois avant que l'instruction puisse tester la véracité de l'expression.

Description et exemples de la boucle for-Java

Représente une forme de langage universelle et efficace en Java. Jusqu'au cinquième Versions Java Le SDK n'avait qu'une seule forme traditionnelle de l'opérateur for, puis une nouvelle est apparue - pour chacun. Dans cette section, nous examinerons la forme traditionnelle de l'opérateur. pour Java, la boucle ressemble à ceci :

Avant que le contrôle ne soit transféré au code dans le corps de la boucle, la variable i, qui fait office de compteur, est d'abord initialisée. Ensuite, une expression conditionnelle est vérifiée pour comparer le compteur à une valeur spécifique, et si elle renvoie vrai, le corps de la boucle est exécuté. Ensuite, la valeur du compteur est modifiée d'un pas prédéterminé et l'expression conditionnelle est à nouveau vérifiée, et ainsi de suite jusqu'à ce que la condition devienne fausse. L'organigramme ci-dessous illustre toutes les étapes du cycle.

Pour une meilleure compréhension, voici un exemple du fonctionnement d’une boucle for Java :

On voit que la variable loopVal est utilisée comme compteur. Après chaque itération de la boucle, sa valeur incrémentera de 1, et cela continuera jusqu'à ce qu'elle atteigne 11. Notez qu'une variable de contrôle peut être déclarée en dehors d'une instruction for, mais si vous n'avez pas l'intention d'utiliser cette variable ailleurs que dans une boucle, il est recommandé de le déclarer directement dans l'instruction. Gardez à l'esprit qu'une variable déclarée dans l'instruction elle-même a une portée dans cette même boucle.

Il existe des situations où vous devez déclarer plusieurs variables de contrôle de boucle. Pour Java, une boucle vous permet de spécifier deux ou plusieurs variables séparées par des virgules, et ce à la fois lors de leur initialisation et lors de leur itération. Un tel opérateur ressemblera à ceci :

pour (int je = 1, int j = 10; je< j; ++i, --j) {}

À chaque itération, la valeur de la variable i augmentera de 1 et la valeur de la variable j diminuera de 1. Les itérations seront effectuées jusqu'à ce que i devienne supérieur ou égal à j.

Caractéristiques de l'utilisation de l'opérateur for

La boucle for est une conception assez flexible car ses trois parties (initialisation, condition et incrémentation/décrémentation) peuvent être utilisées à d'autres fins. Par exemple, au lieu d'une expression conditionnelle par une variable de contrôle, vous pouvez remplacer n'importe quelle variable logique.

sortie booléenne = faux ;

pour (int i = 0; !exit; ++i) (

Dans l'exemple ci-dessus, on peut observer comment le fonctionnement de la boucle est absolument indépendant de la variable de contrôle i et le nombre d'itérations dépend uniquement du moment où la variable de sortie devient vraie. De plus, la variable de contrôle peut être complètement supprimée de la boucle et cela n'affectera en rien son fonctionnement : for(; !exit;) (). Même si ce n’est pas la façon la plus intelligente de programmer, cela peut parfois s’avérer utile. L'essentiel est de prévoir une situation dans laquelle la variable prendra la valeur nécessaire pour sortir de la boucle, afin de ne pas la transformer en une boucle infinie.

Pour Java, une boucle peut également être déclarée de cette manière : for(; ;) (). Il s'agit d'un exemple typique de boucle infinie avec des conditions d'interruption particulières. Nous parlerons de la façon d'interrompre ce genre de cycles un peu plus tard.

Pour chaque boucle de style

La boucle Java foreach est toujours utilisée pour parcourir séquentiellement les éléments d'un tableau ou de tout autre et effectuer certaines opérations répétitives sur eux. Un exemple de cette forme de l'instruction for est présenté ci-dessous :

Le nom est déclaré comme une variable itérative et le tableau de noms de chaînes précédemment déclaré agit comme deuxième argument de l'opérateur. Le nom de la variable prendra tour à tour les valeurs de chaque élément du tableau jusqu'à ce que tous ses éléments aient été récupérés. Il est à noter que le type de la variable doit être compatible avec le type des éléments stockés dans le tableau. De plus, la variable name est en lecture seule et tenter de la modifier ne modifiera pas l'élément du tableau lui-même.

Instructions d'interruption de boucle

Il existe trois instructions d'interruption de boucle : break, return et continue. Les deux premiers sont capables d'interrompre complètement la boucle, tandis que continue n'interrompt que l'itération en cours. Si vous utilisez une boucle volontairement infinie en Java dans votre code, ces opérateurs doivent y être présents. Regardons un exemple simple d'utilisation de break :

Bien que cette instruction for comporte 11 itérations, seules 8 seront exécutées, car lorsque le compte i est égal à 7, la condition qui contient l'instruction break sera déclenchée.

L'instruction return fonctionne de la même manière, à la différence qu'elle permet non seulement de sortir de la boucle Java, mais également de la méthode dans laquelle la boucle est placée.

Utiliser break comme goto

Il convient de garder à l'esprit que la rupture n'interrompt que la boucle dans le corps de laquelle elle se trouve directement, c'est-à-dire si vous l'utilisez dans une boucle imbriquée, la boucle externe ne cessera pas de s'exécuter. Pour ce faire, l'instruction break peut être utilisée comme une forme civilisée de goto.

Dans cette version cet opérateur utilisé en conjonction avec une étiquette, qui permet d'organiser une sortie non seulement des boucles, mais aussi de n'importe quel bloc de code. Une étiquette est un identifiant nommé de manière appropriée suivi de deux points. L'étiquette est déclarée au début du bloc de code marqué. Pour interrompre l'exécution d'un bloc marqué, dans la bonne place doit être déclaré : break label_name. Prenons l'exemple de la figure ci-dessous :

Le code déclare trois blocs avec les noms d'étiquettes One, Two et Three, respectivement. L'instruction break intitulée Deux est imbriquée dans les trois blocs, mais lorsqu'elle se déclenche, le programme quittera les blocs trois et deux et poursuivra son exécution dans le bloc un. Ceux. dans la console, nous verrons deux messages : Trois et Un.

Conclusion

Nous avons découvert le concept de boucles en Java, les principales instructions while et for, ainsi que leurs formes do while et for each, respectivement. Pour une meilleure compréhension, nous vous recommandons de faire des exercices utilisant ces opérateurs dans Formes variées, et de diverses façons leur interruption et leur passage d'un bloc à l'autre.

pour la boucle

Depuis JDK 5, il existe deux formes de boucle for en Java. La première est la forme traditionnelle, utilisée depuis la version originale de Java. Le second est le nouveau formulaire « pour chaque ». Nous examinerons les deux types de boucles for, en commençant par la forme traditionnelle.

La forme générale d’une instruction for traditionnelle est la suivante :

pour (initialisation; condition; répétition)
( // corps
}

Si une seule instruction doit être répétée dans une boucle, vous pouvez omettre les accolades.

La boucle for fonctionne comme suit. Lorsque la boucle est lancée pour la première fois, le programme effectue la partie initialisation de la boucle. En général, il s'agit d'une expression qui définit la valeur d'une variable de contrôle de boucle, qui agit comme un compteur contrôlant la boucle. Il est important de comprendre que l’expression d’initialisation n’est exécutée qu’une seule fois. Le programme évalue ensuite la condition, qui doit être une expression booléenne. En règle générale, l'expression compare la valeur d'une variable de contrôle avec une valeur cible. Si cette valeur est vraie, le programme exécute le corps de la boucle. Si c'est faux, l'exécution de la boucle est interrompue. Le programme exécute ensuite la partie répétition de la boucle. Il s'agit généralement d'une expression qui augmente ou diminue la valeur d'une variable de contrôle. Le programme répète ensuite la boucle, chaque fois qu'il passe en évaluant d'abord l'expression conditionnelle, puis en exécutant le corps de la boucle et en exécutant l'expression répétée. Le processus est répété jusqu'à ce que l'expression répétée soit évaluée comme fausse.

Vous trouverez ci-dessous une version du programme de comptage d'horloge qui utilise une boucle for.

// Démonstration de l'utilisation d'une boucle for.
classe ForTick (

entier n;
pour(n=10; n>0; n-)

}
}

Déclaration de variables de contrôle de boucle dans une boucle for

Souvent, la variable qui contrôle une boucle for n'est nécessaire que pour cette boucle et n'est utilisée nulle part ailleurs. Dans ce cas, la variable peut être déclarée dans la partie initialisation de l'instruction for. Par exemple, programme précédent peut être réécrit en déclarant une variable de contrôle de type int dans une boucle for :

// Déclaration d'une variable de contrôle de boucle dans une boucle for.
classe ForTick (public static void main (String args) (
//dans ce cas, la variable n est déclarée dans la boucle for
pour(int n=10; n>0; n-)
System.out.println("battement " + n) ;
}
}

Lorsque vous déclarez une variable dans une boucle for, vous devez vous rappeler la circonstance importante suivante : la portée et la durée de vie de cette variable sont complètement les mêmes que la portée et la durée de vie de l'instruction for. (C'est-à-dire que la portée d'existence de la variable est limitée à la boucle for.) En dehors de la boucle for, la variable cessera d'exister. Si une variable de contrôle de boucle doit être utilisée dans d’autres parties du programme, elle ne peut pas être déclarée dans une boucle for.

Dans les cas où une variable de contrôle de boucle n'est nécessaire nulle part ailleurs, la plupart des programmeurs Java préfèrent la déclarer dans une instruction for. A titre d'exemple, donnons un programme simple, qui vérifie si le nombre saisi est premier. Notez que la variable de contrôle de boucle i est déclarée dans la boucle for car elle n'est nécessaire nulle part ailleurs.

Variations de la boucle for

La boucle for se décline en plusieurs variantes qui augmentent ses capacités et son applicabilité. La flexibilité de cette boucle est due au fait que ses trois parties : initialisation, vérification des conditions et itération ne doivent pas être utilisées uniquement aux fins prévues. En fait, chaque section de l'instruction for peut être utilisée à n'importe quelle fin. Regardons quelques exemples.

L’une des variantes les plus courantes implique l’utilisation d’une expression conditionnelle. En particulier, cette expression n'a pas besoin de comparer la variable de contrôle de la boucle avec une valeur cible. En fait, la condition pilotant une boucle for peut être n’importe quelle expression booléenne. Par exemple, considérons l'extrait suivant :

booléen done = faux ;
pour(int i=1; !done; i++) (
// ...
if(interrupted()) done = true;
}

Dans cet exemple, la boucle for continue jusqu'à ce que done soit défini sur true. Dans cette boucle, la valeur de la variable de contrôle de boucle i n'est pas vérifiée.

Voici une autre variante de la boucle for. En laissant les trois parties de l'instruction vides, vous pouvez intentionnellement créer une boucle infinie (une boucle qui ne se termine jamais). Par exemple:

pour(; ;) (
// ...
}

Cette boucle peut s’exécuter indéfiniment car aucune condition ne pourrait entraîner son interruption. Bien que certains programmes, comme les processeurs de commandes système opérateur, nécessitent une boucle infinie, la plupart des "boucles infinies" ne sont en réalité que des boucles avec des conditions d'interruption spéciales. Comme vous le verrez bientôt, il existe un moyen de rompre une boucle - même une boucle infinie comme cet exemple - qui ne nécessite pas l'utilisation d'une boucle conditionnelle normale.

La version "for-each" de la boucle for

À partir du JDK 5, Java vous permet d'utiliser une deuxième forme de boucle for, qui implémente une boucle de style "for-each". Comme vous le savez peut-être, le concept de boucles « pour chaque » devient de plus en plus courant dans la théorie moderne des langages de programmation et devient rapidement la norme. Fonctionnalité dans de nombreuses langues. Une boucle de style for-each est conçue pour effectuer des actions répétées sur une collection d'objets, comme un tableau, de manière strictement séquentielle. Contrairement à certains langages comme C#, qui utilisent des boucles "for-each" pour implémenter mot-clé foreach, en Java, la possibilité d'utiliser une boucle for-each est implémentée en améliorant la boucle for. L’avantage de cette approche est qu’aucun mot-clé supplémentaire n’est requis pour l’implémenter et qu’aucun code préexistant n’est cassé. La boucle for de style for-each est également appelée boucle for améliorée. La forme générale de la version "for-each" d'une boucle for est :

pour (tapez iter-per: collection)
opérateurs de bloc

Ici, type indique le type, et iter-per est le nom de la variable d'itération qui prendra séquentiellement les valeurs de la collection, du premier au dernier. L'élément de collection spécifie la collection sur laquelle effectuer une boucle. Il existe de nombreux types de collections que vous pouvez utiliser avec une boucle for, mais dans ce chapitre, nous n'utiliserons que des tableaux. (D'autres types de collections pouvant être utilisées avec une boucle for, telles que celles définies dans Collection Framework, sont abordées dans les chapitres suivants du livre.) À chaque itération de la boucle, le programme récupère l'élément suivant de la collection et le stocke dans la variable iter. La boucle s'exécute jusqu'à ce que tous les éléments de la collection aient été récupérés.

Étant donné qu'une variable d'itération reçoit des valeurs d'une collection, le type doit correspondre (ou être compatible avec) le type des éléments stockés dans la collection. Ainsi, lors d'une boucle sur des tableaux, le type doit être compatible avec le type sous-jacent du tableau.

Le style for-each pour la boucle vous permet d'automatiser ce processus. En particulier, l'utilisation d'une telle boucle permet d'éviter de définir la valeur du compteur de boucle en spécifiant ses valeurs initiales et finales, et élimine le besoin d'indexer manuellement le tableau. Au lieu de cela, le programme parcourt automatiquement l'ensemble du tableau, obtenant les valeurs de chacun de ses éléments de manière séquentielle, du premier au dernier. Par exemple, étant donné la version « for-each » de la boucle for, le fragment précédent pourrait être réécrit comme suit :

nombres int = ( 1, 2, 3, 4, 5, b, 7, 8, 9, 10 );
somme entière = 0 ;
for(int x: nums) sum += x;

Chaque fois que la boucle passe, la variable x se voit automatiquement attribuer une valeur égale à la valeur de l'élément suivant du tableau nums. Ainsi, à la première itération x contient 1, à la seconde - 2, etc. Cela simplifie non seulement la syntaxe du programme, mais élimine également la possibilité d'erreurs hors limites du tableau.

Ci-dessous un exemple programme complet, illustrant l'utilisation de la version "for-each" décrite de la boucle for.

// Utilisation d'une boucle for dans le style for-each.
classe PourEach(
public static void main (arguments de chaîne) (

somme entière = 0 ;
// utilise le style for-each pour afficher et additionner les valeurs
pour(int x: nombres) (

somme += x ;
}
System.out.println("La somme est : " + somme) ;
}
}

La valeur est : 1
La valeur est : 2
La valeur est : 3
La valeur est : 4
La valeur est : 5
La valeur est : 6
La valeur est : 7
La valeur est : 8
La valeur est : 9
La valeur est : 10
Le montant est de : 55

Comme le montre cette conclusion, pour déclaration Le style "for-each" parcourt automatiquement les éléments du tableau, de l'index le plus bas au plus élevé.

Bien que le style for-each de la boucle se répète jusqu'à ce que tous les éléments du tableau aient été traités, la boucle peut être interrompue plus tôt à l'aide d'une instruction break. Par exemple, le programme suivant additionne les valeurs des cinq premiers éléments du tableau nums.

// Utilisation d'une instruction break dans une boucle for dans le style for-each.
classe ForEach2 (
public static void main (arguments de chaîne) (
somme entière = 0 ;
nombres int = ( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 );
// utilise une boucle for pour afficher et additionner les valeurs
pour(int x: nombres) (
System.out.println("La valeur est : " + x) ;
somme += x ; v si (x == 5) pause ; // arrête la boucle après avoir reçu 5 valeurs
}
System.out.println("La somme des cinq premiers éléments est : " + somme);
}
}

Le programme génère la sortie suivante :

La valeur est : 1
La valeur est : 2
La valeur est : 3
La valeur est : 4
La valeur est : 5
La somme des cinq premiers éléments est : 15

Comme vous pouvez le voir, la boucle arrête l'exécution après avoir reçu la valeur du cinquième élément. L'instruction break peut également être utilisée avec d'autres boucles Java. Cet opérateur sera discuté plus en détail dans les sections suivantes de ce chapitre.

Lorsque vous utilisez une boucle for-each, il y a une chose importante à garder à l’esprit : Sa variable d'itération est une variable en lecture seule car elle est associée uniquement au tableau d'origine. L'opération d'attribution d'une valeur à une variable itérative n'a aucun effet sur le tableau d'origine. En d’autres termes, le contenu d’un tableau ne peut pas être modifié en attribuant une nouvelle valeur à une variable d’itération. Par exemple, considérons le programme suivant :

// La variable de boucle for-each est en lecture seule.
classe NoChange (
public static void main (arguments de chaîne) (
nombres int = ( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 );
pour(int x: nombres) (
System.out.print(x + " ");
x=x*10 ; // cet opérateur n'a aucun effet sur le tableau nums
}
System.out.println();
pour (int x : nombres)
System.out.print(x + " ");
System.out.println();
}
}

La première boucle for incrémente la valeur de la variable d'itération de 10. Cependant, cette opération d'affectation n'a aucun effet sur le tableau nums d'origine, comme on peut le voir dans la sortie de la seconde instruction for. La sortie générée par le programme le confirme :

1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10

Itération dans des tableaux multidimensionnels

Une version améliorée de la boucle for s'applique également aux tableaux multidimensionnels. Cependant, gardez à l’esprit qu’en Java, les tableaux multidimensionnels sont constitués de tableaux de tableaux. (Par exemple, un tableau à deux dimensions est un tableau de tableaux à une dimension.) Ceci est important lors d'une itération sur un tableau multidimensionnel, car le résultat de chaque itération est le tableau suivant, et non le tableau suivant. élément séparé. De plus, le type de la variable d'itération de la boucle for doit être compatible avec le type du tableau résultant. Par exemple, dans le cas tableau bidimensionnel la variable d'itération doit être une référence à tableau unidimensionnel. En général, lorsque vous utilisez une boucle for-each pour parcourir un tableau de taille N, les objets résultants seront des tableaux de taille N-1. Pour comprendre ce qui en découle, considérons le programme suivant. Il utilise des boucles for imbriquées pour obtenir des éléments ordonnés par lignes d'un tableau à deux dimensions.

// Utilisation d'une boucle for de style for-each sur un tableau à deux dimensions.
classe ForEach3 (
public static void main (arguments de chaîne) (
somme entière = 0 ;
int nums = nouveau int ;
// attribution de valeurs aux éléments du tableau nums
for (int i = 0; i nums[i] [j] = (i+l)*(j+l) ; // utilise un style for-each pour la boucle pour afficher
// et additionner les valeurs
pour (int x : nombres) (
pour (int y : x) (
System.out.println("La valeur est : " + y);
somme += y ;
}
}
System.out.println("Somme : " + somme);
}

Ce programme génère le résultat suivant :

La valeur est : 1
La valeur est : 2
La valeur est : 3
La valeur est : 4
La valeur est : 5
La valeur est : 2
La valeur est : 4
La valeur est : 6
La valeur est : 8
La valeur est : 10
La valeur est : 3
La valeur est : 6
La valeur est : 9
La valeur est : 12
La valeur est : 15
Montant : 9 0

La ligne suivante de ce programme mérite une attention particulière :

pour (int x : nombres) (

Faites attention à la façon dont la variable x est déclarée. Cette variable est une référence à un tableau unidimensionnel de valeurs entières. Ceci est nécessaire car le résultat de chaque itération de la boucle for est le tableau suivant du tableau nums, en commençant par le tableau spécifié par l'élément nums. La boucle for interne parcourt ensuite chacun de ces tableaux, affichant les valeurs de chaque élément.

Utilisation d'une boucle For améliorée

Étant donné que chaque instruction for de style for-each ne peut parcourir les éléments d'un tableau que de manière séquentielle, en commençant par le premier et en terminant par le dernier, son utilité peut sembler limitée. Cependant, ce n’est pas le cas. De nombreux algorithmes nécessitent l’utilisation de ce mécanisme particulier. L'un des algorithmes les plus couramment utilisés est la recherche. Par exemple, le programme suivant utilise une boucle for pour rechercher une valeur dans un tableau non ordonné. La recherche s'arrête lorsque la valeur recherchée est trouvée.

// Recherchez le tableau en utilisant une boucle for de style for-each.
recherche de classe (
public static void main (arguments de chaîne) (
nombres int = ( 6, 8, 3, 7, 5, 6, 1, 4 );
valeur int =5 ;
booléen trouvé = faux ;
// utiliser la boucle for dans le style for-each
pour (int x : nombres) (
si (x == val) (
trouvé = vrai ;
casser;
}
}
si trouvé)
System.out.println("Valeur trouvée!");)

Dans ce cas, choisir le style "for-each" pour la boucle for est tout à fait justifié, car la recherche dans un tableau non ordonné implique de parcourir chaque élément de manière séquentielle. (Bien sûr, si le tableau était ordonné, une recherche binaire pourrait être utilisée, ce qui nécessiterait l'implémentation d'un style de boucle différent.) D'autres types d'applications qui bénéficient des boucles for-each incluent la moyenne, la recherche de valeur minimale ou maximale dans un ensemble, rechercher des doublons, etc.



Un cycle est un fragment d'un programme qui se répète plusieurs fois.

Il existe deux types de boucles en Java : le type « while » et le type « n-time ».

Le premier type de « pendant » est conçu pour répéter une action tant qu’une certaine condition est remplie. Exemple : augmenter un nombre de 5 jusqu'à ce qu'il atteigne trois chiffres.

Le deuxième type « n-time » est destiné à répéter certaines actions un nombre de fois prédéterminé. Exemple : multipliez un nombre par lui-même 4 fois.

Boucle While (instructions while et do... while)

L'instruction while répète les actions spécifiées tant que son paramètre est vrai.

Par exemple, une telle boucle sera exécutée 4 fois, et « 1 2 3 4 » s'affichera à l'écran :

Int je = 1 ; alors que je< 5) { System.out.print(i + " "); i++; }

Une telle boucle ne sera pas exécutée une seule fois et rien ne sera affiché à l'écran :

Int je = 1 ; alors que je< 0) { System.out.print(i + " "); i++; }

Cette boucle s'exécutera sans fin et l'écran affichera « 1 2 3 4 5 6 7... » :

Int je = 1 ; while (true) ( ​​​​System.out.print(i + " "); i++; )

La condition qui détermine si la boucle sera répétée à nouveau est vérifiée avant chaque étape de la boucle, y compris la toute première. Ils disent ce qui se passe pré-vérification conditions.

Il y a un cycle comme « au revoir » avec post-vérification conditions. Pour l'écrire, une construction d'instructions do... while est utilisée.

Cette boucle sera exécutée 4 fois, et « 2 3 4 5 » s'affichera à l'écran :

< 5);

Cette boucle sera exécutée 1 fois, et « 2 » s'affichera à l'écran :

Int je = 1 ; faire ( i++; System.out.print(i + " "); ) tandis que (i< 0);

Le corps de la boucle do... while est exécuté au moins une fois. Cet opérateur est pratique à utiliser lorsqu'une action du programme doit être effectuée au moins une fois, mais dans certaines conditions, elle devra être répétée plusieurs fois.

Découvrez le programme suivant (il devine un entier aléatoire à partir d'un segment et demande à l'utilisateur de le deviner en entrant des options à partir du clavier, jusqu'à ce que l'utilisateur devine le nombre, le programme lui demandera si le nombre deviné est supérieur ou inférieur à ce que l'utilisateur a saisi) :

Importer java.util.Scanner ; public class Main ( public static void main(String args) ( // prog - un nombre créé par le programme // user - un nombre entré par l'utilisateur int prog, user; // Génère un entier aléatoire de 1 à 10 prog = (int)(Math. random() * 10) + 1; System.out.println("J'ai pensé à un nombre de 1 à 10, devinez-le."); System.out.print("Entrez votre numéro : " ); Scanner input = new Scanner( System.in); // Vérifier s'il y a un entier dans le flux d'entrée if(input.hasNextInt()) ( do ( // Lire un entier à partir du flux d'entrée user = input.nextInt (); if(user == prog) ( System.out.println("Vous l'avez deviné!"); ) else ( // Vérifiez si le numéro est inclus dans le segment if (user > 0 && user<= 10) { System.out.print("Вы не угадали! "); // Если число загаданное программой меньше... if(prog < user) { System.out.println("Моё число меньше."); } else { System.out.println("Моё число больше."); } } else { System.out.println("Ваше число вообще не из нужного отрезка!"); } } } while(user != prog); } else { System.out.println("Ошибка. Вы не ввели целое число!"); } System.out.println("До свиданья!"); } }

Apportez les modifications suivantes au programme :

Le programme doit penser à un nombre non pas du segment , mais à un entier du segment de [−10;10], en excluant zéro. Dans le même temps, essayez de vous assurer que la distribution des nombres aléatoires générés par le programme est uniforme (c'est-à-dire que si un zéro tombe, il ne peut pas simplement être remplacé par un autre nombre, par exemple par 1, car alors 1 sera abandonné avec deux fois plus de probabilité que les autres chiffres).

Le programme doit avertir l'utilisateur qu'il a fait une erreur dans le signe si le programme a deviné un nombre positif et que l'utilisateur a entré un nombre négatif. Et vice versa.

Boucle N-time (instruction for)

L'instruction for contient trois paramètres. La première est appelée initialisation, la seconde est appelée condition de répétition et la troisième est appelée itération.

For (initialisation; condition; itération) ( //corps de la boucle, c'est-à-dire actions répétées cycliquement)

Dans le premier paramètre, vous sélectionnez généralement une variable qui sera utilisée pour compter le nombre de répétitions de la boucle. Cela s'appelle un compteur. Le compteur reçoit une valeur initiale (ils indiquent à partir de quelle valeur il va changer).

Le deuxième paramètre indique une certaine limitation sur le compteur (indiquez à quelle valeur il changera).

Le troisième paramètre spécifie une expression qui modifie le compteur après chaque étape de boucle. Il s'agit généralement d'un incrément ou d'un décrément, mais vous pouvez utiliser n'importe quelle expression dans laquelle le compteur se verra attribuer une nouvelle valeur.

Avant la première étape de la boucle, le compteur se voit attribuer une valeur initiale (une initialisation est effectuée). Cela n'arrive qu'une seule fois.

Avant chaque étape de la boucle (mais après initialisation), la condition de répétition est vérifiée ; si elle est vraie, alors le corps de la boucle est à nouveau exécuté. Dans le même temps, le corps de la boucle peut ne pas être exécuté une seule fois si la condition est fausse au moment de la première vérification.

Après avoir réalisé chaque étape de la boucle et avant de démarrer la suivante (et donc avant de vérifier la condition de répétition), une itération est effectuée.

Le programme suivant affiche les nombres de 1 à 100 :

Pour (int je = 1; je<= 100; i++) { System.out.print(i + " "); }

Le programme suivant affiche les nombres de 10 à −10 :

Pour (int s = 10; s > -11; s--) ( System.out.print(s + " "); )

Le programme présenté affiche les nombres impairs de 1 à 33 :

Pour (int je = 1; je<= 33; i = i + 2) { System.out.print(i + " "); }

Le programme présenté calculera la somme des éléments d'un fragment de la séquence 2, 4, 6, 8,... 98, 100. Donc :

Somme entière = 0 ; // Nous accumulerons ici le résultat pour (int j = 2; j

Le programme présenté élèvera un nombre à partir d'une variable un au degré naturel de variable n:

Double a = 2 ; entier n = 10 ; double résolution = 1 ; // Nous accumulerons ici le résultat pour (int i = 1; i<= n; i++) { res = res * a; } System.out.println(res);

Le programme présenté affichera les 10 premiers éléments de la séquence 2n+2, où n=1, 2, 3… :

Pour (int je = 1; je< 11; i++) { System.out.print(2*i + 2 + " "); }

Le programme présenté affichera les 10 premiers éléments de la séquence 2a n−1 +3, où a 1 =3 :

Int a = 3 ; pour (i=1; je<=10;i++) { System.out.print(a + " "); a = 2*a + 3; }

En un seul cycle, vous pouvez régler plusieurs compteurs à la fois. Dans ce cas, plusieurs expressions en itération et en initialisation sont séparées par des virgules. Une seule condition de répétition peut être spécifiée, mais il peut s'agir d'une expression contenant plusieurs compteurs à la fois.

Le programme présenté affichera les 10 premiers éléments de la séquence 2a n−1 -2, où a 1 =3 :

Pour (int a=3, i=1; je<=10; a=2*a-2, i++) { System.out.print(a + " "); }

Le programme présenté affichera la séquence suivante « 0 -1 -4 -9 -16 -25 » :

Pour (int a=0, b=0; a-b<=10; a++, b--) { System.out.print(a*b + " "); }

Terminer une boucle plus tôt (instruction break)

La boucle de type « while » et la boucle de type « n-time » peuvent être terminées plus tôt si vous appelez l'opérateur à l'intérieur du corps de la boucle. casser. Dans ce cas, la boucle se terminera immédiatement ; même l'étape en cours ne sera pas terminée (c'est-à-dire que s'il y avait d'autres instructions après break, elles ne seront pas exécutées).

Suite à l’exemple suivant, seuls les chiffres « 1 2 3 4 End » seront affichés à l’écran :

Pour (int a=1; a

Lorsque le programme exécute la boucle pour la cinquième fois (entre dans une boucle avec un compteur égal à 5), la condition dans laquelle l'instruction break sera exécutée sera immédiatement vérifiée et trouvée vraie. La partie restante du corps de la boucle (sortie à l'écran) ne sera pas produite : le programme procédera immédiatement à l'exécution des opérations spécifiées après la boucle et au-delà.

En utilisant l'instruction break, vous pouvez interrompre une boucle manifestement infinie. Exemple (l'écran affichera « 100 50 25 12 6 3 1 0 » et après cela la boucle s'arrêtera) :

Int s = 100 ; while (true) ( ​​​​System.out.print(s + " "); s = s / 2; if(s == 0) ( break; ) )

Il est logique d'appeler l'opérateur break uniquement lorsqu'une condition se produit, sinon la boucle sera terminée plus tôt que prévu dès sa toute première étape.

Int un; for (a=25; a>0; a--) ( break; System.out.print(a + " "); ) System.out.print("a=" + a);

Dans l'exemple ci-dessus, la sortie à l'écran dans une boucle ne se produira pas une seule fois, et lorsque la variable un s'affiche à l'écran après la boucle, il s'avère que sa valeur n'a jamais changé, c'est à dire que « a=25 » sera affiché (et rien d'autre).

Notez également que la variable a été déclarée avant le début de la boucle. Lorsqu'une variable est déclarée dans les paramètres d'une boucle, elle s'avère inaccessible en dehors de celle-ci, mais dans ce cas, il fallait autre chose : savoir quelle valeur aura le compteur une fois la boucle terminée.

Tâches

Créez un programme qui affiche tous les nombres à quatre chiffres dans la séquence 1000 1003 1006 1009 1012 1015….

Écrivez un programme qui affiche les 55 premiers éléments de la séquence 1 3 5 7 9 11 13 15 17 ….

Écrivez un programme qui affiche tous les éléments non négatifs de la séquence 90 85 80 75 70 65 60….

Écrivez un programme qui affiche les 20 premiers éléments de la séquence 2 4 8 16 32 64 128 ….

Affichez tous les termes de la séquence 2a n-1 -1, où a 1 =2, qui sont inférieurs à 10 000.

Affichez tous les termes à deux chiffres de la séquence 2a n-1 +200, où a 1 = -166.

Créez un programme qui calcule la factorielle d'un nombre naturel n que l'utilisateur saisit à l'aide du clavier.

Afficher tous les diviseurs positifs d'un nombre naturel saisi par l'utilisateur à partir du clavier.

Vérifiez si l'entier naturel saisi par l'utilisateur à partir du clavier est premier. Essayez de ne pas effectuer d'actions inutiles (par exemple, après avoir trouvé au moins un diviseur non trivial, il est déjà clair que le nombre est composé et qu'il n'est pas nécessaire de continuer à vérifier). Notez également que le plus petit diviseur d'un nombre naturel n, s'il existe, doit être situé dans le segment.

Écrivez un programme qui affiche les 12 premiers éléments de la séquence 2a n-2 -2, où a 1 =3 et a 2 =2.

Affichez les 11 premiers termes de la séquence de Fibonacci. Nous vous rappelons que le premier et le deuxième terme de la suite sont égaux à un, et que chaque terme suivant est la somme des deux précédents.

Pour un nombre naturel saisi par l'utilisateur à partir du clavier, calculez la somme de tous ses chiffres (on ne sait pas à l'avance combien de chiffres contiendra le nombre).

Dans la ville N, les déplacements en tramway s'effectuent au moyen de tickets papier détachables. Chaque semaine, le dépôt de tramway commande à l'imprimerie locale un rouleau de tickets portant les numéros de 000001 à 999999. Un ticket est considéré comme « porte-bonheur » si la somme des trois premiers chiffres du numéro est égale à la somme des trois derniers. chiffres, comme par exemple sur les tickets portant les numéros 003102 ou 567576. Le dépôt de tramway a décidé d'offrir un souvenir au gagnant de chaque ticket chanceux et se demande maintenant combien de souvenirs seront nécessaires. À l'aide du programme, comptez combien de billets chanceux il y a dans un seul rouleau ?

Dans la ville N, il y a un grand entrepôt dans lequel se trouvent 50 000 étagères différentes. Pour la commodité des travailleurs, la direction de l'entrepôt a décidé de commander une plaque avec un numéro de 00001 à 50000 pour chaque étagère auprès d'une imprimerie locale, mais lorsque les plaques ont été imprimées, il s'est avéré que l'imprimerie, en raison d'un dysfonctionnement, n'a pas imprimé le numéro 2, donc toutes les plaques dont les numéros contenaient un ou plusieurs deux (par exemple, 00002 ou 20202) - vous devez le retaper. Écrivez un programme qui comptera combien de ces plaques erronées se trouvaient dans le lot défectueux.

L'horloge électronique affiche l'heure au format de 00h00 à 23h59. Comptez combien de fois par jour il arrive qu'une combinaison symétrique s'affiche à gauche du côlon pour celle à droite du côlon (par exemple, 02h20, 11h11 ou 15h51).

Dans l'armée américaine, le chiffre 13 est considéré comme porte-bonheur, et chez les Japonais - 4. Avant les exercices internationaux, le quartier général de l'armée russe a décidé d'exclure les numéros d'équipement militaire contenant les chiffres 4 ou 13 (par exemple, 40123, 13313, 12345 ou 13040) afin de ne pas confondre les collègues étrangers. Si l'armée dispose de 100 000 unités d'équipement militaire et que chaque véhicule de combat porte un numéro de 00001 à 99999, alors combien de numéros devront être exclus ?

2010, Alexeï Nikolaïevitch Kostin. Département de TIDM, Faculté de mathématiques, Université pédagogique d'État de Moscou.