Java Primitives Type Casting

1. Introduction

Java is a typed language which means it utilizes the concept of types. There are two distinct type groups:

1. primitive data types
2. abstract data types.

In this article, we will focus on conversions of primitive types.

2. Overview of Primitives

The first thing we have to know is what kind of values may be used with primitive types. There are eight primitive types which are:

• byte – 8 bits and signed

• short – 16 bits and signed

• char – 16 bits and unsigned, so that it may represent Unicode characters

• int – 32 bits and signed

• long – 64 bits and signed

• float – 32 bits and signed

• double – 64 bits and signed

• boolean – it’s not numeric, may only have true or false values

This is not intended to be an extensive discussion about primitives and we will talk a little more about their details as needed during the conversions.

3. Widening Primitive Conversions

When we need to convert from a primitive that is simpler or smaller than the destination type, we don’t have to use any special notation for that:

int myInt = 127;
long myLong = myInt;

During widening conversion, the smaller primitive value is placed over a larger container, which means that all the extra space, on the left of the value, is filled with zeros. This may also be used to go from the integer group to the floating point:

float myFloat = myLong;
double myDouble = myLong;

This is possible because the moving to a wider primitive does not lose any information.

4. Narrowing Primitive Conversion

Sometimes we need to fit a value that is larger than the type used in the variable declaration. This may result in information loss since some bytes will have to be discarded.

In this case, we have to explicitly express that we are aware of the situation and we agree with that, by using a cast:

int myInt = (int) myDouble;
byte myByte = (byte) myInt;

5. Widening and Narrowing Primitive Conversion

This situation happens in a very specific case when we want to convert from a byte to a char. The first conversion is the widening of the byte to int and then from the int it is narrowed down to char.

An example will clarify this point:

byte myLargeValueByte = (byte) 130;   //0b10000010 -126

The binary representation of 130 is the same for -126, the difference is the interpretation of the signal bit. Let’s now convert from byte to char:

char myLargeValueChar = (char) myLargeValueByte;
  //0b11111111 10000010 unsigned value
int myLargeValueInt = myLargeValueChar; //0b11111111 10000010 65410

The char representation is a Unicode value, but converting to an int showed us a very large value which has the lower 8 bits exactly the same as -126.

If we convert it again to byte we get:

byte myOtherByte = (byte) myLargeValueInt; //0b10000010 -126

The original value that we used. If the whole code was starting with a char the values will be different:

char myLargeValueChar2 = 130; //This is an int not a byte! 
  //0b 00000000 10000010 unsigned value
        
int myLargeValueInt2 = myLargeValueChar2; //0b00000000 10000010  130
        
byte myOtherByte2 = (byte) myLargeValueInt2; //0b10000010 -126

Although the byte representation is the same, which is -126, the char representation gives us two different characters.

6. Boxing/Unboxing Conversion

In Java, we have a Wrapper Class for each primitive type, this is a clever way of providing programmers with useful processing methods, without the overhead of having everything as a heavyweight object reference. Since Java 1.5 the ability to automatically convert to/from a primitive to an object and back was included and its achieved by simple attribution:

Integer myIntegerReference = myInt;
int myOtherInt = myIntegerReference;

7. String Conversions

All the primitive types may be converted to String through their Wrapper Classes, which override the toString() method:

String myString = myIntegerReference.toString();

If we need to go back to a primitive type, we need to use a parse method defined by the corresponding Wrapper Class:

byte  myNewByte   = Byte.parseByte(myString);
short myNewShort  = Short.parseShort(myString);
int   myNewInt    = Integer.parseInt(myString);
long  myNewLong   = Long.parseLong(myString);

float  myNewFloat  = Float.parseFloat(myString);
double myNewDouble = Double.parseDouble(myString);

boolean myNewBoolean = Boolean.parseBoolean(myString);

The only exception here is the Character Class because a String is made of chars anyway, this way, considering that probably the String is made of a single char, we can use the charAt() method of the String class:

char myNewChar = myString.charAt(0);

8. Numeric Promotions

To execute a binary operation, it is necessary that both operands are compatible in terms of size.

There is a set of simple rules that apply:

1. If one of the operands is a double, the other is promoted to double
2. Otherwise, if one of the operands is a float, the other is promoted to float
3. Otherwise, if one of the operands is a long, the other is promoted to long
4. Otherwise, both are considered int

Let’s see an example:

byte op1 = 4;
byte op2 = 5;
byte myResultingByte = (byte) (op1 + op2);

Both operands were promoted to int and the result must be downcast to byte again.

9. Conclusion

Conversion between types is a very common task on daily programming activities. There is a set of rules that govern the ways in which statically typed languages operate those conversions. Knowing this rules may save a lot of time when trying to figure out why a certain code is compiling or not.