Cómo comprobar si un número es un entero en Java

JavaJavaBeginner
Practicar Ahora

💡 Este tutorial está traducido por IA desde la versión en inglés. Para ver la versión original, puedes hacer clic aquí

Introducción

En este laboratorio, aprenderás cómo determinar si un número es un entero en Java. Exploraremos diferentes técnicas, comenzando con el método Math.floor() para verificar valores enteros. Practicarás con los tipos de datos double y float para entender cómo se comporta este método con diferentes representaciones de punto flotante. Finalmente, cubriremos cómo manejar entradas de tipo cadena (string) y convertirlas a tipos numéricos antes de realizar la comprobación de enteros. Este laboratorio te proporcionará habilidades prácticas para validar datos numéricos en tus programas Java.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/SystemandDataProcessingGroup(["System and Data Processing"]) java(("Java")) -.-> java/BasicSyntaxGroup(["Basic Syntax"]) java(("Java")) -.-> java/ObjectOrientedandAdvancedConceptsGroup(["Object-Oriented and Advanced Concepts"]) java/BasicSyntaxGroup -.-> java/data_types("Data Types") java/BasicSyntaxGroup -.-> java/operators("Operators") java/BasicSyntaxGroup -.-> java/math("Math") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/user_input("User Input") java/SystemandDataProcessingGroup -.-> java/math_methods("Math Methods") subgraph Lab Skills java/data_types -.-> lab-559960{{"Cómo comprobar si un número es un entero en Java"}} java/operators -.-> lab-559960{{"Cómo comprobar si un número es un entero en Java"}} java/math -.-> lab-559960{{"Cómo comprobar si un número es un entero en Java"}} java/user_input -.-> lab-559960{{"Cómo comprobar si un número es un entero en Java"}} java/math_methods -.-> lab-559960{{"Cómo comprobar si un número es un entero en Java"}} end

Usar Math.floor() para Verificar Enteros

En este paso, exploraremos cómo determinar si un número es un entero en Java utilizando el método Math.floor(). Esta es una tarea común en la programación, especialmente cuando se trata de entrada de usuario o cálculos.

Primero, entendamos qué hace Math.floor(). El método Math.floor() en Java devuelve el mayor entero que es menor o igual al argumento. Por ejemplo, Math.floor(5.9) devolvería 5.0, y Math.floor(5.0) devolvería 5.0.

Podemos utilizar esta propiedad para verificar si un número es un entero. Si un número es un entero, aplicar Math.floor() a él resultará en el mismo número. Si el número tiene una parte fraccionaria, Math.floor() devolverá un entero menor.

Vamos a crear un nuevo archivo Java para practicar esto. Abre el WebIDE y crea un nuevo archivo llamado IntegerCheck.java en el directorio ~/project.

Ahora, copia y pega el siguiente código en el archivo IntegerCheck.java:

public class IntegerCheck {

    public static void main(String[] args) {
        double number1 = 10.0;
        double number2 = 10.5;

        // Check if number1 is an integer
        if (number1 == Math.floor(number1)) {
            System.out.println(number1 + " is an integer.");
        } else {
            System.out.println(number1 + " is not an integer.");
        }

        // Check if number2 is an integer
        if (number2 == Math.floor(number2)) {
            System.out.println(number2 + " is an integer.");
        } else {
            System.out.println(number2 + " is not an integer.");
        }
    }
}

Desglosemos el código:

  • double number1 = 10.0; y double number2 = 10.5;: Declaramos dos variables de tipo double, una que representa un valor entero y otra que representa un valor no entero.
  • if (number1 == Math.floor(number1)): Esta es la lógica central. Comparamos el número original (number1) con el resultado de Math.floor(number1). Si son iguales, el número es un entero.
  • System.out.println(...): Estas líneas imprimen el resultado en la consola.

Guarda el archivo IntegerCheck.java.

Ahora, compilaremos y ejecutaremos el programa. Abre la Terminal en el WebIDE y asegúrate de estar en el directorio ~/project.

Compila el código utilizando javac:

javac IntegerCheck.java

Si la compilación es exitosa, deberías ver un nuevo archivo llamado IntegerCheck.class en el directorio ~/project.

Ahora, ejecuta el código compilado utilizando java:

java IntegerCheck

Deberías ver la siguiente salida:

10.0 is an integer.
10.5 is not an integer.

Esta salida confirma que nuestra lógica utilizando Math.floor() identifica correctamente si un valor de tipo double representa un entero.

Prueba con Tipos Double y Float

En el paso anterior, utilizamos Math.floor() con valores de tipo double. Java tiene diferentes tipos de datos para representar números, incluyendo double y float. Ambos se utilizan para números de punto flotante (números con puntos decimales), pero double proporciona más precisión que float.

Modifiquemos nuestro programa IntegerCheck.java para probar con tipos double y float y ver cómo funciona Math.floor() con cada uno.

Abre el archivo IntegerCheck.java en el editor del WebIDE.

Reemplaza el código existente con el siguiente:

public class IntegerCheck {

    public static void main(String[] args) {
        double doubleNumber1 = 20.0;
        double doubleNumber2 = 20.75;

        float floatNumber1 = 30.0f; // Note the 'f' suffix for float literals
        float floatNumber2 = 30.25f;

        // Check if doubleNumber1 is an integer
        if (doubleNumber1 == Math.floor(doubleNumber1)) {
            System.out.println(doubleNumber1 + " (double) is an integer.");
        } else {
            System.out.println(doubleNumber1 + " (double) is not an integer.");
        }

        // Check if doubleNumber2 is an integer
        if (doubleNumber2 == Math.floor(doubleNumber2)) {
            System.out.println(doubleNumber2 + " (double) is an integer.");
        } else {
            System.out.println(doubleNumber2 + " (double) is not an integer.");
        }

        // Check if floatNumber1 is an integer
        // Math.floor() takes a double, so the float is promoted to double
        if (floatNumber1 == Math.floor(floatNumber1)) {
            System.out.println(floatNumber1 + " (float) is an integer.");
        } else {
            System.out.println(floatNumber1 + " (float) is not an integer.");
        }

        // Check if floatNumber2 is an integer
        if (floatNumber2 == Math.floor(floatNumber2)) {
            System.out.println(floatNumber2 + " (float) is an integer.");
        } else {
            System.out.println(floatNumber2 + " (float) is not an integer.");
        }
    }
}

Observa el sufijo f después de los valores literales de tipo float (30.0f, 30.25f). Esto es necesario en Java para indicar que el número es un float en lugar de un double (que es el valor predeterminado para los literales de punto flotante).

También, observa que Math.floor() está definido para tomar un argumento de tipo double. Cuando se pasa un float a Math.floor(), Java automáticamente promueve el float a un double antes de ejecutar el método. La comparación floatNumber1 == Math.floor(floatNumber1) sigue funcionando porque el resultado de Math.floor() (un double) se compara con floatNumber1 (que también se promueve a double para la comparación).

Guarda el archivo IntegerCheck.java.

Ahora, compila y ejecuta el programa modificado desde la Terminal en el directorio ~/project:

javac IntegerCheck.java
java IntegerCheck

Deberías ver una salida similar a esta:

20.0 (double) is an integer.
20.75 (double) is not an integer.
30.0 (float) is an integer.
30.25 (float) is not an integer.

Esto demuestra que nuestro método de comparación Math.floor() funciona correctamente para los tipos double y float.

Manejar la Conversión de Entrada de Tipo String

En aplicaciones del mundo real, a menudo es necesario obtener entrada del usuario, y esta entrada se lee típicamente como un String. Para realizar comprobaciones numéricas, como determinar si la entrada representa un entero, primero debes convertir el String a un tipo numérico, como double.

En este paso, modificaremos nuestro programa para tomar la entrada del usuario como un String, convertirla a un double y luego usar Math.floor() para comprobar si la entrada original representaba un entero.

Abre el archivo IntegerCheck.java en el editor del WebIDE.

Reemplaza el código existente con el siguiente:

import java.util.Scanner; // Import the Scanner class

public class IntegerCheck {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); // Create a Scanner object

        System.out.print("Enter a number: "); // Prompt the user for input
        String input = scanner.nextLine(); // Read user input as a String

        try {
            // Convert the String input to a double
            double number = Double.parseDouble(input);

            // Check if the number is an integer using Math.floor()
            if (number == Math.floor(number)) {
                System.out.println("The input '" + input + "' represents an integer.");
            } else {
                System.out.println("The input '" + input + "' does not represent an integer.");
            }

        } catch (NumberFormatException e) {
            // Handle cases where the input is not a valid number
            System.out.println("Invalid input: '" + input + "' is not a valid number.");
        } finally {
            scanner.close(); // Close the scanner
        }
    }
}

Veamos las nuevas partes del código:

  • import java.util.Scanner;: Esta línea importa la clase Scanner, que se utiliza para leer entrada desde la consola.
  • Scanner scanner = new Scanner(System.in);: Esto crea un objeto Scanner que lee entrada desde el flujo de entrada estándar (System.in), que normalmente es el teclado.
  • System.out.print("Enter a number: ");: Esta línea solicita al usuario que ingrese un número.
  • String input = scanner.nextLine();: Esto lee toda la línea de entrada ingresada por el usuario como un String y la almacena en la variable input.
  • try { ... } catch (NumberFormatException e) { ... }: Este es un bloque try-catch. Se utiliza para manejar posibles errores. En este caso, estamos intentando convertir la entrada String a un double. Si la entrada no es un número válido (por ejemplo, "hello"), se producirá una NumberFormatException, y se ejecutará el código dentro del bloque catch.
  • double number = Double.parseDouble(input);: Esta es la parte crucial de la conversión. Double.parseDouble() es un método estático de la clase Double que intenta convertir un String en un valor double.
  • finally { scanner.close(); }: El bloque finally asegura que se llame al método scanner.close(), liberando los recursos del sistema utilizados por el Scanner, independientemente de si se produjo una excepción o no.

Guarda el archivo IntegerCheck.java.

Ahora, compila y ejecuta el programa desde la Terminal en el directorio ~/project:

javac IntegerCheck.java
java IntegerCheck

El programa ahora esperará a que ingreses una entrada.

Intenta ingresar un entero, como 42, y presiona Enter. La salida debería ser:

Enter a number: 42
The input '42' represents an integer.

Ejecuta el programa de nuevo e ingresa un número no entero, como 3.14, y presiona Enter. La salida debería ser:

Enter a number: 3.14
The input '3.14' does not represent an integer.

Ejecuta el programa una vez más e ingresa algo que no sea un número, como test, y presiona Enter. La salida debería ser:

Enter a number: test
Invalid input: 'test' is not a valid number.

Esto demuestra cómo manejar la entrada del usuario como un String, convertirla a un tipo numérico y luego aplicar nuestra comprobación Math.floor() mientras también se manejan posibles errores de entrada no válida.

Resumen

En este laboratorio, aprendimos cómo comprobar si un número es un entero en Java utilizando el método Math.floor(). Exploramos el concepto de que para un entero, Math.floor() devuelve el mismo valor, mientras que para un número no entero, devuelve un entero menor. Implementamos esta lógica en un programa de Java, comparando el número original con el resultado de Math.floor() para determinar si es un entero.