Casting rules for primitive types in java

by

The JLS lists

19 specific conversions on primitive types are called the widening primitive conversions:

  • byte to short, int, long, float, or double
  • short to int, long, float, or double
  • char to int, long, float, or double
  • int to long, float, or double
  • long to float or double
  • float to double

Note the missing conversions from byte and short to char, even though char is two bytes long.

Everything else needs an explicit cast. Narrowing is a little more complex:

  • double to float uses standard IEEE 754 rounding.
  • integer values have their most significant bits stripped to the available width of the target type. This may result in a sign bit appearing, e.g. (byte)0xfff == (byte)-1;
  • If the source type is floating point and the target type is long, the value is converted by rounding towards zero.
  • If the source type is floating point and the target type is integral but not long, the value is first converted to int by rounding towards zero. Then the resulting int is converted to the target type using integer conversion.

Examples:

int doubleToInt = (int)aDoubleValue;

yields Integer.MAX_VALUE as per rounding rules.

byte doubleToByte = (byte)aDoubleValue;

first converts to int, yielding Integer.MAX_VALUE and then converts that to byte. Integer.MAX_VALUE is 0x7fffffff, hence the byte value 0xff which is -1.

short doubleToShort = (short)aDoubleValue;

same again: converts to int, yielding Integer.MAX_VALUE. 0x7fffffff to short yields 0xffff, i.e. -1.

The tricky thing is actually the to-char conversion. char is a single, 16-bit unicode character, hence char doubleToChar = (char)aDoubleValue gives you '\uffff' by the now familiar rules.

As can be seen there is a difference between floating point and integer narrowing operations. The floating point operations do actual rounding, while the integer operations perform bitwise clamping.

The integer semantics are probably inherited from C. At least the first step of the float-to-integral narrowing ops are also what you expected. The second narrowing steps, from double/float to short, byte and char may seem a little surprising, but if you really cast float to short, you should probably double check that you know what you are doing anyway.

More Related Contents:

  1. Why do people still use primitive types in Java?
  2. casting Object array to Integer array error
  3. When to use wrapper class and primitive type
  4. Why does the ternary operator unexpectedly cast integers?
  5. Why does Java implicitly (without cast) convert a `long` to a `float`?
  6. java: How can I do dynamic casting of a variable from one type to another?
  7. How to cast a double to an int in Java by rounding it down?
  8. Is a Java array of primitives stored in stack or heap?
  9. Why can’t primitive data types be “null” in Java?
  10. Cast Int to enum in Java
  11. Converting an array of objects to an array of their primitive types
  12. How are integers cast to bytes in Java?
  13. Postgres data type cast
  14. How to insert a character in a string at a certain position?
  15. Explicit type casting example in Java
  16. Can’t cast to to unspecific nested type with generics
  17. What is the priority of casting in java?
  18. Cast Object to Generic Type for returning
  19. How to cast List to List
  20. What is unchecked cast and how do I check it?
  21. Is it valid to compare a double with an int in java?
  22. Cannot convert from List to List
  23. Converting double to integer in Java
  24. Java rules for casting
  25. When to use primitive and when reference types in Java
  26. Overflowing Short in java
  27. Comparator with double type
  28. How to avoid large if-statements and instanceof
  29. Differences in auto-unboxing between Java 6 vs Java 7
  30. How does long to int cast work in Java?

Leave a Comment