Methods 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 methodology’s parameter record is right, however there’s an issue. In response to the compiler, dest.add(src.get(i)); violates kind security. The ? implies that any type of object could be the record’s aspect kind, and it’s doable that the supply and vacation spot aspect 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 could be thrown when making an attempt to retrieve the vacation spot record’s parts.

You would partially resolve 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’ll be able to present an higher certain for a wildcard by specifying extends adopted by a sort identify. Equally, you’ll be able to provide a decrease certain for a wildcard by specifying tremendous adopted by a sort identify. These bounds restrict the categories that may be handed as precise kind arguments.

Within the instance, you’ll be able to interpret ? extends String as any precise kind argument that occurs to be String or a subclass. Equally, you’ll be able to interpret ? tremendous String as any precise kind argument that occurs to be String or a superclass. As a result of String is last, 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’ll be able to absolutely resolve this downside by utilizing a generic methodology, which is a category or occasion methodology with a type-generalized implementation. A generic methodology declaration adheres to the next syntax:

<formalTypeParameterList> returnType identifier(parameterList)

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

Itemizing 5 demonstrates how one can declare and invoke (name) a generic copy() methodology.

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 methodology. The compiler notes that the kind of every of the src, dest, and filter parameters consists of the sort parameter T. Because of this the identical precise kind argument have to be handed throughout a technique invocation, and the compiler infers this argument by inspecting the invocation.

In the event you 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 kind inference algorithm for figuring out the precise kind argument(s) when instantiating a generic class, invoking a category’s generic constructor, or invoking a generic methodology.

Generic class instantiation

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

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

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

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

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

To leverage kind inference throughout generic class instantiation, you could specify the diamond operator. Take into account 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 kind and to not the Map<String, Set<String>> kind.

Generic constructor invocation

Generic and non-generic courses can declare generic constructors through which a constructor has a proper kind parameter record. For instance, you may 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 kind parameter E. It additionally specifies a generic constructor with formal kind parameter T. Take into account 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 kind argument as a result of the invoked constructor’s argument is a String object.

We are able to go additional by leveraging the diamond operator to eradicate the Marble precise kind 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 sort Marble for formal kind parameter E of generic class Field<E>, and infers kind String for formal kind parameter T of this generic class’s constructor.

Generic methodology invocation

When invoking a generic methodology, you don’t have to produce precise kind arguments. As a substitute, the sort inference algorithm examines the invocation and corresponding methodology declaration to determine the invocation’s kind argument(s). The inference algorithm identifies argument varieties and (when obtainable) the kind of the assigned or returned outcome.

The algorithm makes an attempt to establish probably the most particular kind that works with all arguments. For instance, within the following code fragment, kind 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 methodology 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 kind inference, you’ll be able to specify copy(/*...*/); to invoke this methodology. It’s not essential to specify an precise kind argument.

You may encounter a scenario the place you have to specify an precise kind argument. For copy() or one other class methodology, you’d specify the argument(s) after the category identify and member entry operator (.) as follows:

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

For an occasion methodology, the syntax is sort of equivalent. As a substitute of following a category identify and operator, nevertheless, the precise kind argument would observe 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 may not be controversial, their explicit 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 kind or generic methodology’s formal kind parameter record after compiling the supply code. This “throwing away” habits is called kind erasure (or erasure, for brief). Different examples of erasure in generics embrace inserting casts to the suitable varieties when code isn’t kind right, and changing kind parameters by their higher bounds (equivalent to Object).

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

The shortcoming 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’t specify Set<Form> shapes = null; if (shapes instanceof
ArrayList<Form>) {}. As a substitute, you have to change the instanceof expression to shapes instanceof ArrayList<?>, which demonstrates an unbounded wildcard. Alternatively, you may specify shapes instanceof ArrayList, which demonstrates a uncooked kind (and which is the popular use).
• Some builders have identified that you just 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 not use kind parameters in array-creation expressions; for instance parts = new E[size];. The compiler will report a generic array creation error message for those who strive to take action.

Given the restrictions of erasure, you may surprise 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 kind refers to an object that isn’t of that parameterized kind (as an illustration if a uncooked kind has been combined with a parameterized kind). On this scenario, the compiler stories an “unchecked warning” as a result of the correctness of an operation involving a parameterized kind (like a forged or methodology name) can’t be verified. Take into account 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 kind 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> kind (it doesn’t). The result’s heap air pollution. (The compiler permits this project 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() methodology. It does so as a result of it can’t decide if variable s refers to a Set<String> or Set<Integer> kind. That is one other heap air pollution scenario. (The compiler permits this methodology name as a result of erasure transforms Set’s boolean add(E e) methodology to boolean add(Object
o), which might add any type of object to the set, together with the Integer subtype of Object.)

Generic strategies that embrace variable arguments (varargs) parameters can even 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; project introduces the opportunity of heap air pollution. A worth whose Checklist kind’s parameterized kind doesn’t match the parameterized kind (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 finished so when translating Checklist<String>... l to Checklist[] l. This project is legitimate as a result of variable l has the sort Checklist[], which subtypes Object[].

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

The String s = l[0].get(0); project is problematic. The article saved within the first array part of variable l has the sort Checklist<Double>, however this project expects an object of kind Checklist<String>. In consequence, 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 
kind Checklist<String>[]
      unsafe(Arrays.asList("A", "B", "C"),
            ^
UnsafeVarargsDemo.java:12: warning: [unchecked] Attainable heap air pollution 
from parameterized vararg kind 
Checklist<String>
   static void unsafe(Checklist<String>... l)
                                      ^
2 warnings

Earlier on this article, I acknowledged that you just can’t use kind parameters in array-creation expressions. For instance, you can’t specify parts = new E[size];. The compiler stories a “generic array creation error” message once you strive to take action. Nonetheless, it’s nonetheless doable 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() methodology’s declaration website. This message isn’t generated at this methodology’s name website, 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 methodology’s declaration website. If you recognize that your methodology doesn’t contribute to heap air pollution, you’ll be able to suppress this warning by declaring it with the @SafeVarargs annotation—Java SE 7 launched the java.lang.SafeVarargs annotation kind. For instance, as a result of there isn’t any approach for the Arrays class’s asList() methodology to contribute to heap air pollution, this methodology’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 tactic’s contract and asserts that the tactic’s implementation is not going to improperly deal with the varargs formal parameter.

Do you need to follow extra with Java generics? See Methods to use generics in your Java packages.