Convert From int to short in Java

1. Overview

When we work with Java, we often encounter scenarios where we need to convert data types to suit specific requirements. One common conversion is from int to short.

In this tutorial, we’ll explore how to convert an int to a short and the potential pitfalls to watch out for.

2. Introduction to the Problem

Java offers several primitive data types to store numerical values, each with its range and precision. The int data type, for example, is a 32-bit signed integer capable of holding values ranging from -2^31 to 2^31 – 1. On the other hand, the short data type is a 16-bit signed integer, accommodating values from -2^15 to 2^15 – 1.

Since int‘s range is broader than short‘s, converting int to short can have potential pitfalls, which we’ll discuss in detail in the following sections.

Next, let’s explore converting an int to a short in Java.

3. Casting int to short

The most straightforward way to convert an int to a short is by casting. An example can clearly show how it works:

short expected = 42;
int i = 42;
short result = (short) i;
assertEquals(expected, result);

In Java, integers are of two types: primitive int and Integer. Next, let’s look at how to convert an Integer instance to a short.

4. Using the Integer.shortValue() Method

The Integer class provides the shortValue() method. As its name implies, shortValue() allows us to convert the given Integer to a short value conveniently:

short expected = 42;
Integer intObj = 42;
short result = intObj.shortValue();
assertEquals(expected, result);

However, if we take a look at the shortValue() method’s implementation, we observe that it internally casts the Integer value to a short value:

public short shortValue() {
    return (short)value;
}

We’ve noted that the int range is larger than short in Java. Consequently, we may wonder: What happens if the given integer exceeds the short range? Next, let’s delve into this aspect in detail.

5. Potential Pitfalls

Casting an integer whose value exceeds the range of short may yield “surprising” results. Next, let’s check a couple of conversion examples:

int oneMillion = 1_000_000;
short result = (short) oneMillion;
assertEquals(16960, result);

In this example, the integer value is one million, which exceeds the maximum value of short (32767). After casting, we obtain a short value of 16960.

Moreover, if we change the integer to two million, we even get a negative number (-31616):

int twoMillion = 2_000_000;
result = (short) twoMillion;
assertEquals(-31616, result);

Next, we’ll figure out why we get these “surprising” numbers.

To address this question, let’s first understand how a short is represented as a binary number in Java.

5.1. short: the 16-Bit Signed Integer

We’ve learned that short is a 16-bit signed integer in Java. The most significant bit (MSB) represents the sign of the integer: 0 for positive numbers and 1 for negative numbers. For example, the short value 42 is stored in this way:

short 42:
    00000000 00101010
    ^
    MSB

Following this rule, some might think -42 can be represented as “10000000 00101010“. However, it isn’t:

short -42:
    11111111 11010110
    ^
    MSB

This is because Java employs two’s complement to represent negative numbers. Simply put, in two’s complement calculations, there are two steps: first, invert each bit, then add one to the inverted binary number.

Next, let’s understand why -42 can be represented as “11111111 11010110”:

Binary          : 11111111 11010110 (MSB: 1 -> Negative)
Invert bits     : 00000000 00101001
+ 1             : 00000000 00101010
Decimal         : 42
Result          : -42

Now that we know how short is stored, let’s understand what happens if we cast an int to a short.

5.2. How Casting Works

In Java, an int is a 32-bit signed integer, providing 16 bits more than a short. Consequently, when we cast an int to a short, the int‘s 16 high-order bits are truncated.

An example can clarify it quickly. Let’s see how it works when we cast the int value 42 to a short:

42 (int)      : 00000000 00000000 00000000 00101010
cast to short :                   00000000 00101010
Result        : 42

Now, we can understand why we obtained the “surprising” result when we cast the integer of one million to short. Since short has a narrower range than int, the high-order bits that exceed short‘s capacity are discarded during the casting process, leading to unexpected values in the resulting short:

1 million (int)  : 00000000 00001111 01000010 01000000
Cast to short    :                   01000010 01000000
Decimal          :                   16960

In the “casting the integer of two million” example, we got a negative number since the MSB is 1 after truncating the high-order bits:

2 million (int)  : 00000000 00011110 10000100 10000000
Cast to short    :                   10000100 10000000
MSB: 1 -> Negative
Invert bits      :                   01111011 01111111
+ 1              :                   01111011 10000000 
Decimal          :                   31616
Result           :                   -31616

5.3. Creating intToShort()

It’s essential to be cautious when casting int to short, as it can lead to data loss or unexpected behavior if the int value is outside the range of short. We should always check if the int value is between Short.MIN_VALUE and Short.MAX_VALUE before casting:

short intToShort(int i) {
    if (i < Short.MIN_VALUE || i > Short.MAX_VALUE) {
        throw new IllegalArgumentException("Int is out of short range");
    }
    return (short) i;
}

Then, when the input integer is out of the range of short, it throws an exception:

short expected = 42;
int int42 = 42;
assertEquals(expected, intToShort(int42));
 
int oneMillion = 1_000_000;
assertThrows(IllegalArgumentException.class, () -> intToShort(oneMillion));

6. Conclusion

In this article, we’ve explored how to convert an int to a short in Java and discussed the potential pitfalls when we cast an int whose value is outside the range of short.

As always, the complete source code for the examples is available over on GitHub.