3 minutos

Estructuras de control en Java

Estructuras de control en Java

1. Introducción

En el sentido más básico, un programa es una lista de instrucciones. Las estructuras de control son bloques de programación que pueden cambiar el camino que seguimos a través de esas instrucciones.

En este tutorial, exploraremos las estructuras de control en Java.

Existen tres tipos de estructuras de control:

  • Ramificaciones condicionales, que usamos para elegir entre dos o más caminos. Hay tres tipos en Java: if/else/if else, operador ternario y switch.
  • Bucles que se utilizan para iterar a través de múltiples valores/objetos y ejecutar repetidamente bloques de código específicos. Los tipos básicos de bucles en Java son for, while y do while.
  • Sentencias de ramificación, que se utilizan para alterar el flujo de control en los bucles. Hay dos tipos en Java: break y continue.

2. If/Else/Else If

La declaración if/else es la estructura de control más básica, pero también se puede considerar la base misma de la toma de decisiones en la programación.

Aunque if puede utilizarse por sí solo, el escenario de uso más común es elegir entre dos caminos con if/else:

if (cuenta > 2) {
    System.out.println("La cuenta es mayor que 2");
} else {
    System.out.println("La cuenta es menor o igual a 2");
}

Teóricamente, podemos encadenar o anidar infinitamente bloques if/else, pero esto perjudicará la legibilidad del código, por lo que no se recomienda.

Exploraremos declaraciones alternativas en el resto de este artículo.

3. Operador Ternario

Podemos usar un operador ternario como una expresión abreviada que funciona como una declaración if/else.

Veamos nuestro ejemplo de if/else nuevamente:

if (cuenta > 2) {
    System.out.println("La cuenta es mayor que 2");
} else {
    System.out.println("La cuenta es menor o igual a 2");
}

Podemos refactorizar esto con un operador ternario de la siguiente manera:

System.out.println(cuenta > 2 ? "La cuenta es mayor que 2" : "La cuenta es menor o igual a 2");

Si bien el operador ternario puede ser una excelente manera de hacer que nuestro código sea más legible, no siempre es un buen sustituto de if/else.

4. Switch

Si tenemos múltiples casos para elegir, podemos usar una declaración switch.

Veamos nuevamente un ejemplo simple:

int cuenta = 3;
switch (cuenta) {
case 0:
    System.out.println("La cuenta es igual a 0");
    break;
case 1:
    System.out.println("La cuenta es igual a 1");
    break;
default:
    System.out.println("La cuenta es negativo o mayor que 1");
    break;
}

Tres o más declaraciones if/else pueden ser difíciles de leer. Como una de las posibles soluciones, podemos usar switch, como se ve arriba.

Y también ten en cuenta que switch tiene limitaciones de alcance y entrada que veremos en futuras publicaciones.

5. Bucles

Usamos bucles cuando necesitamos repetir el mismo código varias veces consecutivas.

Veamos un ejemplo rápido de bucles comparables de tipo for y while:

for (int i = 1; i <= 50; i++) {
    metodoARepetir();
}

int contadorWhile = 1;
while (contadorWhile <= 50) {
    metodoARepetir();
    contadorWhile++;
}

Ambos bloques de código anteriores llamarán al metodoARepetir 50 veces.

6. Break

Necesitamos usar break para salir de un bucle antes de que finalice.

Veamos un ejemplo rápido:

List<String> nombres = obtenerListaDeNombres();
String nombre = "John Doe";
int indice = 0;
for (; indice < nombres.length; indice++) {
    if (nombres[indice].equals(nombre)) {
        break;
    }
}

Aquí, estamos buscando un nombre en una lista de nombres y queremos dejar de buscar una vez que lo hayamos encontrado.

Normalmente, un bucle se ejecutaría hasta su finalización, pero hemos usado break aquí para interrumpirlo y salir antes.

7. Continue

En pocas palabras, continue significa saltar el resto del bucle en el que estamos:

List<String> nombres = obtenerListaDeNombres();
String nombre = "John Doe";
String lista = "";
for (int i = 0; i < nombres.length; i++) {
    if (nombres[i].equals(nombre)) {
        continue;
    }
    lista += nombres[i];
}

Aquí, omitimos agregar los nombres duplicados a la lista.

Como hemos visto aquí, break y continue pueden ser útiles al iterar, aunque a menudo pueden reescribirse con declaraciones return u otra lógica.

8. Conclusión

En este breve artículo, aprendimos qué son las estructuras de control y cómo usarlas para gestionar el flujo de control en nuestros programas Java.

-->