Java Language
Strutture di controllo di base

Osservazioni

// 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);

Se / Else If / Else Control

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");
}

Il blocco if verrà eseguito solo quando i è 1 o meno.

La condizione else if viene verificata solo se tutte le condizioni precedenti (nel precedente else if construct e parent if costrutti) sono state testate su false . In questo esempio, la condizione else if verrà verificata solo se i è maggiore o uguale a 2.

Se il risultato è true , viene eseguito il blocco e tutti i costrutti else if e else verranno saltati.

Se nessuna delle if e else if condizioni sono state testate su true , verrà eseguito il blocco else alla fine.

Per loop

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

I tre componenti del ciclo for (separati da ; ) sono dichiarazione / inizializzazione variabile (qui int i = 0 ), la condizione (qui i < 100 ) e l'istruzione di incremento (qui i++ ). La dichiarazione delle variabili viene eseguita una volta come se fosse posizionata appena all'interno di { alla prima esecuzione. Quindi la condizione viene verificata, se è true il corpo del ciclo verrà eseguito, se è false il ciclo si fermerà. Supponendo che il ciclo continui, il corpo verrà eseguito e, infine, quando viene raggiunto il punto } l'istruzione di incremento verrà eseguita appena prima che la condizione venga nuovamente controllata.

Le parentesi graffe sono facoltative (è possibile una riga con un punto e virgola) se il ciclo contiene una sola istruzione. Tuttavia, è sempre consigliabile utilizzare le parentesi graffe per evitare equivoci e bug.

I componenti del ciclo for sono opzionali. Se la tua logica aziendale contiene una di queste parti, puoi omettere il componente corrispondente dal tuo ciclo 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 struttura for (;;) { function-body } è uguale ad un ciclo while (true) .

Nested For Loops

Qualsiasi istruzione di loop con un'altra istruzione loop all'interno chiamata loop annidato. Lo stesso modo per il loop che ha più loop interno è chiamato 'nested for loop'.

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

È possibile dimostrare che il ciclo annidato per stampare numeri a forma di triangolo.

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);
    }
 }

Mentre cicli

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

Un ciclo while viene eseguito fintanto che la condizione tra parentesi è true . Questa viene anche chiamata la struttura del "ciclo di pre-test" poiché l'istruzione condizionale deve essere soddisfatta prima che il corpo del ciclo principale venga eseguito ogni volta.

Le parentesi graffe sono facoltative se il ciclo contiene una sola istruzione, ma alcune convenzioni di stile di codifica preferiscono avere le parentesi a prescindere.

do ... while Loop

Il ciclo do...while differenzia da altri loop in quanto è garantito che venga eseguito almeno una volta . Viene anche chiamata la struttura "loop post-test" perché l'istruzione condizionale viene eseguita dopo il corpo del ciclo principale.

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

In questo esempio, il ciclo verrà eseguito finché non verrà stampato il numero 100 (anche se la condizione è i < 100 e non i <= 100 ), poiché la condizione del ciclo viene valutata dopo l'esecuzione del ciclo.

Con la garanzia di almeno un'esecuzione, è possibile dichiarare le variabili all'esterno del ciclo e inizializzarle all'interno.

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

System.out.println(theWord);

In questo contesto, la theWord è definita al di fuori del ciclo, ma poiché è garantito avere un valore basato sul suo flusso naturale, la theWord verrà inizializzata.

Per ciascuno

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) {
}

Se altro

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

Un'istruzione if esegue il codice condizionalmente a seconda del risultato della condizione tra parentesi. Quando la condizione tra parentesi è vera, entrerà nel blocco di if statement che è definito da parentesi graffe come { e } . la staffa di apertura fino alla staffa di chiusura è lo scopo dell'istruzione if.

Il blocco else è facoltativo e può essere omesso. Funziona se il if affermazione è false e non viene eseguito se il if affermazione è vera perché in quel caso if istruzione viene eseguita.

Vedi anche: Ternario Se

Passare la dichiarazione

L'istruzione switch è la dichiarazione di ramo a più vie di Java. E 'usato per prendere il posto di lunga if - else if - else catene, e renderli più leggibili. Tuttavia, a differenza delle dichiarazioni if , non si possono usare disuguaglianze; ogni valore deve essere definito concretamente.

Esistono tre componenti critici per l'istruzione switch :

• case : questo è il valore che viene valutato per l'equivalenza con l'argomento dell'istruzione switch .
• default : si tratta di un'espressione catch-all facoltativa, nel case cui nessuna delle espressioni case valuti come true .
• Completamento brusco della dichiarazione del case ; di solito break : ciò è necessario per evitare la valutazione indesiderata di ulteriori dichiarazioni di un case .

Ad eccezione di continue , è possibile utilizzare qualsiasi istruzione che possa causare il completamento brusco di una dichiarazione . Ciò comprende:

• break
• return
• throw

Nell'esempio seguente, una tipica istruzione switch viene scritta con quattro possibili casi, incluso quello 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");
}

Omettendo la break o qualsiasi affermazione che avrebbe un completamento brusco, possiamo sfruttare i casi noti come "fall-through", che valutano rispetto a diversi valori. Questo può essere usato per creare intervalli per cui un valore ha successo, ma non è ancora flessibile come le disuguaglianze.

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");
}

In caso di foo == 1 l'output sarà:

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

In caso di foo == 3 l'output sarà:

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");
    }
}

Operatore ternario

A volte è necessario verificare una condizione e impostare il valore di una variabile.

Per es.

String name;

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

Questo può essere facilmente scritto in una riga come

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

Il valore della variabile è impostato sul valore immediatamente dopo la condizione, se la condizione è vera. Se la condizione è falsa, verrà assegnato il secondo valore alla variabile.

Rompere

L'istruzione break termina un ciclo (come for , while ) o la valutazione di un'istruzione switch .

Ciclo continuo:

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

Il ciclo nell'esempio funzionerebbe per sempre. Ma quando una someCondition uguale a 5 in qualche punto dell'esecuzione, allora il ciclo termina.

Se i loop multipli sono in cascata, solo il loop più interno termina utilizzando break .

Prova ... Catch ... Finalmente

La struttura di controllo try { ... } catch ( ... ) { ... } viene utilizzata per la gestione delle eccezioni .

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.");
}

Questo stamperebbe:

Inserimento non valido. 'abc' non è un numero intero valido.

Una finally clausola può essere aggiunto dopo la catch . La clausola finally sarebbe sempre stata eseguita, indipendentemente dal fatto che fosse stata lanciata un'eccezione.

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");
}

Questo stamperebbe:

Inserimento non valido. 'abc' non è un numero intero valido.
Questo codice verrà sempre eseguito, anche se viene generata un'eccezione

Interruzione / proseguimento annidato

È possibile break / continue con un ciclo esterno usando le istruzioni label:

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

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

Non c'è altro uso per le etichette in Java.

Continua la dichiarazione in Java

L'istruzione continue viene utilizzata per saltare i passaggi rimanenti nell'iterazione corrente e iniziare con l'iterazione del ciclo successivo. Il controllo passa dall'istruzione continue al valore di passo (incremento o decremento), se presente.

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'istruzione continue può anche fare in modo che il controllo del programma passi al valore di passo (se esiste) di un ciclo denominato:

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;
    }
}