Como Verificar se String é Número em Java: Guia Completo

Introdução

Neste laboratório, você aprenderá diferentes métodos para verificar se uma determinada string em Java representa um valor numérico. Começaremos explorando como tentar converter uma string em um inteiro e lidar com erros potenciais quando a string não for um número válido.

Em seguida, você descobrirá como aproveitar o poder das expressões regulares (regular expressions) para uma verificação numérica mais flexível e robusta. Por fim, estenderemos nossa compreensão para lidar com strings que representam números negativos e valores decimais, garantindo que nossas verificações numéricas sejam abrangentes.

Tentar Converter String para Inteiro

Nesta etapa, exploraremos como converter uma string (texto) em um inteiro (um número inteiro) em Java. Esta é uma tarefa comum em programação, especialmente quando você precisa obter entrada numérica de um usuário ou ler números de um arquivo.

Java fornece uma maneira integrada de fazer isso usando o método Integer.parseInt(). No entanto, o que acontece se a string realmente não representar um número válido? Vamos descobrir escrevendo um programa Java simples.

Abra o arquivo HelloJava.java no editor WebIDE, caso ainda não esteja aberto.
Substitua todo o conteúdo do arquivo pelo seguinte código:
```
public class HelloJava {
    public static void main(String[] args) {
        String numberString = "123";
        int number = Integer.parseInt(numberString);
        System.out.println("Successfully parsed: " + number);

        String invalidString = "abc";
        try {
            int invalidNumber = Integer.parseInt(invalidString);
            System.out.println("This line will not be reached.");
        } catch (NumberFormatException e) {
            System.out.println("Error: Could not parse '" + invalidString + "' to an integer.");
            System.out.println("Exception details: " + e.getMessage());
        }
    }
}
```
Vamos analisar as novas partes deste código:
- String numberString = "123";: Criamos uma variável de string numberString e atribuímos a ela o valor "123".
- int number = Integer.parseInt(numberString);: Este é o núcleo da conversão. Integer.parseInt() tenta converter a string "123" em um inteiro. Como "123" é uma representação de inteiro válida, isso terá sucesso, e o valor inteiro 123 será armazenado na variável number.
- String invalidString = "abc";: Criamos outra variável de string invalidString e atribuímos a ela o valor "abc". Esta string não representa um inteiro válido.
- try { ... } catch (NumberFormatException e) { ... }: Este é um bloco try-catch, que é usado para lidar com erros (exceções) em Java.
  - O código dentro do bloco try é onde colocamos a operação que pode causar um erro. Neste caso, é Integer.parseInt(invalidString).
  - Se Integer.parseInt("abc") falhar porque "abc" não é um número válido, ele "lançará" um NumberFormatException.
  - O bloco catch (NumberFormatException e) "captura" este tipo específico de exceção. O código dentro do bloco catch será então executado.
- System.out.println("Error: Could not parse '" + invalidString + "' to an integer.");: Esta linha será impressa se o NumberFormatException ocorrer.
- System.out.println("Exception details: " + e.getMessage());: Isso imprime uma mensagem mais específica sobre o erro fornecida pelo objeto de exceção e.
Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa no Terminal:
```
javac HelloJava.java
```
Se não houver erros, você não verá nenhuma saída.
Execute o programa compilado:
```
java HelloJava
```
Você deve ver uma saída semelhante a esta:
```
Successfully parsed: 123
Error: Could not parse 'abc' to an integer.
Exception details: For input string: "abc"
```
Esta saída mostra que a primeira tentativa de conversão foi bem-sucedida, mas a segunda tentativa com a string inválida "abc" resultou em um NumberFormatException, e nosso bloco catch o tratou graciosamente imprimindo uma mensagem de erro.

Isso demonstra a importância de lidar com erros potenciais ao converter strings em números, pois nem todas as strings podem ser convertidas com sucesso. Usar blocos try-catch é uma maneira padrão de gerenciar essas situações em Java.

Usar Expressão Regular para Verificação Numérica

Na etapa anterior, vimos que Integer.parseInt() lança uma exceção se a string não for um inteiro válido. Embora try-catch seja útil para lidar com o erro quando ele ocorre, às vezes você pode querer verificar se uma string pode ser convertida em um número antes de tentar a conversão. É aqui que as Expressões Regulares (Regex) são úteis.

Expressões Regulares são padrões poderosos usados para corresponder combinações de caracteres em strings. Podemos usar um padrão regex simples para verificar se uma string consiste apenas em dígitos.

Abra o arquivo HelloJava.java no editor WebIDE.

Substitua todo o conteúdo do arquivo pelo seguinte código:

public class HelloJava {
    public static void main(String[] args) {
        String numberString = "123";
        String invalidString = "abc";
        String mixedString = "123a";

        System.out.println("Checking string: \"" + numberString + "\"");
        if (numberString.matches("\\d+")) {
            System.out.println("  Matches the pattern (contains only digits).");
            int number = Integer.parseInt(numberString);
            System.out.println("  Parsed integer: " + number);
        } else {
            System.out.println("  Does not match the pattern.");
        }

        System.out.println("\nChecking string: \"" + invalidString + "\"");
        if (invalidString.matches("\\d+")) {
            System.out.println("  Matches the pattern (contains only digits).");
        } else {
            System.out.println("  Does not match the pattern.");
        }

        System.out.println("\nChecking string: \"" + mixedString + "\"");
        if (mixedString.matches("\\d+")) {
            System.out.println("  Matches the pattern (contains only digits).");
        } else {
            System.out.println("  Does not match the pattern.");
        }
    }
}

Vamos detalhar as novas partes:

numberString.matches("\\d+"): Esta é a parte chave. O método matches() está disponível em todos os objetos String em Java. Ele verifica se a string inteira corresponde ao padrão de expressão regular fornecido.
"\\d+": Este é o padrão de expressão regular.
- \\d: Isso corresponde a qualquer dígito (0 a 9). Usamos \\ porque \ é um caractere especial em strings Java, então precisamos escapá-lo.
- +: Este é um quantificador que significa "um ou mais" do elemento anterior. Portanto, \\d+ significa "um ou mais dígitos".
A instrução if verifica o resultado de matches(). Se retornar true, significa que a string consiste inteiramente em um ou mais dígitos. Se retornar false, significa que a string contém caracteres diferentes de dígitos ou está vazia.

Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa no Terminal:
```
javac HelloJava.java
```
Você não deve ver nenhuma saída se a compilação for bem-sucedida.
Execute o programa compilado:
```
java HelloJava
```
Você deve ver uma saída semelhante a esta:
```
Checking string: "123"
  Matches the pattern (contains only digits).
  Parsed integer: 123

Checking string: "abc"
  Does not match the pattern.

Checking string: "123a"
  Does not match the pattern.
```
Como você pode ver, a verificação matches("\\d+") identificou corretamente "123" como contendo apenas dígitos, enquanto "abc" e "123a" não corresponderam ao padrão. Essa abordagem permite que você valide o formato da string antes de tentar convertê-la, potencialmente evitando NumberFormatException em alguns casos.

Lidar com Números Negativos e Decimais

Nas etapas anteriores, nos concentramos em converter números inteiros positivos. No entanto, os números também podem ser negativos ou ter casas decimais. Nesta etapa, aprenderemos como lidar com esses casos ao converter strings em números em Java.

Java fornece métodos diferentes para converter diferentes tipos de números:

Integer.parseInt(): Para números inteiros (integers).
Double.parseDouble(): Para números com casas decimais (números de ponto flutuante).

Vamos modificar nosso programa para lidar com inteiros negativos e números decimais.

Abra o arquivo HelloJava.java no editor WebIDE.

Substitua todo o conteúdo do arquivo pelo seguinte código:

public class HelloJava {
    public static void main(String[] args) {
        String positiveIntString = "456";
        String negativeIntString = "-789";
        String decimalString = "123.45";
        String invalidString = "not a number";

        // Handling Integers (positive and negative)
        System.out.println("Attempting to parse integers:");
        try {
            int positiveInt = Integer.parseInt(positiveIntString);
            System.out.println("  Parsed '" + positiveIntString + "' as integer: " + positiveInt);
        } catch (NumberFormatException e) {
            System.out.println("  Could not parse '" + positiveIntString + "' as integer.");
        }

        try {
            int negativeInt = Integer.parseInt(negativeIntString);
            System.out.println("  Parsed '" + negativeIntString + "' as integer: " + negativeInt);
        } catch (NumberFormatException e) {
            System.out.println("  Could not parse '" + negativeIntString + "' as integer.");
        }

        try {
            int decimalAsInt = Integer.parseInt(decimalString);
            System.out.println("  Parsed '" + decimalString + "' as integer: " + decimalAsInt);
        } catch (NumberFormatException e) {
            System.out.println("  Could not parse '" + decimalString + "' as integer.");
        }

        // Handling Decimal Numbers
        System.out.println("\nAttempting to parse decimal numbers:");
        try {
            double decimal = Double.parseDouble(decimalString);
            System.out.println("  Parsed '" + decimalString + "' as double: " + decimal);
        } catch (NumberFormatException e) {
            System.out.println("  Could not parse '" + decimalString + "' as double.");
        }

        try {
            double intAsDouble = Double.parseDouble(positiveIntString);
            System.out.println("  Parsed '" + positiveIntString + "' as double: " + intAsDouble);
        } catch (NumberFormatException e) {
            System.out.println("  Could not parse '" + positiveIntString + "' as double.");
        }

         try {
            double invalidAsDouble = Double.parseDouble(invalidString);
            System.out.println("  Parsed '" + invalidString + "' as double: " + invalidAsDouble);
        } catch (NumberFormatException e) {
            System.out.println("  Could not parse '" + invalidString + "' as double.");
        }
    }
}

Aqui está o que está acontecendo:

Agora temos strings representando um inteiro positivo, um inteiro negativo, um número decimal e uma string inválida.
Usamos Integer.parseInt() dentro de blocos try-catch para tentar converter as strings em inteiros. Observe que Integer.parseInt() pode lidar com o sinal negativo (-). No entanto, ele lançará um NumberFormatException se a string contiver uma casa decimal ou caracteres que não sejam dígitos.
Usamos Double.parseDouble() dentro de blocos try-catch para tentar converter as strings em números decimais (doubles). Double.parseDouble() pode lidar com inteiros e números com casas decimais. Ele lançará um NumberFormatException para strings que não são representações válidas de um double.

Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa no Terminal:
```
javac HelloJava.java
```
Você não deve ver nenhuma saída se a compilação for bem-sucedida.
Execute o programa compilado:
```
java HelloJava
```
Você deve ver uma saída semelhante a esta:
```
Attempting to parse integers:
  Parsed '456' as integer: 456
  Parsed '-789' as integer: -789
  Could not parse '123.45' as integer.

Attempting to parse decimal numbers:
  Parsed '123.45' as double: 123.45
  Parsed '456' as double: 456.0
  Could not parse 'not a number' as double.
```
Esta saída mostra que Integer.parseInt() converteu corretamente os inteiros positivos e negativos, mas falhou na string decimal. Double.parseDouble() converteu com sucesso a string decimal e a string inteira (representando-a como um double, por exemplo, 456.0), mas falhou na string inválida.

Esta etapa demonstra como usar os métodos de conversão apropriados para diferentes tipos de números e reforça a importância de usar blocos try-catch para lidar com erros potenciais NumberFormatException quando a string de entrada pode não estar no formato esperado.

Resumo

Neste laboratório, aprendemos como verificar se uma string é numérica em Java. Primeiro, exploramos o uso de Integer.parseInt() para tentar converter uma string em um inteiro, entendendo que este método lança um NumberFormatException se a string não for uma representação inteira válida. Vimos como lidar com essa exceção usando um bloco try-catch para gerenciar strings não numéricas de forma elegante.

Com base nisso, aprendemos então como usar expressões regulares como uma abordagem mais flexível para verificar strings numéricas, que podem lidar com vários formatos. Finalmente, estendemos nossa compreensão para incluir o tratamento de números negativos e decimais ao determinar se uma string representa um valor numérico.

Como Verificar se uma String é Numérica em Java

Introdução

Tentar Converter String para Inteiro

Usar Expressão Regular para Verificação Numérica

Lidar com Números Negativos e Decimais

Resumo