Find out how to use Java generics to keep away from ClassCastExceptions

void copy(Checklist<?> src, Checklist<?> dest, Filter filter)
{
   for (int i = 0; i < src.dimension(); i++)
      if (filter.settle for(src.get(i)))
         dest.add(src.get(i));
}

This technique’s parameter record is appropriate, however there’s an issue. In keeping with the compiler, dest.add(src.get(i)); violates sort security. The ? implies that any type of object could be the record’s component sort, and it’s attainable that the supply and vacation spot component varieties are incompatible.

For instance, if the supply record was a Checklist of Form and the vacation spot record was a Checklist of String, and copy() was allowed to proceed, ClassCastException can be thrown when trying to retrieve the vacation spot record’s components.

You could possibly partially remedy this downside by offering higher and decrease bounds for the wildcards, as follows:

void copy(Checklist<? extends String> src, Checklist<? tremendous String> dest, Filter filter)
{
   for (int i = 0; i < src.dimension(); i++)
      if (filter.settle for(src.get(i)))
         dest.add(src.get(i));
}

You possibly can present an higher sure for a wildcard by specifying extends adopted by a sort title. Equally, you may provide a decrease sure for a wildcard by specifying tremendous adopted by a sort title. These bounds restrict the kinds that may be handed as precise sort arguments.

Within the instance, you may interpret ? extends String as any precise sort argument that occurs to be String or a subclass. Equally, you may interpret ? tremendous String as any precise sort argument that occurs to be String or a superclass. As a result of String is ultimate, which signifies that it can’t be prolonged, solely supply lists of String objects and vacation spot lists of String or Object objects could be handed, which isn’t very helpful.

You possibly can absolutely remedy this downside through the use of a generic technique, which is a category or occasion technique with a type-generalized implementation. A generic technique declaration adheres to the next syntax:

<formalTypeParameterList> returnType identifier(parameterList)

A generic technique’s formal sort parameter record precedes its return sort. It consists of sort parameters and non-compulsory higher bounds. A sort parameter can be utilized because the return sort and may seem within the parameter record.

Itemizing 5 demonstrates the best way to declare and invoke (name) a generic copy() technique.

Itemizing 5. GenDemo.java (model 5)

import java.util.ArrayList;
import java.util.Checklist;
public class GenDemo
{
   public static void major(String[] args)
   {
      Checklist<Integer> grades = new ArrayList<Integer>();
      Integer[] gradeValues = 
      {
         Integer.valueOf(96),
         Integer.valueOf(95),
         Integer.valueOf(27),
         Integer.valueOf(100),
         Integer.valueOf(43),
         Integer.valueOf(68)
      };
      for (int i = 0; i < gradeValues.size; i++)
         grades.add(gradeValues[i]);
      Checklist<Integer> failedGrades = new ArrayList<Integer>();
      copy(grades, failedGrades, new Filter<Integer>()
                                 {
                                    @Override
                                    public boolean settle for(Integer grade)
                                    {
                                       return grade.intValue() <= 50;
                                    }
                                 });
      for (int i = 0; i < failedGrades.dimension(); i++)
         System.out.println(failedGrades.get(i));
   }
   static <T> void copy(Checklist<T> src, Checklist<T> dest, Filter<T> filter)
   {
      for (int i = 0; i < src.dimension(); i++)
         if (filter.settle for(src.get(i)))
            dest.add(src.get(i));
   }
}
interface Filter<T>
{
   boolean settle for(T o);
}

In Itemizing 5 I’ve declared a <T> void copy(Checklist<T> src, Checklist<T> dest, Filter<T>
filter) generic technique. The compiler notes that the kind of every of the src, dest, and filter parameters contains the kind parameter T. Which means that the identical precise sort argument have to be handed throughout a way invocation, and the compiler infers this argument by inspecting the invocation.

If you happen to compile Itemizing 5 (javac GenDemo.java) and run the applying (java GenDemo) it’s best to observe the next output:

27
43

About generics and sort inference

The Java compiler features a sort inference algorithm for figuring out the precise sort argument(s) when instantiating a generic class, invoking a category’s generic constructor, or invoking a generic technique.

Generic class instantiation

Earlier than Java SE 7, you needed to specify the identical precise sort argument(s) for each a variable’s generic sort and the constructor when instantiating a generic class. Contemplate the next instance:

Map<String, Set<String>> marbles = new HashMap<String, Set<Integer>>();

The redundant String, Set<String> precise sort arguments within the constructor invocation litter the supply code. That can assist you eradicate this litter, Java SE 7 modified the kind inference algorithm so that you could exchange the constructor’s precise sort arguments with an empty record (<>), offered that the compiler can infer the kind arguments from the instantiation context.

Informally, <> is known as the diamond operator, though it isn’t an actual operator. Use of the diamond operator leads to the next extra concise instance:

Map<String, Set<String>> marbles = new HashMap<>();

To leverage sort inference throughout generic class instantiation, you should specify the diamond operator. Contemplate the next instance:

Map<String, Set<String>> marbles = new HashMap();

The compiler generates an “unchecked conversion warning” as a result of the HashMap() constructor refers back to the java.util.HashMap uncooked sort and to not the Map<String, Set<String>> sort.

Generic constructor invocation

Generic and non-generic courses can declare generic constructors through which a constructor has a proper sort parameter record. For instance, you could possibly declare the next generic class with a generic constructor:

public class Field<E>
{
   public <T> Field(T t) 
   {
      // ...
   }
}

This declaration specifies generic class Field<E> with formal sort parameter E. It additionally specifies a generic constructor with formal sort parameter T. Contemplate the next instance:

new Field<Marble>("Aggies")

This expression instantiates Field<Marble>, passing Marble to E. Additionally, the compiler infers String as T’s precise sort argument as a result of the invoked constructor’s argument is a String object.

We will go additional by leveraging the diamond operator to eradicate the Marble precise sort argument within the constructor invocation, so long as the compiler can infer this kind argument from the instantiation context:

Field<Marble> field = new Field<>("Aggies");

The compiler infers the kind Marble for formal sort parameter E of generic class Field<E>, and infers sort String for formal sort parameter T of this generic class’s constructor.

Generic technique invocation

When invoking a generic technique, you don’t have to produce precise sort arguments. As an alternative, the kind inference algorithm examines the invocation and corresponding technique declaration to determine the invocation’s sort argument(s). The inference algorithm identifies argument varieties and (when accessible) the kind of the assigned or returned end result.

The algorithm makes an attempt to determine essentially the most particular sort that works with all arguments. For instance, within the following code fragment, sort inference determines that the java.io.Serializable interface is the kind of the second argument (new TreeSet<String>()) that’s handed to choose() — TreeSet implements Serializable:

Serializable s = choose("x", new TreeSet<String>());
static <T> T choose(T a1, T a2) 
{
   return a2;
}

I beforehand introduced a generic static <T> void copy(Checklist<T> src, Checklist<T> dest,
Filter<T> filter) class technique that copies a supply record to a vacation spot record, and is topic to a filter for deciding which supply objects are copied. Due to sort inference, you may specify copy(/*...*/); to invoke this technique. It’s not essential to specify an precise sort argument.

You would possibly encounter a state of affairs the place it is advisable to specify an precise sort argument. For copy() or one other class technique, you’d specify the argument(s) after the category title and member entry operator (.) as follows:

GenDemo.<Integer>copy(grades, failedGrades, new Filter() /*...*/);

For an occasion technique, the syntax is sort of similar. As an alternative of following a category title and operator, nonetheless, the precise sort argument would comply with the constructor name and member entry operator:

new GenDemo().<Integer>copy(grades, failedGrades, new Filter() /*...*/);

Sort erasure and different limitations of generics in Java

Whereas generics as such won’t be controversial, their specific implementation within the Java language has been. Generics have been carried out as a compile-time function that quantities to syntactic sugar for eliminating casts. The compiler throws away a generic sort or generic technique’s formal sort parameter record after compiling the supply code. This “throwing away” habits is called sort erasure (or erasure, for brief). Different examples of erasure in generics embody inserting casts to the suitable varieties when code isn’t sort appropriate, and changing sort parameters by their higher bounds (corresponding to Object).

Erasure prevents a generic sort from being reifiable (exposing full sort data at runtime). Because of this, the Java digital machine doesn’t know the distinction between. Take, for instance, Set<String> and Set<Marble>; at runtime, solely the uncooked sort Set is offered. In distinction, primitive varieties, non-generic varieties (reference varieties previous to Java 5), uncooked varieties, and invocations of wildcards are reifiable.

The lack for generic varieties to be reifiable has resulted in a number of limitations:

• With one exception, the instanceof operator can’t be used with parameterized varieties. The exception is an unbounded wildcard. For instance, you can not specify Set<Form> shapes = null; if (shapes instanceof
ArrayList<Form>) {}. As an alternative, it is advisable to change the instanceof expression to shapes instanceof ArrayList<?>, which demonstrates an unbounded wildcard. Alternatively, you could possibly specify shapes instanceof ArrayList, which demonstrates a uncooked sort (and which is the popular use).
• Some builders have identified that you simply can’t use Java Reflection to acquire generics data, which isn’t current within the class file. Nonetheless, in Java Reflection: Generics developer Jakob Jenkov factors out a couple of instances the place generics data is saved in a category file, and this data could be accessed reflectively.
• You can’t use sort parameters in array-creation expressions; for instance components = new E[size];. The compiler will report a generic array creation error message in case you attempt to take action.

Given the restrictions of erasure, you would possibly marvel why generics have been carried out with erasure. The reason being easy: The Java compiler was refactored to make use of erasure in order that generic code might interoperate with legacy Java code, which isn’t generic (reference varieties can’t be parameterized). With out that backward compatibility, legacy Java code would fail to compile in a Java compiler supporting generics.

Generics and heap air pollution

Whereas working with generics, you might encounter heap air pollution, through which a variable of a parameterized sort refers to an object that isn’t of that parameterized sort (as an example if a uncooked sort has been combined with a parameterized sort). On this state of affairs, the compiler reviews an “unchecked warning” as a result of the correctness of an operation involving a parameterized sort (like a solid or technique name) can’t be verified. Contemplate Itemizing 6.

Itemizing 6. Demonstrating heap air pollution

import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class HeapPollutionDemo
{
   public static void major(String[] args)
   {
      Set s = new TreeSet<Integer>();
      Set<String> ss = s;            // unchecked warning
      s.add(Integer.valueOf(42));    // one other unchecked warning
      Iterator<String> iter = ss.iterator();
      whereas (iter.hasNext())
      {
         String str = iter.subsequent();   // ClassCastException thrown
         System.out.println(str);
      }
   }
}

Variable ss has parameterized sort Set<String>. When the Set that’s referenced by s is assigned to ss, the compiler generates an unchecked warning. It does so as a result of the compiler can’t decide that s refers to a Set<String> sort (it doesn’t). The result’s heap air pollution. (The compiler permits this task to protect backward compatibility with legacy Java variations that don’t help generics. Moreover, erasure transforms Set<String> into Set, which leads to one Set being assigned to a different Set.)

The compiler generates a second unchecked warning on the road that invokes Set’s add() technique. It does so as a result of it can’t decide if variable s refers to a Set<String> or Set<Integer> sort. That is one other heap air pollution state of affairs. (The compiler permits this technique name as a result of erasure transforms Set’s boolean add(E e) technique to boolean add(Object
o), which may add any type of object to the set, together with the Integer subtype of Object.)

Generic strategies that embody variable arguments (varargs) parameters may also trigger heap air pollution. This state of affairs is demonstrated in Itemizing 7.

Itemizing 7. Demonstrating heap air pollution in an unsafe varargs context

import java.util.Arrays;
import java.util.Checklist;
public class UnsafeVarargsDemo
{
   public static void major(String[] args)
   {
      unsafe(Arrays.asList("A", "B", "C"),
             Arrays.asList("D", "E", "F"));
   }
   static void unsafe(Checklist<String>... l)
   {
      Object[] oArray = l;
      oArray[0] = Arrays.asList(Double.valueOf(3.5));
      String s = l[0].get(0);
   }
}

The Object[] oArray = l; task introduces the potential for heap air pollution. A price whose Checklist sort’s parameterized sort doesn’t match the parameterized sort (String) of the varargs parameter l could be assigned to array variable oArray. Nonetheless, the compiler doesn’t generate an unchecked warning as a result of it has already carried out so when translating Checklist<String>... l to Checklist[] l. This task is legitimate as a result of variable l has the kind Checklist[], which subtypes Object[].

Additionally, the compiler doesn’t subject a warning or error when assigning a Checklist object of any sort to any of oArray’s array parts; for instance, oArray[0] = Arrays.asList(Double.valueOf(3.5));. This task assigns to the primary array element of oArray a Checklist object containing a single Double object.

The String s = l[0].get(0); task is problematic. The thing saved within the first array element of variable l has the kind Checklist<Double>, however this task expects an object of sort Checklist<String>. Because of this, the JVM throws ClassCastException.

Compile the Itemizing 7 supply code (javac -Xlint:unchecked UnsafeVarargsDemo.java). It is best to observe the next output (barely reformatted for readability):

UnsafeVarargsDemo.java:8: warning: [unchecked] unchecked generic array 
creation for varargs parameter of 
sort Checklist<String>[]
      unsafe(Arrays.asList("A", "B", "C"),
            ^
UnsafeVarargsDemo.java:12: warning: [unchecked] Doable heap air pollution 
from parameterized vararg sort 
Checklist<String>
   static void unsafe(Checklist<String>... l)
                                      ^
2 warnings

Earlier on this article, I acknowledged that you simply can’t use sort parameters in array-creation expressions. For instance, you can not specify components = new E[size];. The compiler reviews a “generic array creation error” message once you attempt to take action. Nonetheless, it’s nonetheless attainable to create a generic array, however solely in a varargs context, and that’s what the primary warning message is reporting. Behind the scenes, the compiler transforms Checklist<String>...
l to Checklist<String>[] l after which to Checklist[] l.

Discover that the heap air pollution warning is generated on the unsafe() technique’s declaration web site. This message isn’t generated at this technique’s name web site, which is the case with Java 5 and Java 6 compilers.

Not all varargs strategies will contribute to heap air pollution. Nonetheless, a warning message will nonetheless be issued on the technique’s declaration web site. If that your technique doesn’t contribute to heap air pollution, you may suppress this warning by declaring it with the @SafeVarargs annotation—Java SE 7 launched the java.lang.SafeVarargs annotation sort. For instance, as a result of there isn’t any method for the Arrays class’s asList() technique to contribute to heap air pollution, this technique’s declaration has been annotated with @SafeVarargs, as follows:

@SafeVarargs
public static <T> Checklist<T> asList(T... a)

The @SafeVarargs annotation eliminates the generic array creation and heap air pollution warning messages. It’s a documented a part of the strategy’s contract and asserts that the strategy’s implementation won’t improperly deal with the varargs formal parameter.

Do you need to apply extra with Java generics? See Find out how to use generics in your Java applications.