Verificar se a Entrada é um Inteiro

Introdução

Ao desenvolver aplicações Java, validar a entrada do usuário é uma tarefa crucial. Este laboratório demonstra três métodos comuns para verificar se uma determinada entrada é um inteiro válido:

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

Implementaremos cada método passo a passo e entenderemos suas diferenças e casos de uso.

Configurando o Projeto Java

Vamos criar um novo arquivo Java para implementar nossos métodos de validação de inteiros.

1. Abra seu terminal e certifique-se de estar no diretório /home/labex/project:

pwd

2. Crie um novo arquivo Java chamado CheckInputInteger.java:

touch CheckInputInteger.java

3. Abra o arquivo em seu editor de texto preferido e adicione a estrutura básica da classe:

import java.util.Scanner;

public class CheckInputInteger {
    public static void main(String[] args) {
        // Adicionaremos nossas chamadas de método aqui
    }
}

Implementando a Validação de Inteiro Usando Integer.parseInt()

O método Integer.parseInt() tenta converter uma string em um inteiro. Se a conversão falhar, ele lança uma NumberFormatException. Podemos usar esse comportamento para validar inteiros.

1. Adicione o seguinte método ao seu arquivo CheckInputInteger.java:

// Adicione este método dentro da classe CheckInputInteger
public static void checkUsingParseInt(String input) {
    try {
        // Tentar converter a string de entrada em um inteiro
        Integer.parseInt(input);
        System.out.println(input + " is a valid integer");
    } catch (NumberFormatException e) {
        // Se a conversão falhar, a entrada não é um inteiro válido
        System.out.println(input + " is not a valid integer");
    }
}

2. Atualize o método main para testar esta implementação:

// Modifique o método main para testar esta implementação
public static void main(String[] args) {
    // Casos de teste
    checkUsingParseInt("123");    // Inteiro válido
    checkUsingParseInt("12.34");  // Não é um inteiro
    checkUsingParseInt("abc");    // Não é um inteiro
}

3. O arquivo deve ter a seguinte aparência:

import java.util.Scanner;

public class CheckInputInteger {
    // Defina o método dentro da classe
    public static void checkUsingParseInt(String input) {
        try {
            // Tentar converter a string de entrada em um inteiro
            Integer.parseInt(input);
            System.out.println(input + " is a valid integer");
        } catch (NumberFormatException e) {
            // Se a conversão falhar, a entrada não é um inteiro válido
            System.out.println(input + " is not a valid integer");
        }
    }

    public static void main(String[] args) {
        // Casos de teste
        checkUsingParseInt("123");    // Inteiro válido
        checkUsingParseInt("12.34");  // Não é um inteiro
        checkUsingParseInt("abc");    // Não é um inteiro
    }
}

4. Compile e execute seu programa:

javac CheckInputInteger.java
java CheckInputInteger

Você deve ver a seguinte saída:

123 is a valid integer
12.34 is not a valid integer
abc is not a valid integer

Implementando a Validação de Inteiro Usando Scanner.hasNextInt()

A classe Scanner fornece o método hasNextInt() para verificar se o próximo token na entrada pode ser interpretado como um inteiro. Este método é particularmente útil ao ler a entrada do usuário do console.

1. Adicione o seguinte método ao seu arquivo CheckInputInteger.java, dentro da classe CheckInputInteger:

public static void checkUsingScanner(String input) {
    Scanner scanner = new Scanner(input);
    if (scanner.hasNextInt()) {
        System.out.println(input + " is a valid integer");
    } else {
        System.out.println(input + " is not a valid integer");
    }
    scanner.close();
}

2. Atualize o método main para incluir testes para esta implementação:

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

    // Novos casos de teste
    checkUsingScanner("456");     // Inteiro válido
    checkUsingScanner("-789");    // Inteiro válido
    checkUsingScanner("12.34");   // Não é um inteiro
}

3. Compile e execute seu programa:

javac CheckInputInteger.java
java CheckInputInteger

Você deve ver a seguinte saída:

456 is a valid integer
-789 is a valid integer
12.34 is not a valid integer

Isso demonstra que o método Scanner.hasNextInt() identifica corretamente inteiros válidos e inválidos.

Implementando a Validação de Inteiro Usando Character.isDigit()

O método Character.isDigit() verifica se um caractere é um dígito numérico. Podemos usar isso para validar inteiros, verificando cada caractere na string de entrada.

1. Adicione o seguinte método ao seu arquivo CheckInputInteger.java:

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

    // Lidar com números negativos verificando o primeiro caractere
    int startIndex = (input.charAt(0) == '-') ? 1 : 0;

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

    if (isValid) {
        System.out.println(input + " is a valid integer");
    } else {
        System.out.println(input + " is not a valid integer");
    }
}

2. Atualize o método main com os casos de teste finais:

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

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

    // Novos casos de teste
    checkUsingIsDigit("789");     // Inteiro válido
    checkUsingIsDigit("-123");    // Inteiro válido
    checkUsingIsDigit("12.34");   // Não é um inteiro
}

3. Compile e execute a versão final do seu programa:

javac CheckInputInteger.java
java CheckInputInteger

Você deve ver a seguinte saída:

789 is a valid integer
-123 is a valid integer
12.34 is not a valid integer

Resumo

Neste laboratório, exploramos três métodos diferentes para validar a entrada de inteiros em Java:

1. O método Integer.parseInt(), que é simples, mas requer tratamento de exceções.
2. O método Scanner.hasNextInt(), que é excelente para ler a entrada do usuário.
3. O método Character.isDigit(), que fornece validação caractere por caractere.

Cada método tem suas vantagens e casos de uso. O método parseInt() é bom para conversão simples de string para inteiro, Scanner.hasNextInt() é excelente para ler a entrada do usuário, e Character.isDigit() oferece o maior controle sobre o processo de validação.

Essas técnicas de validação são essenciais para o desenvolvimento de aplicações Java robustas que podem lidar com a entrada do usuário de forma segura e eficaz.