Does Java casting introduce overhead? Why?

by

There are 2 types of casting:

Implicit casting, when you cast from a type to a wider type, which is done automatically and there is no overhead:

String s = "Cast";
Object o = s; // implicit casting

Explicit casting, when you go from a wider type to a more narrow one. For this case, you must explicitly use casting like that:

Object o = someObject;
String s = (String) o; // explicit casting

In this second case, there is overhead in runtime, because the two types must be checked and in case that casting is not feasible, JVM must throw a ClassCastException.

Taken from JavaWorld: The cost of casting

Casting is used to convert between
types — between reference types in
particular, for the type of casting
operation in which we’re interested
here.

Upcast operations (also called
widening conversions in the Java
Language Specification) convert a
subclass reference to an ancestor
class reference. This casting
operation is normally automatic, since
it’s always safe and can be
implemented directly by the compiler.

Downcast operations (also called
narrowing conversions in the Java
Language Specification) convert an
ancestor class reference to a subclass
reference. This casting operation
creates execution overhead, since Java
requires that the cast be checked at
runtime to make sure that it’s valid.
If the referenced object is not an
instance of either the target type for
the cast or a subclass of that type,
the attempted cast is not permitted
and must throw a
java.lang.ClassCastException.

More Related Contents:

  1. Performance of java if-else with return statement [duplicate]
  2. Why don’t Java’s +=, -=, *=, /= compound assignment operators require casting?
  3. Downcasting in Java
  4. Array or List in Java. Which is faster?
  5. Primitive type ‘short’ – casting in Java
  6. Why do we assign a parent reference to the child object in Java?
  7. In java, is it more efficient to use byte or short instead of int and float instead of double?
  8. Dealing with an ArrayStoreException
  9. Technique or utility to minimize Java “warm-up” time?
  10. How does the Java cast operator work?
  11. Counting the number of files in a directory using Java
  12. How can I avoid garbage collection delays in Java games? (Best Practices) [closed]
  13. Which part of throwing an Exception is expensive?
  14. How to cast an Object to an int
  15. Java benchmarking – why is the second loop faster?
  16. Why does Java switch on contiguous ints appear to run faster with added cases?
  17. How to have Java method return generic list of any type?
  18. Casting to generic type in Java doesn’t raise ClassCastException?
  19. Are volatile variable ‘reads’ as fast as normal reads?
  20. Java Streams: How to do an efficient “distinct and sort”?
  21. Support for Compressed Strings being Dropped in HotSpot JVM?
  22. Java toString() using reflection?
  23. Fastest way to strip all non-printable characters from a Java String
  24. Is there a memory-efficient replacement of java.lang.String?
  25. In JNI, how do I cache the class, methodID, and fieldIDs per IBM’s performance recommendations?
  26. Integer.parseInt(scanner.nextLine()) vs scanner.nextInt()
  27. How can I improve performance of Field.set (perhap using MethodHandles)?
  28. Java 2D Drawing Optimal Performance
  29. Is there a workaround for Java’s poor performance on walking huge directories?
  30. How to retrieve a list of directories QUICKLY in Java?

Leave a Comment