CEPC

Lectura por teclado : Uso básico del Objeto Scanner.

El tema central es la lectura por teclado, utilizando el objeto Scanner que se encuentra en la API de java.

El paquete donde se cuentra es :

       java.util.Scanner

A la hora de utilizarlo quedaría de esta manera :

      import  java.util.Scanner;

Teniendo en cuenta esto, vamos a empezar:

Primero: 

• ¿Qué es lo que queremos leer? 
• ¿Qué es lo que podemos leer con Scanner?

Nos centraremos en el uso básico del Scanner.

Contestando la primera pregunta:

¿Qué es lo que queremos leer con Scanner?

La mayoría de los usuarios quieren ingresar en un programa, dependiendo su finalidad:

• Números.
• Palabras.

El primer punto, los números hay diferentes tipos: enteros , decimales , números pequeños, extremadamente grandes, etc...

Sobre las palabras, son generales y se pueden utilizar de diversas maneras, según el objetivo del programa.

Por el lado de los números, lo que le debe de importar al programador es que finalidad va a tener su programa. El tipo de número que tiene que utilizar.

¿Qué es lo que podemos leer con Scanner?

En Java existen los tipos de datos primitivos.

• Hablando de valores números se presentan: 

Nombre   Tipo       Ocupa       Rango Aproximado

byte         Entero     1 byte      -128 a 127

short        Entero     2 bytes    -32768 a 32767

int            Entero     4 bytes    -2147483648 a 2147483647

long         Entero     8 bytes    -9223372036854775808 a 9223372036854775807

Nombre            Tipo              Ocupa       Rango Aproximado

float        Decimal simple     4 bytes       ± 3.4x10^-38 a ± 3.4x10³⁸

double    Decimal doble      8 bytes       ± 1.8x10^-308 a ± 1.8x10³⁰⁸

*Es importante que el programador tenga en cuenta el rango aproximado  del tipo de dato a utilizar. Dado que  si no se manejan correctamente pueden desbordarse y dar valores incorrectos

**Desbordarse : superar su rango aproximado, por ende dar un valor incorrecto.

En Java, para cada tipo de dato existe una clase asociada en la API. Todas ellas se encuentran en java.lang las cuales vienen por defecto.

Tipo de Dato       Clase en Java

byte                          Byte

short                         Short

int                             Integer

long                          Long
float                          Float
double                      Double

Todos los tipos de datos numéricos, cuando los creamos vienen con 0 [cero] como valor por defecto.

Los valores del tipo numérico entero es un número real, pueden ser positivos o negativos.

Los valores del tipo numérico decimal son números  que llevan un punto decimal y que pueden ser positivos o negativos.

• Hablando de cadenas de caracteres Java presenta:

Nombre       Tipo                Ocupa       Rango Aproximado       Clase en Java

char           Carácter simple      2 byte       Caracteres Unicode        Character

• Hablando de datos lógicos se encuentra: 

Nombre           Tipo               Ocupa       Rango          Clase en Java

boolean          Dato lógico     1 byte       true - false         Boolean

¿ Y cómo leemos esos valores con el Scanner?

Primero se crea una instancia del objeto Scanner. Lo que recibe en el constructor es el flujo del teclado. *Se agrega System.in [flujo de entrada].

     Scanner s = new Scanner (System.in); 


Concluido lo anterior, Scanner tiene métodos para lectura de los datos primitivos presentados, con la facilidad de utilizar la variable del Scanner y llamar al método para el correspondiente tipo de dato.

       Numérico : 

       Tipo de Dato     Forma de Lectura
       
        byte                     .nextByte();
        short                    .nextShort();
        int                        .nextInt();
        long                     .nextLong();
        float                     .nextFloat();
        double                .nextDouble();

        Cadena de Caracteres:

       Tipo de Dato     Forma de Lectura

        char              No Aplica con Scanner.
        String          .next()
        String          .nextLine()

        Dato Lógico

       Tipo de Dato     Forma de Lectura

        boolean             .nextBoolean();

*Para leer Cadena de caracteres se utiliza el objeto String y los métodos antes mencionados. La diferencia radica en :

.next() - Lee una linea que el usuario introduzca hasta donde se encuentre un espacio.

   Ejemplo :
       String ejemplo = s.next()       // El usuario ingresa por teclado :   hola mundo

  Cuando el usuario imprima la variable ejemplo se mostrará :
    hola    // El método next() solo lee hasta encontrar un espacio en blanco.

.nextLine() - Lee una linea completa que introduzca el usuario, no importando si esta separada por espacios.

**Para leer un tipo de dato lógico, solo se acepta que el usuario ingrese true-false, tanto en mayúsculas como minúsculas, de otra manera se arrojará una excepción

Se crean 6 variables numéricas con sus respectivo tipo de dato:

byte                 
     byte a = s.nextByte();

short
     short corto = s.nextShort();

int
     int entero = s.nextInt();

long
     long largo = s.nextLong();

float
     float flotante= s.nextFloat();

double
     double doble = s.nextDouble();

Para finalizar, solo se mandan a imprimir. El código quedaría de la siguiente manera:

    public static void leerDatosNumericos() {
        
        Scanner s = new Scanner(System.in);
        
        byte a = s.nextByte();
        short corto = s.nextShort();
        int entero = s.nextInt();
        long largo = s.nextLong();
        float flotante = s.nextFloat();
        double doble = s.nextDouble();

        System.out.println("El byte es : " + a);
        System.out.println("El short es : " + corto);
        System.out.println("El int es : " + entero);
        System.out.println("El long es : " + largo);
        System.out.println("El float es : " + flotante);
        System.out.println("El double es : " + doble);
    }

Para leer cadenas de texto, se usan los métodos antes mencionados :

String cadena = s.next();
String cadena2 = s.nextLine();

*Problema : Al leer con Scanner, en algunos métodos de lectura dejan basura, ya sea el retorno de carro [\r]  o nueva linea [\n]. En el buffer del flujo de entrada se queda la basura mencionada.

**Para  resolver lo anterior , basta con poner el método leer Cadena Completa [s.nextLine()] para que quite la basura. El problema mencionado surge a la hora de leer con un .next() o después de leer un número y siempre, en ambos casos siga el leer un String. En C o C++ existe algo parecido, el fflush () , por si están acostumbrados a esos lenguajes una comparación.

Finalizando el método de lectura de cadenas de la siguiente manera:

    public static void leerCadenas() {
        Scanner s = new Scanner(System.in);

        String cadena1 = s.next();
        
        s.nextLine(); // Para limpiar el buffer
        
        String cadena2 = s.nextLine();

        System.out.println("Cadena 1 : " + cadena1);
        System.out.println("Cadena 2 : " + cadena2);
        
    }

Para leer tipos de dato lógicos es de la siguiente manera:

    public static void leerDatoLogico() {
        Scanner s = new Scanner(System.in);
        
        boolean boleano = s.nextBoolean();
        
        System.out.println("El boolean es : "+boleano);
    }

Con esto termina el tema. Lectura básica del teclado con el Objeto Scanner.