Como Verificar se um Número é um Inteiro em Java

JavaBeginner
Pratique Agora

Introdução

Neste laboratório, você aprenderá como determinar se um número é um inteiro em Java. Exploraremos diferentes técnicas, começando com o método Math.floor() para verificar valores inteiros. Você praticará com os tipos de dados double e float para entender como este método se comporta com diferentes representações de ponto flutuante. Finalmente, abordaremos como lidar com entradas de string e convertê-las em tipos numéricos antes de realizar a verificação de inteiro. Este laboratório fornecerá habilidades práticas para validar dados numéricos em seus programas Java.

Usar Math.floor() para Verificar Inteiro

In this step, we will explore how to determine if a number is an integer in Java using the Math.floor() method. This is a common task in programming, especially when dealing with user input or calculations.

First, let's understand what Math.floor() does. The Math.floor() method in Java returns the largest integer that is less than or equal to the argument. For example, Math.floor(5.9) would return 5.0, and Math.floor(5.0) would return 5.0.

We can use this property to check if a number is an integer. If a number is an integer, applying Math.floor() to it will result in the same number. If the number has a fractional part, Math.floor() will return a smaller integer.

Let's create a new Java file to practice this. Open the WebIDE and create a new file named IntegerCheck.java in the ~/project directory.

Now, copy and paste the following code into the IntegerCheck.java file:

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.");
        }
    }
}

Let's break down the code:

  • double number1 = 10.0; and double number2 = 10.5;: We declare two double variables, one representing an integer value and one representing a non-integer value.
  • if (number1 == Math.floor(number1)): This is the core logic. We compare the original number (number1) with the result of Math.floor(number1). If they are equal, the number is an integer.
  • System.out.println(...): These lines print the result to the console.

Save the IntegerCheck.java file.

Now, let's compile and run the program. Open the Terminal in WebIDE and make sure you are in the ~/project directory.

Compile the code using javac:

javac IntegerCheck.java

If the compilation is successful, you should see a new file named IntegerCheck.class in the ~/project directory.

Now, run the compiled code using java:

java IntegerCheck

You should see the following output:

10.0 is an integer.
10.5 is not an integer.

This output confirms that our logic using Math.floor() correctly identifies whether a double value represents an integer.

Testar com Tipos Double e Float

No passo anterior, usamos Math.floor() com valores double. Java possui diferentes tipos de dados para representar números, incluindo double e float. Ambos são usados para números de ponto flutuante (números com casas decimais), mas double fornece mais precisão do que float.

Vamos modificar nosso programa IntegerCheck.java para testar com os tipos double e float para ver como Math.floor() funciona com cada um.

Abra o arquivo IntegerCheck.java no editor WebIDE.

Substitua o código existente pelo seguinte:

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.");
        }
    }
}

Observe o sufixo f após os valores literais float (30.0f, 30.25f). Isso é necessário em Java para indicar que o número é um float em vez de um double (que é o padrão para literais de ponto flutuante).

Além disso, observe que Math.floor() é definido para receber um argumento double. Quando você passa um float para Math.floor(), Java automaticamente promove o float para um double antes que o método seja executado. A comparação floatNumber1 == Math.floor(floatNumber1) ainda funciona porque o resultado de Math.floor() (um double) é comparado com o floatNumber1 (que também é promovido para double para a comparação).

Salve o arquivo IntegerCheck.java.

Agora, compile e execute o programa modificado a partir do Terminal no diretório ~/project:

javac IntegerCheck.java
java IntegerCheck

Você deve ver uma saída semelhante 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.

Isso demonstra que nosso método de comparação Math.floor() funciona corretamente para os tipos double e float.

Lidar com a Conversão de Entrada de String

Em aplicações do mundo real, você frequentemente precisa obter entrada do usuário, e essa entrada é tipicamente lida como uma String. Para realizar verificações numéricas, como determinar se a entrada representa um inteiro, você primeiro precisa converter a String para um tipo numérico, como double.

Neste passo, modificaremos nosso programa para receber a entrada do usuário como uma String, convertê-la para double e, em seguida, usar Math.floor() para verificar se a entrada original representava um inteiro.

Abra o arquivo IntegerCheck.java no editor WebIDE.

Substitua o código existente pelo seguinte:

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
        }
    }
}

Vamos analisar as novas partes do código:

  • import java.util.Scanner;: Esta linha importa a classe Scanner, que é usada para ler a entrada do console.
  • Scanner scanner = new Scanner(System.in);: Isso cria um objeto Scanner que lê a entrada do fluxo de entrada padrão (System.in), que normalmente é o teclado.
  • System.out.print("Enter a number: ");: Esta linha solicita que o usuário insira um número.
  • String input = scanner.nextLine();: Isso lê a linha inteira de entrada inserida pelo usuário como uma String e a armazena na variável input.
  • try { ... } catch (NumberFormatException e) { ... }: Este é um bloco try-catch. Ele é usado para lidar com possíveis erros. Neste caso, estamos tentando converter a entrada String para um double. Se a entrada não for um número válido (por exemplo, "hello"), uma NumberFormatException ocorrerá, e o código dentro do bloco catch será executado.
  • double number = Double.parseDouble(input);: Esta é a parte crucial para a conversão. Double.parseDouble() é um método estático da classe Double que tenta converter uma String em um valor double.
  • finally { scanner.close(); }: O bloco finally garante que o método scanner.close() seja chamado, liberando os recursos do sistema usados pelo Scanner, independentemente de uma exceção ter ocorrido ou não.

Salve o arquivo IntegerCheck.java.

Agora, compile e execute o programa a partir do Terminal no diretório ~/project:

javac IntegerCheck.java
java IntegerCheck

O programa agora esperará que você insira uma entrada.

Tente inserir um inteiro, como 42, e pressione Enter. A saída deve ser:

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

Execute o programa novamente e insira um número não inteiro, como 3.14, e pressione Enter. A saída deve ser:

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

Execute o programa mais uma vez e insira algo que não seja um número, como test, e pressione Enter. A saída deve ser:

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

Isso demonstra como lidar com a entrada do usuário como uma String, convertê-la para um tipo numérico e, em seguida, aplicar nossa verificação Math.floor() enquanto também lida com possíveis erros de entrada inválida.

Resumo

Neste laboratório, aprendemos como verificar se um número é um inteiro em Java usando o método Math.floor(). Exploramos o conceito de que, para um inteiro, Math.floor() retorna o mesmo valor, enquanto para um não inteiro, ele retorna um inteiro menor. Implementamos essa lógica em um programa Java, comparando o número original com o resultado de Math.floor() para determinar se é um inteiro.