Computación I

El tipo boolean y la instrucción break

Objetivos: Presentar nuevos elementos del lenguaje Java.

Temas:

El tipo boolean.
La instrucción break.
El patrón de lectura simplificado con la instrucción break.

Ejercicio: búsqueda en archivos.

Escriba un programa que entregue la distancia entre Santiago y alguna ciudad de Chile. El diálogo debe ser el siguiente:

    Nombre de ciudad ? arica
    La distancia entre Santiago y Arica es 2030 kilómetros

Para obtener la distancia, Ud. dispone de un archivo "dist.txt" que contiene las distancias entre Santiago y las ciudades más importantes de Chile en el siguiente formato:

Arica               2030
Puerto Mont         1012
Valparaiso           109
...

El nombre de la ciudad aparece entre las columnas 0 y 19 y la distancia entre la 20 y 23.

Observe que el usuario ingresa arica en minúsculas y que la misma ciudad aparece en mayúsculas en el archivo. El programa debe ignorar este tipo de diferencias.

Si la ciudad solicitada por el usuario no aparece en el archivo, el programa debe desplegar el siguiente mensaje:

    Nombre de ciudad ? Mendoza
    La ciudad de Mendoza no se encuentra en mi base de datos

Solución:

    print("Nombre de ciudad ? ");
    String ciudadBusc= lower(readLine());
    TextReader lect= new TextReader("dist.txt");
    int existe= 0;
    String linea= lect.readLine();
    while (!lect.eofReached() && existe==0) {
      FieldParser decod= new FieldParser(linea, ":");
      String ciudad= lower(trim(substring(linea, 0, 20)));
      int dist= parseInt(trim(substring(linea, 20, 4)));
      if (compare(ciudad, ciudadBusc)==0) {
        println("La distancia entre Santiago y "+ciudad+" es "+dist+
                " kilometros");
        existe= 1;
      }
      linea= lect.readLine();
    }
    if (existe==0) {
      println("La ciudad de "+ciudadBusc+
              " no se encuentra en mi base de datos");
    }
    lect.close();

(Ver el programa completo en BuscaCiudad.java. Recupere también el archivo de datos en dist.txt.)

Observación: La comparación se debe hacer ignorando la diferencia entre mayúsculas y minúscula. Por esta razón, se usó la función lower que traduce todo a letras minúsculas.

Si se encuentra la ciudad, no tiene sentido seguir leyendo el archivo. Por esta razón se agregó la variable existe. Esta variable permanece en 0 mientras no se haya encontrado la ciudad. Cuando se encuentra la ciudad se le asigna un 1, lo que se traduce en que el ciclo termina, puesto que no satisface la condición existe==0.

El tipo boolean

Los tipos de datos int, double y String, permiten almacenar enteros, reales y secuencias de caracteres. La mayoría de los lenguajes posee un tipo de datos para almacenar valores de verdad. En Java este tipo de datos se llama boolean y puede almacenar unicamente dos valores: verdadero o falso.

Constantes:

true: representa el valor verdadero.
false: representa el valor falso.

Declaración de variables:

    boolean existe; // sin inicialización
    boolean terminar= false; // con inicialización

Aplicaciones:

Los operadores relacionales <, ==, >=, etc. permiten construir expresiones que producen valores de verdad. Estos valores pueden ser utilizados en condiciones en un while o un if, y también pueden ser asignados a variables:

    boolean mayor= a>b;

También existen funciones y métodos que producen valores de verdad: isInt(...) y lect.eofReached().

Ejemplo:

El programa que entrega la distancia de una ciudad a Santiago puede ser reescrito:

    print("Nombre ciudad ? ");
    String ciudadBusc= lower(readLine());
    TextReader lect= new TextReader("dist.txt");
    boolean existe= false;
    String linea= lect.readLine();
    while (!lect.eofReached() && !existe) {
      String ciudad= lower(trim(substring(linea, 0, 20)));
      int dist= parseInt(trim(substring(linea, 20, 4)));
      if (compare(ciudad, ciudadBusc)==0) {
        println("La distancia entre Santiago y "+ciudad+" es "+dist+
                " kilometros");
        existe= true; // (C)
      }
      else linea= lect.readLine();
    }
    if (!existe) {
      println("La ciudad de "+ciudadBusc+
              " no se encuentra en mi base de datos");
    }
    lect.close();

(Ver el programa completo en BuscaCiudad2.java.)

La instrucción break

Se usa para salir rápidamente de un ciclo. Mientras se ejecuta una iteración de un ciclo, si se llega a ejecutar la instrucción break;, se abandona de inmediato esa iteración y se sale del ciclo. La próxima instrucción que será ejecutada será la que está inmediatamente después del ciclo.

El patrón de uso de esta instrucción consiste en un ciclo while que contiene un if, en donde se ejecuta la instrucción break:

    while ( ... ) {
      ... // (A)
      if ( ... ) { // (B)
        ... // (C)
        break;
        // (D)
      }
      ... // (E)
    }
    ... // (F)

Mientras la codición (B) sea falsa, el ciclo continuará realizando iteraciones de la manera usual. Esto significa que se ejecuta tanto (A) como (E). Pero si (B) resulta verdadera, se ejecutan las instrucciones de (C) y luego break que termina el ciclo. La próxima instrucción en ejecutarse será (F).

Esta secuencia de ejecución se observa más claramente en el siguiente diagrama:

Observaciones:

No tiene sentido colocar instrucciones en (D), puesto que nunca llegarían a ser ejecutadas.

Se pueden colocar varias instrucciones break en un mismo ciclo, pero solo tienen sentido si se colocan en instrucciones if distintas:

    while (...) {
      ...
      if (...) {
        break;
      }
      ...
      if (...) {
        break;
      }
      ...
    }

La instrucción break sólo termina el ciclo más interno que la contiene. En la siguiente sección veremos un ejemplo de esto último.

El patrón de lectura simplificado

La instrucción break se puede usar para simplificar el patrón de lectura:

    while (true) {
      lectura de un dato
      if ( se acabaron los datos ) {
        break;
      }
      ... procesar dato
    }

Ejemplo:

Modificar el programa que determina la distancia entre Santiago y otra ciudad de modo que ahora se acepten varias ciudades. El diálogo debe ser:

    Nombre de ciudad ? valparaiso
    La distancia entre Santiago y Valparaiso es 109 kilómetros
    Nombre de ciudad ? Mendoza
    La ciudad de Mendoza no se encuentra en mi base de datos
    Nombre de ciudad ? arica
    La distancia entre Santiago y Arica es 2030 kilómetros

Solución:

    while (true) { // Ciclo externo
      // Dialogar para obtener la ciudad
      print("Nombre ciudad ? ");
      String ciudadBusc= lower(readLine());
      if (compare(ciudadBusc,"fin")==0) {
        break; // (A)
      }
      // Buscarla en el archivo dist.txt
      TextReader lect= new TextReader("dist.txt");
      while (!lect.eofReached()) { // Ciclo interno
        String linea= lect.readLine();
        if (lect.eofReached()) {
          break; // (B)
        }
        String ciudad= lower(trim(substring(linea, 0, 20)));
        int dist= parseInt(trim(substring(linea, 20, 4)));
        println(ciudad+" "+dist+" "+ciudadBusc);
        if (compare(ciudad, ciudadBusc)==0) {
          println("La distancia entre Santiago y "+ciudad+" es "+dist+
                  " kilometros"); 
          break; // (C)
        }
      }
      if (lect.eofReached()) {
        println("La ciudad de "+ciudadBusc+
                " no se encuentra en mi base de datos");
      }
      lect.close(); 
    }

(Ver el programa completo en BuscaCiudad3.java.)

Observaciones:

En esta solución se crea un lector del archivo "datos.txt" por cada nombre de ciudad que ingrese el usuario por medio de la consola. Si el usuario consulta la distancia de 10 ciudades, se crearán 10 lectores. Cada lector no necesita leer todo el archivo, puesto que basta leer hasta encontrar la ciudad buscada.
Gracias a la instrucción break no es necesario mantener la variable existe de la versión anterior y que servía para terminar el ciclo.
Los break en (B) y (C) sirven para salir del ciclo interno, mientras que el break en (A) termina el ciclo externo.
Por razones de eficiencia en el uso de recursos, es conveniente cerrar con close todo lector de archivos que no se continuará usando. En el caso de los escritores de archivos, es obligatorio cerrarlos, puesto que si se leen posteriormenete, podrían estar incompletos.