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

Introducción

En este laboratorio, exploraremos diferentes métodos para determinar si un número en Java es del tipo Long. Comenzaremos aprendiendo cómo usar el operador instanceof para verificar si un objeto es una instancia de la clase envolvente Long.

Luego, profundizaremos en la conversión de cadenas a valores Long, y entenderemos cómo manejar los posibles errores durante este proceso. Finalmente, distinguiremos entre los tipos Long y Integer, destacando sus diferencias clave y cómo trabajar eficazmente con cada uno.

Comprobar instancia de la clase Long

En este paso, exploraremos la clase Long en Java y aprenderemos cómo verificar si un objeto es una instancia de la clase Long.

En Java, los tipos de datos primitivos como long no son objetos. Sin embargo, Java proporciona clases envolventes (wrapper classes) para cada tipo primitivo, y Long es la clase envolvente para el tipo primitivo long. Las clases envolventes nos permiten tratar los valores primitivos como objetos, lo cual es útil en muchas situaciones, como cuando trabajamos con colecciones.

Para verificar si un objeto es una instancia de una clase específica, usamos el operador instanceof. El operador instanceof es un operador binario que se utiliza para probar si un objeto es una instancia de una clase, una subclase o una interfaz.

Vamos a crear un simple programa en Java para demostrar cómo usar el operador instanceof con la clase Long.

Abra el archivo HelloJava.java en el editor WebIDE si no está abierto.

Reemplace todo el contenido del archivo con el siguiente 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.");
        }
    }
}

En este código:

Creamos un objeto Long llamado myLong con el valor 12345L. El sufijo L indica que es un literal long.
Creamos un objeto Integer llamado myInteger con el valor 67890.
Usamos el operador instanceof para verificar si myLong es una instancia de Long.
Usamos el operador instanceof para verificar si myInteger es una instancia de Long.

Guarde el archivo (Ctrl+S o Cmd+S).
Compile el programa ejecutando el siguiente comando en la Terminal:
```
javac HelloJava.java
```
Si la compilación es exitosa, no verá ninguna salida.

Ejecute el programa compilado:

java HelloJava

Debería ver la siguiente salida:

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

Esta salida confirma que myLong, que creamos como un objeto Long, es en realidad una instancia de la clase Long, mientras que myInteger, creado como un objeto Integer, no lo es.

Convertir cadena a Long

En este paso, aprenderemos cómo convertir una representación de número en formato String a un objeto Long o al tipo primitivo long. Esta es una tarea común cuando se reciben datos numéricos en forma de texto, por ejemplo, a través de la entrada del usuario o desde un archivo.

La clase Long proporciona métodos estáticos para realizar esta conversión. Los dos métodos más utilizados son:

Long.parseLong(String s): Este método analiza el argumento de tipo cadena como un número long decimal con signo. Devuelve un valor primitivo long.
Long.valueOf(String s): Este método devuelve un objeto Long que contiene el valor representado por el argumento de tipo cadena.

Modifiquemos nuestro programa HelloJava.java para demostrar cómo convertir una cadena a un long y a un objeto Long.

Abra el archivo HelloJava.java en el editor WebIDE.

Reemplace el código existente con el siguiente:

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

En este código:

Definimos una variable de tipo String llamada numberString que contiene el texto "9876543210".
Usamos Long.parseLong() para convertir numberString en un long primitivo y lo almacenamos en primitiveLong.
Usamos Long.valueOf() para convertir numberString en un objeto Long y lo almacenamos en longObject.
Demostramos la conversión de otra cadena para mostrar la flexibilidad del método.

Guarde el archivo (Ctrl+S o Cmd+S).
Compile el programa:
```
javac HelloJava.java
```
Asegúrese de que no haya errores de compilación.

Ejecute el programa:

java HelloJava

Debería ver una salida similar a esta:

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

Esta salida muestra que tanto Long.parseLong() como Long.valueOf() convirtieron con éxito las representaciones de números en cadenas a sus correspondientes valores long y Long.

Es importante tener en cuenta que si la cadena no contiene un número válido que se pueda representar como un long, estos métodos lanzarán una NumberFormatException. No cubriremos el manejo de errores en este laboratorio básico, pero es algo a tener en cuenta para aplicaciones del mundo real.

Diferenciar Long de Integer

En este paso, nos centraremos en entender las diferencias clave entre long (y su clase envolvente Long) y int (y su clase envolvente Integer) en Java. Si bien ambos se utilizan para almacenar números enteros, difieren significativamente en el rango de valores que pueden contener y en su uso de memoria.

La principal diferencia radica en su tamaño:

int: Un int es un entero con signo de 32 bits en complemento a dos. Esto significa que puede almacenar valores que van desde -2.147.483.648 hasta 2.147.483.647.
long: Un long es un entero con signo de 64 bits en complemento a dos. Esto le permite almacenar un rango de valores mucho más amplio, desde -9.223.372.036.854.775.808 hasta 9.223.372.036.854.775.807.

Modifiquemos nuestro programa HelloJava.java para ilustrar esta diferencia.

Abra el archivo HelloJava.java en el editor WebIDE.

Reemplace el código existente con el siguiente:

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

En este código:

Imprimimos el valor máximo que un int puede contener utilizando Integer.MAX_VALUE.
Mostramos una línea comentada que causaría un error de compilación si se descomentara, porque el valor 2147483648 es mayor que el valor máximo de un int.
Almacenamos el mismo valor grande en una variable long llamada largeLong, utilizando el sufijo L para indicar que es un literal long.
Imprimimos el valor máximo que un long puede contener utilizando Long.MAX_VALUE.
Imprimimos el tamaño de int y long en bits utilizando Integer.SIZE y Long.SIZE.

Guarde el archivo (Ctrl+S o Cmd+S).
Compile el programa:
```
javac HelloJava.java
```
Asegúrese de que no haya errores de compilación.

Ejecute el programa:

java HelloJava

Debería ver una salida similar 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 salida demuestra claramente que long puede contener valores significativamente más grandes que int, y confirma sus respectivos tamaños en bits. Cuando elija entre int y long, considere el rango de valores que necesita almacenar en su variable. Utilice int para números más pequeños para ahorrar memoria, y long para números más grandes.

Resumen

En este laboratorio, aprendimos cómo verificar si un número es un Long en Java. Exploramos la clase envolvente Long y su relación con el tipo primitivo long. Nos centramos específicamente en el uso del operador instanceof para determinar si un objeto es una instancia de la clase Long. A través de un ejemplo práctico, demostramos cómo aplicar instanceof para diferenciar entre objetos Long e Integer.