Chapter 6 ■ Generics and Collections
This is the line where you made a mistake and tried to put a String in an Integer:
Integer intValue2 = value2.getValue();
And you get the following compiler error:
BoxPrinterTest.java:23: incompatible types found : java.lang.String
required: java.lang.Integer
Integer intValue2 = value2.getValue();
That’s good, isn’t it? Instead of a ClassCastException in the case of using an Object class in BoxPrinter, you got a compiler error (incompatible types). Now, you can fix this error and the program will work correctly.
Generics offer generic implementation with type safety.
On the basis of this simple introduction, let’s learn more about generics using a few examples.
Creating Generic Classes
Let’s create a Pair generic class that can hold objects of two different types, T1 and T2 (see Listing 6-6). Don’t worry too much about how useful this is for real-world problem solving; just try to understand how to write generics
of your own.
Listing 6-6. PairTest.java
// It demonstrates the usage of generics in defining classes class Pair<T1, T2> {
T1 object1;
T2 object2;
Pair(T1 one, T2 two) { object1 = one; object2 = two;
}
public T1 getFirst() { return object1;
}
public T2 getSecond() { return object2;
}
}
154
Chapter 6 ■ Generics and Collections
class PairTest {
public static void main(String []args) {
Pair<Integer, String> worldCup = new Pair<Integer, String>(2010, "South Africa"); System.out.println("World cup " + worldCup.getFirst() +
" in " + worldCup.getSecond());
}
}
This program prints the following:
World cup 2010 in South Africa
Here T1 and T2 are type holders. You give these type placeholders inside angle brackets: <T1, T2>. When using the Pair class, you must specify which specific types you are going to use in place of T1 and T2. For example, you use Integer and String for Pair, as in Pair<Integer, String> in the main() method. Now, think of the Pair class as if it has this body:
// how Pair<Integer, String> can be treated internally class Pair {
Integer object1; String object2;
Pair(Integer one, String two) { object1 = one;
object2 = two;
}
public Integer getFirst() { return object1;
}
public String getSecond() { return object2;
}
}
In other words, try manually doing a find-and-replace for the type placeholders and replace them with actual types in the code. This will help you understand how generics actually work. With this, you can understand how the getFirst() and getSecond() methods return Integer and String values in the main() method.
In the statement
Pair<Integer, String> worldCup = new Pair<Integer, String>(2010, "South Africa");
note that the types match exactly. If you try
Pair<Integer, String> worldCup = new Pair<String, String>(2010, "South Africa");
you’ll get the following compiler error:
TestPair.java:20: cannot find symbol
symbol : constructor Pair(int,java.lang.String) location: class Pair<java.lang.String,java.lang.String>
155
Chapter 6 ■ Generics and Collections
Now, how about trying this statement?
Pair<Integer, String> worldCup = new Pair<Number, String>(2010, "South Africa");
You’ll get another compiler error because of the type mismatch in the declared type of worldCup and the type given in the initialization expression:
TestPair.java:20: incompatible types
found : Pair<java.lang.Number,java.lang.String> required: Pair<java.lang.Integer,java.lang.String>
Now modify the generic Pair class. Pair<T1, T2> stores objects of type T1 and T2. How about a generic pair class that takes a type T and stores two objects of that type T? Obviously, one way to do that is to instantiate Pair<T1, T2> with same type, say Pair<String, String>, but it is not a good solution. Why? There is no way to ensure that you are instantiating the Pair with same types! Listing 6-7 is a modified version of Pair—let’s call it PairOfT—that takes ones type placeholder T.
Listing 6-7. PairOfT.java
// This program shows how to use generics in your programs
class PairOfT<T> { T object1; T object2;
PairOfT(T one, T two) { object1 = one; object2 = two;
}
public T getFirst() { return object1;
}
public T getSecond() { return object2;
}
}
Now, will this statement work?
PairOfT<Integer, String> worldCup = new PairOfT<Integer, String>(2010, "South Africa");
No, because PairOfT takes one type parameter and you have given two type parameters here. So, you’ll get a compiler error. So, how about this statement?
PairOfT<String> worldCup = new PairOfT<String>(2010, "South Africa");
No, you still get a compiler error:
TestPair.java:20: cannot find symbol
symbol : constructor PairOfT(int,java.lang.String) location: class PairOfT<java.lang.String>
PairOfT<String> worldCup = new PairOfT<String>(2010, "South Africa");
156
Chapter 6 ■ Generics and Collections
The reason is that 2010—when boxed—is an Integer and you should give a String as argument. How about this statement?
PairOfT<String> worldCup = new PairOfT<String>("2010", "South Africa");
Yes, it compiles and will work fine.
Diamond Syntax
In the previous section, we discussed how to create generic type instances, as in the following statement:
Pair<Integer, String> worldCup = new Pair<Integer, String>(2010, "South Africa");
We also discussed how a compiler error will result if these types don’t match, as in the following statement, which will not compile:
Pair<Integer, String> worldCup = new Pair<String, String>(2010, "South Africa");
See how tedious it is to ensure that you provide same type parameters in both the declaration type (Pair<Integer, String> in this case) and the new object creation expression (new Pair<String, String>() in this case)?
To simplify your life, Java 7 has introduced the diamond syntax, in which the type parameters may be omitted: you can just leave it to the compiler to infer the types from the type declaration. So, the declaration can be simplified as
Pair<Integer, String> worldCup = new Pair<>(2010, "South Africa");
To make it clear, Listing 6-8 contains the full program making use of this diamond syntax.
Listing 6-8. Pair.java
// This program shows the usage of the diamond syntax while using generics class Pair<T1, T2> {
T1 object1;
T2 object2;
Pair(T1 one, T2 two) { object1 = one; object2 = two;
}
public T1 getFirst() { return object1;
}
public T2 getSecond() { return object2;
}
}
157