Cómo comprobar si un entero está dentro del rango de short en Java

Introducción

En este laboratorio, aprenderás cómo verificar si un valor entero está dentro del rango del tipo de dato short en Java. Comenzaremos por entender el rango definido de short (-32768 a 32767) y luego procederemos a verificar valores enteros contra estos límites. Finalmente, exploraremos cómo manejar efectivamente los valores límite.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/BasicSyntaxGroup(["Basic Syntax"]) java/BasicSyntaxGroup -.-> java/data_types("Data Types") java/BasicSyntaxGroup -.-> java/type_casting("Type Casting") subgraph Lab Skills java/data_types -.-> lab-560007{{"Cómo comprobar si un entero está dentro del rango de short en Java"}} java/type_casting -.-> lab-560007{{"Cómo comprobar si un entero está dentro del rango de short en Java"}} end

Establecer el rango de short (-32768 a 32767)

En este paso, exploraremos el tipo de dato short en Java y entenderemos su rango. En programación, los tipos de datos se utilizan para clasificar diferentes tipos de datos que una variable puede contener. El tipo de dato short es un entero con signo de 16 bits en complemento a dos. Esto significa que puede almacenar números enteros, tanto positivos como negativos, dentro de un rango específico.

El rango de un short en Java es desde -32.768 hasta 32.767. Comprender estos límites es crucial para evitar errores como overflow o underflow, que ocurren cuando se intenta almacenar un valor fuera del rango del tipo de dato.

Vamos a crear un simple programa en Java para ver en acción el tipo de dato short y observar sus límites.

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

Reemplaza todo el contenido del archivo con el siguiente código:

public class HelloJava {
    public static void main(String[] args) {
        // Declare and initialize a short variable
        short myShort = 10000;
        System.out.println("My short variable: " + myShort);

        // Demonstrate the maximum value of short
        short maxShort = 32767;
        System.out.println("Maximum short value: " + maxShort);

        // Demonstrate the minimum value of short
        short minShort = -32768;
        System.out.println("Minimum short value: " + minShort);
    }
}

En este código:

Declaramos una variable myShort de tipo short y le asignamos el valor 10000.
Luego declaramos maxShort y minShort y les asignamos los valores máximo y mínimo que un short puede contener.
Usamos System.out.println() para imprimir los valores de estas variables en la consola.

Guarda el archivo (Ctrl+S o Cmd+S).
Ahora, vamos a compilar nuestro programa. Abre la Terminal en la parte inferior del WebIDE y asegúrate de estar en el directorio ~/project. Si no lo estás, utiliza el comando cd ~/project. Luego, compila el código utilizando el comando javac:
```
javac HelloJava.java
```
Si no hay errores, la compilación es exitosa y se creará un archivo HelloJava.class en el directorio ~/project.
Finalmente, ejecuta el programa compilado utilizando el comando java:
```
java HelloJava
```
Deberías ver la siguiente salida en la Terminal:
```
My short variable: 10000
Maximum short value: 32767
Minimum short value: -32768
```

Esta salida confirma que nuestras variables short están conteniendo los valores esperados dentro del rango definido. En el siguiente paso, exploraremos qué sucede cuando intentamos asignar valores fuera de este rango.

Verificar un entero contra los límites de short

En el paso anterior, vimos cómo declarar y usar variables short dentro de su rango válido. Ahora, exploremos qué sucede cuando intentamos asignar un valor que está fuera del rango de short a una variable short.

Java tiene diferentes tipos de datos enteros, incluyendo byte, short, int y long, cada uno con un rango diferente. Un int (entero) es un entero con signo de 32 bits en complemento a dos, con un rango desde -2.147.483.648 hasta 2.147.483.647. Este rango es mucho más grande que el de un short.

Cuando intentas asignar un valor de un tipo de dato más grande (como int) a un tipo de dato más pequeño (como short), Java te requiere que le indiques explícitamente que eres consciente de la posible pérdida de información. Esto se llama conversión de tipo (type casting). Si no realizas la conversión, Java te dará un error de compilación para evitar la pérdida accidental de datos.

Modifiquemos nuestro programa HelloJava.java para demostrar esto.

Abre el archivo HelloJava.java en el editor WebIDE.

Reemplaza el código existente con lo siguiente:

public class HelloJava {
    public static void main(String[] args) {
        int largeInt = 40000; // This value is outside the short range

        // Attempt to assign largeInt to a short variable without casting
        // short myShort = largeInt; // This line will cause a compilation error

        // To assign a value from a larger type, we need to cast it
        short myShort = (short) largeInt;
        System.out.println("Value of largeInt cast to short: " + myShort);

        int anotherLargeInt = -40000; // Another value outside the short range
        short anotherShort = (short) anotherLargeInt;
        System.out.println("Value of anotherLargeInt cast to short: " + anotherShort);
    }
}

En este código actualizado:

Declaramos una variable int llamada largeInt con el valor 40000, que es mayor que el valor máximo que un short puede contener (32767).
La línea comentada short myShort = largeInt; muestra lo que sucedería sin la conversión: un error de compilación.
La línea short myShort = (short) largeInt; demuestra cómo convertir el valor int a un short. El (short) antes de largeInt es el operador de conversión.
Hacemos lo mismo para un valor negativo anotherLargeInt (-40000), que es menor que el valor mínimo que un short puede contener (-32768).

Guarda el archivo (Ctrl+S o Cmd+S).
Ahora, compila el programa modificado en la Terminal:
```
javac HelloJava.java
```
Esta vez, la compilación debe ser exitosa porque usamos la conversión de tipo.

Ejecuta el programa compilado:

java HelloJava

Verás una salida similar a esta:

Value of largeInt cast to short: -25536
Value of anotherLargeInt cast to short: 25536

Observa que los valores de salida (-25536 y 25536) no son los valores originales (40000 y -40000). Esto se debe a que cuando conviertes un valor que está fuera del rango del tipo de dato de destino, el valor "da la vuelta". Este es un ejemplo de overflow (para valores positivos que exceden el máximo) y underflow (para valores negativos que exceden el mínimo). El valor resultante exacto depende de cómo se representan los números en binario. Esto demuestra por qué es importante entender los rangos de los tipos de datos y usar la conversión de tipo con cuidado para evitar resultados inesperados.

Manejar valores límite

En los pasos anteriores, aprendimos sobre el rango del tipo de dato short y vimos qué sucede cuando convertimos valores enteros más grandes que están fuera de este rango. También es importante entender cómo Java maneja los valores exactamente en los límites del rango de short (-32768 y 32767).

Cuando trabajas con valores en los límites, debes tener cuidado, especialmente cuando realizas operaciones aritméticas. Sumar 1 al valor máximo o restar 1 al valor mínimo puede provocar overflow o underflow, haciendo que el valor dé la vuelta al otro extremo del rango.

Modifiquemos nuestro programa HelloJava.java una última vez para demostrar este comportamiento en los límites.

Abre el archivo HelloJava.java en el editor WebIDE.

Reemplaza el código existente con lo siguiente:

public class HelloJava {
    public static void main(String[] args) {
        short maxShort = 32767;
        System.out.println("Maximum short value: " + maxShort);

        // Adding 1 to the maximum short value
        // Note: The result of maxShort + 1 is an int by default
        int overflowInt = maxShort + 1;
        System.out.println("Maximum short + 1 (as int): " + overflowInt);

        // Casting the overflowed int back to short
        short overflowShort = (short) overflowInt;
        System.out.println("Maximum short + 1 (cast to short): " + overflowShort);

        short minShort = -32768;
        System.out.println("Minimum short value: " + minShort);

        // Subtracting 1 from the minimum short value
        // Note: The result of minShort - 1 is an int by default
        int underflowInt = minShort - 1;
        System.out.println("Minimum short - 1 (as int): " + underflowInt);

        // Casting the underflowed int back to short
        short underflowShort = (short) underflowInt;
        System.out.println("Minimum short - 1 (cast to short): " + underflowShort);
    }
}

En este código:

Empezamos con el valor máximo de short (maxShort).
Sumamos 1 a maxShort. Por defecto, las operaciones aritméticas que involucran short (y byte) se promueven a int. Entonces, maxShort + 1 da como resultado un int. Lo almacenamos en overflowInt.
Luego convertimos overflowInt de nuevo a short y lo almacenamos en overflowShort. Aquí es donde ocurre el overflow y el valor da la vuelta.
Realizamos operaciones similares con el valor mínimo de short (minShort), restando 1 para demostrar el underflow.

Guarda el archivo (Ctrl+S o Cmd+S).
Compila el programa en la Terminal:
```
javac HelloJava.java
```

Ejecuta el programa compilado:

java HelloJava

Deberías ver una salida similar a esta:

Maximum short value: 32767
Maximum short + 1 (as int): 32768
Maximum short + 1 (cast to short): -32768
Minimum short value: -32768
Minimum short - 1 (as int): -32769
Minimum short - 1 (cast to short): 32767

Como puedes ver, cuando sumamos 1 al valor máximo de short (32767) y lo convertimos de nuevo a short, da la vuelta al valor mínimo (-32768). Del mismo modo, restar 1 al valor mínimo de short (-32768) y convertirlo de nuevo a short da la vuelta al valor máximo (32767).

Es importante recordar este comportamiento cuando trabajas con tipos de enteros de tamaño fijo como short. Siempre ten en cuenta el rango del tipo de dato para evitar resultados inesperados debido a overflow o underflow.

Resumen

En este laboratorio, aprendimos sobre el tipo de dato short en Java, comprendiendo su naturaleza de 16 bits con signo en complemento a dos y su rango específico desde -32.768 hasta 32.767. Exploramos cómo declarar e inicializar variables short y demostramos los valores máximo y mínimo que puede contener a través de un sencillo programa en Java. Este paso fundamental es crucial para evitar posibles errores de desbordamiento (overflow) o subdesbordamiento (underflow) cuando se trabajan con valores enteros dentro de este rango.