Verificar si la Entrada es un Entero

Introducción

Al desarrollar aplicaciones Java, la validación de la entrada del usuario es una tarea crucial. Este laboratorio demuestra tres métodos comunes para verificar si una entrada dada es un entero válido:

1. Usando el método Integer.parseInt()
2. Usando el método Scanner.hasNextInt()
3. Usando el método Character.isDigit()

Implementaremos cada método paso a paso y comprenderemos sus diferencias y casos de uso.

Configuración del Proyecto Java

Creemos un nuevo archivo Java para implementar nuestros métodos de validación de enteros.

1. Abre tu terminal y asegúrate de estar en el directorio /home/labex/project:

pwd

2. Crea un nuevo archivo Java llamado CheckInputInteger.java:

touch CheckInputInteger.java

3. Abre el archivo en tu editor de texto preferido y agrega la estructura básica de la clase:

import java.util.Scanner;

public class CheckInputInteger {
    public static void main(String[] args) {
        // Aquí agregaremos las llamadas a nuestros métodos
    }
}

Implementación de la Validación de Enteros Usando Integer.parseInt()

El método Integer.parseInt() intenta convertir una cadena en un entero. Si la conversión falla, lanza una NumberFormatException. Podemos usar este comportamiento para validar enteros.

1. Agrega el siguiente método a tu archivo CheckInputInteger.java:

// Agrega este método dentro de la clase CheckInputInteger
public static void checkUsingParseInt(String input) {
    try {
        // Intenta convertir la cadena de entrada a un entero
        Integer.parseInt(input);
        System.out.println(input + " es un entero válido");
    } catch (NumberFormatException e) {
        // Si la conversión falla, la entrada no es un entero válido
        System.out.println(input + " no es un entero válido");
    }
}

2. Actualiza el método main para probar esta implementación:

// Modifica el método main para probar esta implementación
public static void main(String[] args) {
    // Casos de prueba
    checkUsingParseInt("123");    // Entero válido
    checkUsingParseInt("12.34");  // No es un entero
    checkUsingParseInt("abc");    // No es un entero
}

3. El archivo debería verse así:

import java.util.Scanner;

public class CheckInputInteger {
    // Define el método dentro de la clase
    public static void checkUsingParseInt(String input) {
        try {
            // Intenta convertir la cadena de entrada a un entero
            Integer.parseInt(input);
            System.out.println(input + " es un entero válido");
        } catch (NumberFormatException e) {
            // Si la conversión falla, la entrada no es un entero válido
            System.out.println(input + " no es un entero válido");
        }
    }

    public static void main(String[] args) {
        // Casos de prueba
        checkUsingParseInt("123");    // Entero válido
        checkUsingParseInt("12.34");  // No es un entero
        checkUsingParseInt("abc");    // No es un entero
    }
}

4. Compila y ejecuta tu programa:

javac CheckInputInteger.java
java CheckInputInteger

Deberías ver la siguiente salida:

123 es un entero válido
12.34 no es un entero válido
abc no es un entero válido

Implementación de la Validación de Enteros Usando Scanner.hasNextInt()

La clase Scanner proporciona el método hasNextInt() para verificar si el siguiente token en la entrada puede ser interpretado como un entero. Este método es particularmente útil cuando se lee la entrada del usuario desde la consola.

1. Agrega el siguiente método a tu archivo CheckInputInteger.java, dentro de la clase CheckInputInteger:

public static void checkUsingScanner(String input) {
    Scanner scanner = new Scanner(input);
    if (scanner.hasNextInt()) {
        System.out.println(input + " es un entero válido");
    } else {
        System.out.println(input + " no es un entero válido");
    }
    scanner.close();
}

2. Actualiza el método main para incluir pruebas para esta implementación:

public static void main(String[] args) {
    // Casos de prueba anteriores
    checkUsingParseInt("123");
    checkUsingParseInt("12.34");
    checkUsingParseInt("abc");

    // Nuevos casos de prueba
    checkUsingScanner("456");     // Entero válido
    checkUsingScanner("-789");    // Entero válido
    checkUsingScanner("12.34");   // No es un entero
}

3. Compila y ejecuta tu programa:

javac CheckInputInteger.java
java CheckInputInteger

Deberías ver la siguiente salida:

456 es un entero válido
-789 es un entero válido
12.34 no es un entero válido

Esto demuestra que el método Scanner.hasNextInt() identifica correctamente los enteros válidos e inválidos.

Implementación de la Validación de Enteros Usando Character.isDigit()

El método Character.isDigit() verifica si un carácter es un dígito numérico. Podemos usar esto para validar enteros comprobando cada carácter en la cadena de entrada.

1. Agrega el siguiente método a tu archivo CheckInputInteger.java:

public static void checkUsingIsDigit(String input) {
    boolean isValid = true;

    // Maneja números negativos comprobando el primer carácter
    int startIndex = (input.charAt(0) == '-') ? 1 : 0;

    // Comprueba cada carácter
    for (int i = startIndex; i < input.length(); i++) {
        if (!Character.isDigit(input.charAt(i))) {
            isValid = false;
            break;
        }
    }

    if (isValid) {
        System.out.println(input + " es un entero válido");
    } else {
        System.out.println(input + " no es un entero válido");
    }
}

2. Actualiza el método main con los casos de prueba finales:

public static void main(String[] args) {
    // Casos de prueba anteriores
    checkUsingParseInt("123");
    checkUsingParseInt("12.34");
    checkUsingParseInt("abc");

    checkUsingScanner("456");
    checkUsingScanner("-789");
    checkUsingScanner("12.34");

    // Nuevos casos de prueba
    checkUsingIsDigit("789");     // Entero válido
    checkUsingIsDigit("-123");    // Entero válido
    checkUsingIsDigit("12.34");   // No es un entero
}

3. Compila y ejecuta la versión final de tu programa:

javac CheckInputInteger.java
java CheckInputInteger

Deberías ver la siguiente salida:

789 es un entero válido
-123 es un entero válido
12.34 no es un entero válido

Resumen

En este laboratorio, exploramos tres métodos diferentes para validar la entrada de enteros en Java:

1. El método Integer.parseInt(), que es simple pero requiere manejo de excepciones (exception handling)
2. El método Scanner.hasNextInt(), que es excelente para leer la entrada del usuario
3. El método Character.isDigit(), que proporciona validación carácter por carácter

Cada método tiene sus ventajas y casos de uso. El método parseInt() es bueno para la conversión simple de cadena a entero, Scanner.hasNextInt() es excelente para leer la entrada del usuario, y Character.isDigit() proporciona el mayor control sobre el proceso de validación.

Estas técnicas de validación son esenciales para desarrollar aplicaciones Java robustas que puedan manejar la entrada del usuario de forma segura y efectiva.