Java Language
Estructuras de control básicas

Observaciones

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

El bloque if solo se ejecutará cuando i sea ​​1 o menos.

La condición else if se comprueba solo si todas las condiciones anteriores (en las anteriores construcciones else if , y la primaria if construye) se han probado como false . En este ejemplo, la condición else if solo se verificará si i es mayor o igual a 2.

Si su resultado es true , su bloque se ejecuta, y cualquier else if y de lo else construye después de que se omita.

Si ninguna de las condiciones if y else if han sido probadas como true , se ejecutará el bloque else al final.

Para loops

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

Los tres componentes del bucle for (separados por ; ) son la declaración / inicialización de la variable (aquí int i = 0 ), la condición (aquí i < 100 ) y la declaración de incremento (aquí i++ ). La declaración de variables se realiza una vez como si se colocara justo dentro de { en la primera ejecución. Luego se comprueba la condición, si es true el cuerpo del bucle se ejecutará, si es false el bucle se detendrá. Suponiendo que el bucle continúe, el cuerpo se ejecutará y, finalmente, cuando se alcance el } la instrucción de incremento se ejecutará justo antes de que se compruebe nuevamente la condición.

Las llaves son opcionales (puede una línea con un punto y coma) si el bucle contiene una sola instrucción. Pero, siempre se recomienda utilizar llaves para evitar malentendidos y errores.

Los componentes de bucle for son opcionales. Si su lógica de negocios contiene una de estas partes, puede omitir el componente correspondiente de su bucle 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 estructura for (;;) { function-body } es igual a un bucle while (true) .

Nested For Loops

Cualquier instrucción de bucle que tenga otra instrucción de bucle dentro de un bucle anidado llamado. La misma forma para que el bucle tenga más bucle interno se llama 'anidado para bucle'.

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

Se puede demostrar que Nested for loop imprime números en forma de triángulo.

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

Mientras bucles

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

A while bucle se ejecuta siempre que la condición dentro de los paréntesis es true . Esto también se denomina estructura de "bucle de prueba previa" porque la declaración condicional debe cumplirse antes de que se realice el cuerpo del bucle principal cada vez.

Las llaves son opcionales si el bucle contiene solo una declaración, pero algunas convenciones de estilo de codificación prefieren tener las llaves independientemente.

hacer ... mientras bucle

El bucle do...while while difiere de otros bucles en que se garantiza que se ejecutará al menos una vez . También se denomina estructura de "bucle posterior a la prueba" porque la declaración condicional se realiza después del cuerpo del bucle principal.

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

En este ejemplo, el bucle se ejecutará hasta que se imprima el número 100 (aunque la condición sea i < 100 y no i <= 100 ), porque la condición del bucle se evalúa después de que se ejecuta el bucle.

Con la garantía de al menos una ejecución, es posible declarar variables fuera del bucle e inicializarlas dentro.

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

System.out.println(theWord);

En este contexto, la theWord se define fuera del bucle, pero como se garantiza que tiene un valor basado en su flujo natural, la theWord se inicializará.

Para cada

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

Si / Else

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

Una instrucción if ejecuta el código condicionalmente según el resultado de la condición entre paréntesis. Cuando la condición entre paréntesis es verdadera, entrará al bloque de la instrucción if que está definida por llaves como { y } . el soporte de apertura hasta el soporte de cierre es el alcance de la sentencia if.

El bloque else es opcional y puede omitirse. Se ejecuta si la instrucción if es false y no se ejecuta si la instrucción if es verdadera. En ese caso, if ejecuta la instrucción.

Ver también: ternario si

Cambiar la declaración

La instrucción switch es la declaración de rama de múltiples vías de Java. Se utiliza para reemplazar el largo de las cadenas if , else if , else , y hacerlas más legibles. Sin embargo, a diferencia de las afirmaciones if , uno no puede usar desigualdades; Cada valor debe ser definido concretamente.

Hay tres componentes críticos para la instrucción switch :

• case : Este es el valor que se evalúa para determinar la equivalencia con el argumento de la instrucción switch .
• default : esta es una expresión opcional, de alcance general, en caso de que ninguna de las declaraciones de case evalúe como true .
• Finalización abrupta de la declaración del case ; generalmente se break : esto es necesario para evitar la evaluación no deseada de declaraciones de case adicionales.

Con la excepción de continue , es posible usar cualquier declaración que cause la finalización brusca de una declaración . Esto incluye:

• break
• return
• throw

En el siguiente ejemplo, una declaración de switch típica se escribe con cuatro casos posibles, incluido el 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");
}

Al omitir una break o cualquier declaración que pudiera completarse de manera abrupta, podemos aprovechar lo que se conoce como casos "directos", que evalúan varios valores. Esto se puede usar para crear rangos para que un valor sea exitoso, pero aún no es tan flexible como las desigualdades.

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

En caso de foo == 1 la salida será:

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

En caso de foo == 3 la salida será:

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

Operador ternario

A veces hay que verificar una condición y establecer el valor de una variable.

Por ej.

String name;

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

Esto se puede escribir fácilmente en una línea como

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

El valor de la variable se establece en el valor inmediatamente después de la condición, si la condición es verdadera. Si la condición es falsa, se le dará el segundo valor a la variable.

Descanso

La instrucción break termina un bucle (como for , while ) o la evaluación de una instrucción switch .

Lazo:

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

El bucle en el ejemplo se ejecutaría para siempre. Pero cuando someCondition es igual a 5 en algún punto de ejecución, entonces el bucle termina.

Si varios bucles se conectan en cascada, solo la mayoría de los bucles internos terminan utilizando break .

Intenta ... Atrapa ... Finalmente

La estructura de control try { ... } catch ( ... ) { ... } se utiliza para manejar las excepciones .

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

Esto imprimiría:

Entrada inválida. 'abc' no es un número entero válido.

Se puede añadir una cláusula finally después de la catch . La cláusula finally siempre se ejecutaría, independientemente de si se lanzó una excepción.

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

Esto imprimiría:

Entrada inválida. 'abc' no es un número entero válido.
Este código siempre se ejecutará, incluso si se lanza una excepción

Pausa anidada / continuar

Es posible break / continue a un bucle externo usando declaraciones de etiqueta:

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

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

No hay otro uso para las etiquetas en Java.

Continuar declaración en Java

La instrucción continue se usa para omitir los pasos restantes en la iteración actual y comenzar con la siguiente iteración de bucle. El control pasa de la instrucción de continue al valor de paso (incremento o decremento), si lo hay.

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

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

La instrucción de continue también puede hacer que el control del programa cambie al valor de paso (si lo hay) de un bucle con nombre:

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