Como Verificar se um Número é um Long em Java - Guia Prático

Introdução

Neste laboratório, exploraremos diferentes métodos para determinar se um número em Java é do tipo Long. Começaremos aprendendo como usar o operador instanceof para verificar se um objeto é uma instância da classe wrapper Long.

Em seguida, mergulharemos na análise de strings para valores Long, compreendendo como lidar com possíveis erros durante esse processo. Por fim, diferenciaremos entre os tipos Long e Integer, destacando suas principais distinções e como trabalhar com cada um de forma eficaz.

Verificar Instância da Classe Long

Nesta etapa, exploraremos a classe Long em Java e aprenderemos como verificar se um objeto é uma instância da classe Long.

Em Java, tipos de dados primitivos como long não são objetos. No entanto, Java fornece classes wrapper para cada tipo primitivo, e Long é a classe wrapper para o tipo primitivo long. As classes wrapper nos permitem tratar valores primitivos como objetos, o que é útil em muitas situações, como ao trabalhar com coleções.

Para verificar se um objeto é uma instância de uma classe específica, usamos o operador instanceof. O operador instanceof é um operador binário usado para testar se um objeto é uma instância de uma classe, uma subclasse ou uma interface.

Vamos criar um programa Java simples para demonstrar como usar o operador instanceof com a classe Long.

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) {
        // Create a Long object
        Long myLong = 12345L;

        // Create an Integer object
        Integer myInteger = 67890;

        // Check if myLong is an instance of Long
        if (myLong instanceof Long) {
            System.out.println("myLong is an instance of Long.");
        } else {
            System.out.println("myLong is not an instance of Long.");
        }

        // Check if myInteger is an instance of Long
        if (myInteger instanceof Long) {
            System.out.println("myInteger is an instance of Long.");
        } else {
            System.out.println("myInteger is not an instance of Long.");
        }
    }
}

Neste código:

Criamos um objeto Long chamado myLong com o valor 12345L. O sufixo L indica que é um literal long.
Criamos um objeto Integer chamado myInteger com o valor 67890.
Usamos o operador instanceof para verificar se myLong é uma instância de Long.
Usamos o operador instanceof para verificar se myInteger é uma instância de Long.

Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa executando o seguinte comando no Terminal:
```
javac HelloJava.java
```
Se a compilação for bem-sucedida, você não verá nenhuma saída.

Execute o programa compilado:

java HelloJava

Você deve ver a seguinte saída:

myLong is an instance of Long.
myInteger is not an instance of Long.

Esta saída confirma que myLong, que criamos como um objeto Long, é de fato uma instância da classe Long, enquanto myInteger, criado como um objeto Integer, não é.

Converter String para Long

Nesta etapa, aprenderemos como converter uma representação String de um número em um objeto Long ou em um tipo primitivo long. Esta é uma tarefa comum quando você recebe dados numéricos como texto, por exemplo, a partir da entrada do usuário ou de um arquivo.

A classe Long fornece métodos estáticos para realizar essa conversão. Os dois métodos mais comumente usados são:

Long.parseLong(String s): Este método analisa o argumento string como um long decimal com sinal. Ele retorna um valor primitivo long.
Long.valueOf(String s): Este método retorna um objeto Long que contém o valor representado pelo argumento string.

Vamos modificar nosso programa HelloJava.java para demonstrar como analisar uma string para um long e um Long.

Abra o arquivo HelloJava.java no editor WebIDE.

Substitua o código existente pelo seguinte:

public class HelloJava {
    public static void main(String[] args) {
        String numberString = "9876543210";

        // Parse the string to a primitive long
        long primitiveLong = Long.parseLong(numberString);
        System.out.println("Parsed primitive long: " + primitiveLong);

        // Parse the string to a Long object
        Long longObject = Long.valueOf(numberString);
        System.out.println("Parsed Long object: " + longObject);

        // Demonstrate parsing a different string
        String anotherNumberString = "112233445566";
        long anotherPrimitiveLong = Long.parseLong(anotherNumberString);
        System.out.println("Parsed another primitive long: " + anotherPrimitiveLong);
    }
}

Neste código:

Definimos uma variável String numberString contendo o texto "9876543210".
Usamos Long.parseLong() para converter numberString em um long primitivo e armazená-lo em primitiveLong.
Usamos Long.valueOf() para converter numberString em um objeto Long e armazená-lo em longObject.
Demonstramos a análise de outra string para mostrar a flexibilidade do método.

Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa:
```
javac HelloJava.java
```
Certifique-se de que não haja erros de compilação.

Execute o programa:

java HelloJava

Você deve ver uma saída semelhante a esta:

Parsed primitive long: 9876543210
Parsed Long object: 9876543210
Parsed another primitive long: 112233445566

Esta saída mostra que tanto Long.parseLong() quanto Long.valueOf() converteram com sucesso as representações string de números em seus valores long e Long correspondentes.

É importante notar que, se a string não contiver um número válido que possa ser representado como um long, esses métodos lançarão uma NumberFormatException. Não abordaremos o tratamento de erros neste laboratório básico, mas é algo a ter em mente para aplicações do mundo real.

Diferenciar Long de Integer

Nesta etapa, focaremos em entender as principais diferenças entre long (e sua classe wrapper Long) e int (e sua classe wrapper Integer) em Java. Embora ambos sejam usados para armazenar números inteiros, eles diferem significativamente na faixa de valores que podem conter e no uso de memória.

A principal diferença reside em seu tamanho:

int: Um int é um inteiro de complemento de dois com sinal de 32 bits. Isso significa que ele pode armazenar valores que variam de -2.147.483.648 a 2.147.483.647.
long: Um long é um inteiro de complemento de dois com sinal de 64 bits. Isso permite que ele armazene uma gama muito maior de valores, de -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807.

Vamos modificar nosso programa HelloJava.java para ilustrar essa diferença.

Abra o arquivo HelloJava.java no editor WebIDE.

Substitua o código existente pelo seguinte:

public class HelloJava {
    public static void main(String[] args) {
        // Maximum value for int
        int maxInt = Integer.MAX_VALUE;
        System.out.println("Maximum value of int: " + maxInt);

        // Trying to store a value larger than maxInt in an int (will cause error if uncommented)
        // int tooBigInt = 2147483648; // This line would cause a compilation error

        // A value larger than maxInt, stored in a long
        long largeLong = 2147483648L; // Note the 'L' suffix
        System.out.println("A large value stored in long: " + largeLong);

        // Maximum value for long
        long maxLong = Long.MAX_VALUE;
        System.out.println("Maximum value of long: " + maxLong);

        // Demonstrating the size difference with literals
        System.out.println("Size of int in bits: " + Integer.SIZE);
        System.out.println("Size of long in bits: " + Long.SIZE);
    }
}

Neste código:

Imprimimos o valor máximo que um int pode conter usando Integer.MAX_VALUE.
Mostramos uma linha comentada que causaria um erro de compilação se não fosse comentada, porque o valor 2147483648 é maior que o valor máximo de um int.
Armazenamos o mesmo valor grande em uma variável long largeLong, usando o sufixo L para indicar que é um literal long.
Imprimimos o valor máximo que um long pode conter usando Long.MAX_VALUE.
Imprimimos o tamanho de int e long em bits usando Integer.SIZE e Long.SIZE.

Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa:
```
javac HelloJava.java
```
Certifique-se de que não haja erros de compilação.

Execute o programa:

java HelloJava

Você deve ver uma saída semelhante a esta:

Maximum value of int: 2147483647
A large value stored in long: 2147483648
Maximum value of long: 9223372036854775807
Size of int in bits: 32
Size of long in bits: 64

Esta saída demonstra claramente que long pode conter valores significativamente maiores que int e confirma seus respectivos tamanhos em bits. Ao escolher entre int e long, considere a faixa de valores que sua variável precisa armazenar. Use int para números menores para economizar memória e long para números maiores.

Resumo

Neste laboratório, aprendemos como verificar se um número é um Long em Java. Exploramos a classe wrapper Long e sua relação com o tipo primitivo long. Especificamente, focamos no uso do operador instanceof para determinar se um objeto é uma instância da classe Long. Por meio de um exemplo prático, demonstramos como aplicar instanceof para diferenciar entre objetos Long e Integer.