Listado completo de tutoriales

62 - Estructura selectiva switch


La estructura selectiva switch nos puede remplazar en algunas circunstancias una serie de if anidados, como veremos no es en todos los casos, solo en los casos que se verifican igualdades con ciertos valores.

Para ver su funcionamiento y sintaxis primero lo resolveremos el problema utilizando instrucciones if y luego empleando el switch.

Problema:

Simular el tirado de un dado 1000 veces. Mostrar luego la cantidad de veces que salieron cada valor. Resolverlo empleando tanto con if como con switch.

Programa:


public class SimulacionDados {

    public static void main(String[] args) {
        int lado1 = 0;
        int lado2 = 0;
        int lado3 = 0;
        int lado4 = 0;
        int lado5 = 0;
        int lado6 = 0;
        for (int f = 0; f < 1000; f++) {
            int dado = (int) (Math.random() * 6) + 1;
            if (dado == 1)
                lado1++;
            else if (dado == 2)
                lado2++;
            else if (dado == 3)
                lado3++;
            else if (dado == 4)
                lado4++;
            else if (dado == 5)
                lado5++;
            else if (dado == 6)
                lado6++;
        }
        System.out.println("Resultado de la primer simulación");
        System.out.println("Cantidad de veces que salieron 1:" + lado1);
        System.out.println("Cantidad de veces que salieron 2:" + lado2);
        System.out.println("Cantidad de veces que salieron 3:" + lado3);
        System.out.println("Cantidad de veces que salieron 4:" + lado4);
        System.out.println("Cantidad de veces que salieron 5:" + lado5);
        System.out.println("Cantidad de veces que salieron 6:" + lado6);

        // Empleando la estructura swich
        lado1 = 0;
        lado2 = 0;
        lado3 = 0;
        lado4 = 0;
        lado5 = 0;
        lado6 = 0;
        for (int f = 0; f < 1000; f++) {
            int dado = (int) (Math.random() * 6) + 1;
            switch (dado) {
            case 1:
                lado1++;
                break;
            case 2:
                lado2++;
                break;
            case 3:
                lado3++;
                break;
            case 4:
                lado4++;
                break;
            case 5:
                lado5++;
                break;
            case 6:
                lado6++;
                break;
            }
        }
        System.out.println("Resultado de la segunda simulación");
        System.out.println("Cantidad de veces que salieron 1:" + lado1);
        System.out.println("Cantidad de veces que salieron 2:" + lado2);
        System.out.println("Cantidad de veces que salieron 3:" + lado3);
        System.out.println("Cantidad de veces que salieron 4:" + lado4);
        System.out.println("Cantidad de veces que salieron 5:" + lado5);
        System.out.println("Cantidad de veces que salieron 6:" + lado6);
    }

}

Como podemos ver el algoritmo queda más legible empleando la estructura selectiva switch:

            switch (dado) {
            case 1: lado1++;
                    break;
            case 2: lado2++;
                    break;
            case 3: lado3++;
                    break;
            case 4: lado4++;
                    break;
            case 5: lado5++;
                    break;
            case 6: lado6++;
                    break;                    
            }

La sintaxis del switch es la siguiente:

Luego de la palabra clave switch debemos indicar entre paréntesis el nombre de la variable a analizar (puede ser una variable entera, char o String).

Entre llaves debemos indicar luego de la palabra clave 'case' el valor a comparar. Si la variable a analizar tiene dicho valor pasa a ejecutar todas las instrucciones que indiquemos luego de los dos puntos.

Es importante terminar con la palabra clave break la finalización del bloque de un 'case', con otro ejemplo veremos más adelante que sucede si no especificamos el break.

default

Así como una instrucción if tiene en forma opcional el bloque del else, el comando switch tiene en forma opcional el bloque 'default'.

Problema:

Generar 100 valores aleatorios comprendidos entre 1 y 10. Contar cuantos se generaron con los valores 1,5,10 y los que no son ni 1,5 o 10.

Programa:


public class Generacion10Valores {

    public static void main(String[] args) {
        int cant1=0;
        int cant5=0;
        int cant10=0;
        int otros=0;
        for (int f = 0; f < 100; f++) {
            int valor = (int) (Math.random() * 10) + 1;
            switch (valor) {
            case 1:
                cant1++;
                break;
            case 5:
                cant5++;
                break;
            case 10:
                cant10++;
                break;
            default:
                otros++;
            }
        }
        System.out.println("Cantidad de veces que salieron 1: " + cant1);
        System.out.println("Cantidad de veces que salieron 5: " + cant5);
        System.out.println("Cantidad de veces que salieron 10: " + cant10);
        System.out.println("Cantidad de veces que no salieron 1,5 o 10: " + otros);
    }

}

En este caso la estructura selectiva 'switch' tiene el bloque del 'default'. Todas las veces que en la variable valor no se almacene un 1,5 o 10 se ejecutarán las instrucciones que especifiquemos luego de la palabra clave 'default'.

La ejecución del programa nos genera una salida similar a:

java switch default

Sin palabra clave 'break'

Si no disponemos la palabra clave 'break' en un 'case' luego se ejecuta el siguiente 'case', por ejemplo:

            switch (valor) {
            case 1:
                cant1++;
            case 5:
                cant5++;
            case 10:
                cant10++;
            default:
                otros++;
            }

Si la variable 'valor' almacena un 1 luego se ejecutan las instrucciones seguidas al primer caso:

            case 1:
                cant1++;

Al no tener un break se ejecuta el segundo caso, es decir se incrementa la variable 'cant5' en uno:

            case 5:
                cant5++;

También al no tener break el segundo caso se ejecuta el tercer 'case' e inclusive el 'default'.

Este comportamiento no tiene sentido y es un error lógico olvidarnos los break.

En algunas situaciones puede tener sentido no disponer 'break', veamos un ejemplo.

Problema:

Simular el tirado de un dado 1000 veces. Mostrar luego la cantidad de veces que salieron valores pares e impares.

Programa:


public class DadosParesImpares {
    public static void main(String[] args) {
        int pares = 0;
        int impares = 0;
        for (int f = 0; f < 1000; f++) {
            int dado = (int) (Math.random() * 6) + 1;
            switch (dado) {
            case 1:
            case 3:
            case 5:
                impares++;
                break;
            case 2:
            case 4:
            case 6:
                pares++;
                break;
            }
        }
        System.out.println("Cantidad de veces que salieron pares: " + pares);
        System.out.println("Cantidad de veces que salieron impares: " + impares);
    }
}

Es muy común emplear bloques de 'case' vacíos sin emplear la palabra clave 'break'. Luego si la variable 'dado' toma el valor 1 o 3 luego se ejecuta el 'case 5' incrementando el contador 'impares'. En el 'case 5' es importante notar que si finalizamos el bloque de instrucciones con un 'break'.

variable de tipo String

En la estructura selectiva switch podemos emplear una variable de tipo String.

Problema:

Almacenar en un vector los nombres de días que trabaja un empleado. Contar la cantidad de días que pertenecen a días laborables y fin de semana.

Programa:


public class Dias {

    public static void main(String[] ar) {
        String[] trabajo = { "lunes", "miércoles", "sábado", "domingo" };
        int laborables = 0;
        int finsemana = 0;
        for (int f = 0; f < trabajo.length; f++)
            switch (trabajo[f]) {
            case "lunes":
            case "martes":
            case "miércoles":
            case "jueves":
            case "viernes":
                laborables++;
                break;
            case "sábado":
            case "domingo":
                finsemana++;
                break;
            }
        System.out.println("Cantidad de días que trabaja en días hábiles: " + laborables);
        System.out.println("Cantidad de días que trabaja en fin de semana: " + finsemana);
    }

}

En el switch cada vuelta del for accede a un elemento del vector 'trabajo' que son de tipo String.


Retornar