Java Language
Structures de contrôle de base

Remarques

// valid, but discouraged
Scanner scan = new Scanner(System.in);
int val = scan.nextInt();
if(val % 2 == 0)
    System.out.println("Val was even!");


// invalid; will not compile
// note the misleading indentation here
for(int i = 0; i < 10; i++)
    System.out.println(i);
    System.out.println("i is currently: " + i);

Si / Sinon Si / Contrôle Else

if (i < 2) {
  System.out.println("i is less than 2");
} else if (i > 2) {
  System.out.println("i is more than 2");
} else {
  System.out.println("i is not less than 2, and not more than 2");
}

Le bloc if ne fonctionnera que lorsque i est inférieur ou égal à 1.

La condition else if est vérifiée uniquement si toutes les conditions avant (dans les constructions précédentes else if et les constructions parent if ) ont été testées sur false . Dans cet exemple, la condition else if ne sera vérifiée que si i est supérieur ou égal à 2.

Si son résultat est true , son bloc est exécuté, et tout else if et else construit après son saut.

Si aucune des if et else if n'a été testée sur true , le bloc else à la fin sera exécuté.

Pour les boucles

for (int i = 0; i < 100; i++) {
    System.out.println(i);
}

Les trois composants de la boucle for (séparés par ; ) sont la déclaration / initialisation des variables (ici int i = 0 ), la condition (ici i < 100 ) et l’instruction d’incrémentation (ici i++ ). La déclaration de variable est effectuée une fois comme si elle était placée juste à l’intérieur du { lors de la première exécution. Ensuite, la condition est vérifiée, s'il est true le corps de la boucle s'exécutera, s'il est false la boucle s'arrêtera. En supposant que la boucle se poursuive, le corps s'exécutera et finalement lorsque l'instruction } sera atteinte, l'instruction d'incrémentation s'exécutera juste avant que la condition ne soit à nouveau vérifiée.

Les accolades sont facultatives (vous pouvez une ligne avec un point-virgule) si la boucle ne contient qu'une seule instruction. Mais, il est toujours recommandé d'utiliser des accolades pour éviter les malentendus et les bugs.

Les composants for loop sont facultatifs. Si votre logique métier contient l'une de ces parties, vous pouvez omettre le composant correspondant de votre boucle for .

int i = obj.getLastestValue(); // i value is fetched from a method
    
for (; i < 100; i++) { // here initialization is not done
    System.out.println(i);
}

La structure for (;;) { function-body } est égale à une boucle while (true) .

Nested For Loops

Toute instruction de boucle ayant une autre instruction de boucle à l'intérieur appelée boucle imbriquée. La même façon de boucler avec plus de boucle interne est appelée «imbriquée pour la boucle».

    for(;;){
        //Outer Loop Statements
        for(;;){
            //Inner Loop Statements
        }
        //Outer Loop Statements
    }

Il est possible de démontrer que les imbriqués pour la boucle impriment des nombres en forme de triangle.

for(int i=9;i>0;i--){//Outer Loop
    System.out.println();
    for(int k=i;k>0;k--){//Inner Loop -1
        System.out.print(" ");
    }
    for(int j=i;j<=9;j++){//Inner Loop -2
        System.out.print(" "+j);
    }
 }

Pendant que les boucles

int i = 0;
while (i < 100) { // condition gets checked BEFORE the loop body executes
    System.out.println(i);
    i++;
}

A while boucle court aussi longtemps que la condition entre parenthèses est true . Cela s'appelle aussi la structure "boucle de pré-test" car l'instruction conditionnelle doit être satisfaite avant que le corps de la boucle principale ne soit exécuté à chaque fois.

Les accolades sont facultatives si la boucle ne contient qu'une seule instruction, mais certaines conventions de style de codage préfèrent les accolades.

do ... tandis que la boucle

La boucle do...while while diffère des autres boucles en ce sens qu'elle est garantie au moins une fois . On l'appelle aussi la structure "post-test loop" car l'instruction conditionnelle est exécutée après le corps de la boucle principale.

int i = 0;
do {
    i++;
    System.out.println(i);
} while (i < 100); // Condition gets checked AFTER the content of the loop executes.

Dans cet exemple, la boucle s'exécutera jusqu'à ce que le nombre 100 soit imprimé (même si la condition est i < 100 et non i <= 100 ), car la condition de la boucle est évaluée après l'exécution de la boucle.

Avec la garantie d'au moins une exécution, il est possible de déclarer des variables en dehors de la boucle et de les initialiser à l'intérieur.

String theWord;
Scanner scan = new Scanner(System.in);
do {
    theWord = scan.nextLine();
} while (!theWord.equals("Bird"));

System.out.println(theWord);

Dans ce contexte, le theWord est défini en dehors de la boucle, mais comme il est garanti d'avoir une valeur basée sur son flux naturel, le theWord sera initialisé.

Pour chaque

List strings = new ArrayList();
        
strings.add("This");
strings.add("is");
strings.add("a for-each loop");
        
for (String string : strings) {
    System.out.println(string);
}

T elements = ...
for (S s : elements) {
}

Sinon

int i = 2;
if (i < 2) {
  System.out.println("i is less than 2");
} else {
  System.out.println("i is greater than 2");
}

Une instruction if exécute le code de manière conditionnelle en fonction du résultat de la condition entre parenthèses. Lorsque la condition entre parenthèses est vraie, elle entrera dans le bloc de l'instruction if qui est défini par des accolades comme { et } . parenthèse ouvrante jusqu'à la parenthèse fermante est la portée de l'instruction if.

Le bloc else est facultatif et peut être omis. Il s'exécute si l'instruction if est false et ne s'exécute pas si l'instruction if est vraie. Dans ce cas, if instruction est exécutée.

Voir aussi: Si ternaire

Déclaration de changement

L'instruction switch est l'instruction de branche multi-voies de Java. Il est utilisé pour remplacer les chaînes long if - else if - else et les rendre plus lisibles. Cependant, à la différence if les déclarations, on ne peut pas utiliser les inégalités; chaque valeur doit être définie concrètement.

L'instruction switch comporte trois composants essentiels:

• case : Valeur évaluée pour l'équivalence avec l'argument de l'instruction switch .
• default : il s'agit d'une expression facultative, catch-all, si aucune des instructions de case n'est évaluée à true .
• Achèvement complet de la déclaration de case ; En général, break : Ceci est nécessaire pour empêcher l'évaluation indésirable d'autres déclarations de case .

À l'exception de continue , il est possible d'utiliser n'importe quelle instruction qui entraînerait l' achèvement brutal d'une déclaration . Ceci comprend:

• break
• return
• throw

Dans l'exemple ci-dessous, une instruction de switch typique est écrite avec quatre cas possibles, y compris la default .

Scanner scan = new Scanner(System.in);
int i = scan.nextInt();
switch (i) {
    case 0:
        System.out.println("i is zero");
        break;
    case 1:
        System.out.println("i is one");
        break;
    case 2:
        System.out.println("i is two");
        break;
    default:
        System.out.println("i is less than zero or greater than two");
}

En omettant les break ou toute déclaration qui aboutirait brusquement, nous pouvons tirer parti de ce que nous appelons des cas «tombants», qui s’évaluent en fonction de plusieurs valeurs. Cela peut être utilisé pour créer des plages pour une valeur réussie, mais n'est pas aussi flexible que les inégalités.

Scanner scan = new Scanner(System.in);
int foo = scan.nextInt();
switch(foo) {
    case 1:
        System.out.println("I'm equal or greater than one");
    case 2:
    case 3:    
        System.out.println("I'm one, two, or three");
        break;
    default:
        System.out.println("I'm not either one, two, or three");
}

Dans le cas de foo == 1 le résultat sera:

I'm equal or greater than one
I'm one, two, or three

Dans le cas de foo == 3 le résultat sera:

I'm one, two, or three

enum Option {
    BLUE_PILL,
    RED_PILL
}

public void takeOne(Option option) {
    switch(option) {
        case BLUE_PILL:
            System.out.println("Story ends, wake up, believe whatever you want.");
            break;
        case RED_PILL:
            System.out.println("I show you how deep the rabbit hole goes.");
            break;
            
    }
}

public void rhymingGame(String phrase) {
    switch (phrase) {
        case "apples and pears":
            System.out.println("Stairs");
            break;
        case "lorry":
            System.out.println("truck");
            break;
        default:
            System.out.println("Don't know any more");
    }
}

Opérateur ternaire

Parfois, vous devez vérifier une condition et définir la valeur d'une variable.

Pour ex.

String name;

if (A > B) {
    name = "Billy";
} else {
    name = "Jimmy";
}

Cela peut être facilement écrit dans une ligne comme

String name = A > B ? "Billy" : "Jimmy";

La valeur de la variable est définie sur la valeur immédiatement après la condition, si la condition est vraie. Si la condition est fausse, la deuxième valeur sera donnée à la variable.

Pause

L'instruction break termine une boucle (comme for , while ) ou l'évaluation d'une instruction switch .

Boucle:

while(true) {
   if(someCondition == 5) {
       break;
   }
}

La boucle dans l'exemple fonctionnerait pour toujours. Mais quand une someCondition est égale à 5 à un moment donné, la boucle se termine.

Si plusieurs boucles sont en cascade, seule la boucle la plus interne se termine par un break .

Essayez ... Catch ... Enfin

La structure de contrôle try { ... } catch ( ... ) { ... } est utilisée pour gérer les exceptions .

String age_input = "abc";
try {
    int age = Integer.parseInt(age_input);
    if (age >= 18) {
        System.out.println("You can vote!");
    } else {
        System.out.println("Sorry, you can't vote yet.");
    }
} catch (NumberFormatException ex) {
    System.err.println("Invalid input.  '" + age_input + "' is not a valid integer.");
}

Cela imprimerait:

Entrée invalide. 'abc' n'est pas un entier valide.

Une clause finally peut être ajoutée après le catch . La clause finally serait toujours exécutée, qu'une exception ait été levée ou non.

try { ... } catch ( ... ) { ... } finally { ... }

String age_input = "abc";
try {
    int age = Integer.parseInt(age_input);
    if (age >= 18) {
        System.out.println("You can vote!");
    } else {
        System.out.println("Sorry, you can't vote yet.");
    }
} catch (NumberFormatException ex) {
    System.err.println("Invalid input.  '" + age_input + "' is not a valid integer.");
} finally {
    System.out.println("This code will always be run, even if an exception is thrown");
}

Cela imprimerait:

Entrée invalide. 'abc' n'est pas un entier valide.
Ce code sera toujours exécuté, même si une exception est levée

Nested break / continue

Il est possible de break / continue vers une boucle externe en utilisant des instructions d'étiquette:

outerloop:
for(...) {
    innerloop:
    for(...) {
        if(condition1)
            break outerloop;

        if(condition2)
            continue innerloop; // equivalent to: continue;
    }
}

Il n'y a pas d'autre utilisation pour les étiquettes en Java.

Continuer la déclaration en Java

L'instruction continue permet d'ignorer les étapes restantes de l'itération en cours et de commencer avec l'itération de boucle suivante. Le contrôle passe de l'instruction continue à la valeur d'étape (incrémentation ou décrémentation), le cas échéant.

String[] programmers = {"Adrian", "Paul", "John", "Harry"};

    //john is not printed out
    for (String name : programmers) {
        if (name.equals("John"))
            continue;
        System.out.println(name);
    }

L'instruction continue peut également faire passer le contrôle du programme à la valeur d'étape (le cas échéant) d'une boucle nommée:

Outer: // The name of the outermost loop is kept here as 'Outer'
for(int i = 0; i < 5; )
{
    for(int j = 0; j < 5; j++)
    {
        continue Outer;
    }
}