1. Java Generics

2. It is nice if we could write a single sort method that could sort array of any type of elements:
Integer array,
String array,
Solution: Generics!
Generics enable types (classes and interfaces) to be parameters when defining classes, interfaces and methods.

3. Advantages of Generics
Stronger type checks at compile time:
A Java compiler applies strong type checking to generic code and issues errors if the code violates type safety.

4. Elimination of casts. Using no generics requires casting:
List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0);
Using generics, require no casting:
List<String> list = new ArrayList<String>();
String s = list.get(0);
Try this code in DrJava interaction pane.
If you add an integer (say 3) will compiler complain?
> import java.util.*;
> List list = new ArrayList()
> list.add("hello")
true
> list.add(new Integer(3))
> list.get(0);
> list.get(0)
"hello"
Try this code in DrJava interaction pane.
If you add an integer (say 3) will compiler complain?

5. No compiler error if you add different data-type elements
data-type element than one specified
at the time of creating list
(Strong type checking at compile time!)

6. Enabling programmers to implement generic algorithms.
By using generics, programmers can implement generic algorithms that work on collections of different types, can be customized, and are type safe and easier to read.
E.g. a single sort method that sort an array of any type element with ordering

7. Generic Types
A generic type is a generic class or interface that is parameterized over types.
Let’s begin by examining a non-generic Box class that operates on objects of any type. 
You are free to pass in whatever object you want to methods.
There is no way to verify, at compile time, how the class is used.
One part of the code may place an Integer in the box
Another part of the code may mistakenly pass in a String, resulting in a runtime error.

8. A Generic Version of the Box Class
A generic class is defined with the following format:
class name<T1, T2, ..., Tn>
{ /* ... */
} type parameters (type variables) T1, T2, ..., and Tn
With this change, the Box class becomes:
all occurrences of Object are replaced by T

9. A type variable can be any non-primitive type you specify:
any class type,
any interface type,
any array type, or even
another type variable.
This same technique can be applied to create generic interfaces.

10. Type Parameter Naming Conventions
The most commonly used type parameter names are:
E - Element (used extensively by Java Collections Framework)
K - Key
N - Number
T - Type
V - Value
S,U,V etc. - 2nd, 3rd, 4th types

11. Invoking and Instantiating a Generic Type
Perform a generic type invocation
replace T with some concrete value, such as Integer:
Box<Integer> integerBox;
Similar to an ordinary method invocation, but instead of passing an argument to a method, you are passing a type argument —Integer in this case — to the Box class itself.

12. To instantiate this class, use the new keyword, as usual, but place <Integer> between the class name and the parenthesis:
Box<Integer> integerBox = new Box<Integer>();

13. Programming Question Write generic class Box.
Use following tester class to test.
public class GenericsTester {
public static void main(String args[])
Box<Integer> integerBox = new Box<Integer>();
integerBox.set(new Integer(3));
Integer n = integerBox.get();
System.out.println(n); }

14. Answer Box.java /** * Generic version of the Box class.
<T> the type of the value being boxed */
public class Box<T> {
// T stands for "Type"
private T t;
public void set(T t) { this.t = t; }
public T get() { return t; } }

15. public class GenericsTester{
public static void main(String args[])
Box<Integer> integerBox = new Box<Integer>();
integerBox.set(new Integer(3));
Integer n = integerBox.get();
System.out.println(n); }

16. Multiple Type Parameters
Generic class can have multiple type parameters.
E.g., the generic OrderedPair class, which implements the generic Pair interface:

17. The following statements create two instantiations of the OrderedPair class:
Due to autoboxing, it is valid to pass a String and an int to the class.
Above statements can be shortened using diamond notation:
To create a generic interface, follow the same conventions as for creating a generic class.

18. Programming Question
Create Pair interface and OrderedPair generic class that implement it.
Then modify GenericsTester to create two ordered pair objects (as given in example) and print keys and values of both pairs.

19. Answer Pair.java OrderedPair.java public interface Pair<K, V> {
public K getKey();
public V getValue(); }
Pair.java
OrderedPair.java
public class OrderedPair<K, V> implements Pair<K, V> {
private K key;
private V value;
public OrderedPair(K key, V value) {
this.key = key;
this.value = value; }
public K getKey() { return key; }
public V getValue() { return value; }

20. GenericsTester.java public class GenericsTester {
public static void main(String args[])
Pair<String, Integer> p1 = new OrderedPair<String, Integer>("Even", 8);
Pair<String, String> p2 = new OrderedPair<String, String>("hello", "world");
System.out.println("p1 key:"+p1.getKey()+" p1 value:"+p1.getValue());
System.out.println("p2 key:"+p2.getKey()+" p2 value:"+p2.getValue()); }

21. Parameterized Types
You can also substitute a type parameter (i.e., K or V) with a parameterized type (i.e., List<String>).
For example, using the OrderedPair<K, V> example:

22. Raw Types
A raw type is the name of a generic class or interface without any type arguments.
To create a parameterized type of Box<T>:
you supply an actual type argument for the formal type parameter T:
Box<Integer> intBox = new Box<>();
To create a raw type of Box<T>:
Omit actual type argument
Box rawBox = new Box();

23. Raw types show up in legacy code because lots of API classes (such as the Collections classes) were not generic prior to JDK 5.0.
Read more:

24. Generic Methods Methods that introduce their own type parameters.
type parameter's scope is limited to the method
The Util class includes a generic method, compare, which compares two Pair objects:

25. The complete syntax for invoking this method would be:
Generally, type can be left out and the compiler will infer the type (type inference):

26. Programming Question
Modify the GenericsTester to implement a generic method printArray. The method should accept an array of a generic type (E or T) and print all array elements.
Find code template next slide

27. public class GenericsTester { public static void main(String args[]) // Create arrays of Integer, Double and Character Integer[] intArray = { 1, 4, 3, 4, 5 }; Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 }; Character[] charArray = { 'H', 'E', 'L', 'L', 'O' }; System.out.println( "Array integerArray contains:" ); printArray( intArray ); // pass an Integer array System.out.println( "\nArray doubleArray contains:" ); printArray( doubleArray ); // pass a Double array System.out.println( "\nArray characterArray contains:" ); printArray( charArray ); // pass a Character array } //TODO: generic method printArray

28. Answer public class GenericsTester {
public static void main(String args[])
// Create arrays of Integer, Double and Character
Integer[] intArray = { 1, 4, 3, 4, 5 };
Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
System.out.println( "Array integerArray contains:" );
printArray( intArray ); // pass an Integer array
System.out.println( "\nArray doubleArray contains:" );
printArray( doubleArray ); // pass a Double array
System.out.println( "\nArray characterArray contains:" );
printArray( charArray ); // pass a Character array }
// generic method printArray
public static < E > void printArray( E[] inputArray )
// Display array elements
for ( E element : inputArray ){
System.out.printf( "%s ", element );
System.out.println();

29. Bounded Type Parameters
Sometimes you want to restrict the kinds of types that are allowed to be passed to a type parameter.
 E.g., a method that operates on numbers might only want to accept instances of Number or its subclasses.
Solution: use bounded type parameters !
To declare a bounded type parameter:
list the type parameter's name, followed by the extends keyword, followed by its upper bound.

30. Example public class MaximumTest {
// determines the largest of three Comparable objects
public static <T extends Comparable<T>> T maximum(T x, T y, T z)
T max = x; // assume x is initially the largest
if ( y.compareTo( max ) > 0 ){ max = y; // y is the largest so far}
if ( z.compareTo( max ) > 0 ){ max = z; // z is the largest now}
return max; // returns the largest object }
public static void main( String args[] )
System.out.printf( "Max of %d, %d and %d is %d\n\n", 3, 4, 5, maximum( 3, 4, 5 ) );
System.out.printf( "Maxm of %.1f,%.1f and %.1f is %.1f\n\n", 6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ) );
System.out.printf( "Max of %s, %s and %s is %s\n","pear", "apple", "orange", maximum( "pear", "apple", "orange" ) );

31. Programming Question
Modify class GenericsTester to implement generics version of selection sort method. Then call this on an Integer and a Double Array.
Non-generic version:
public static int[] sort(int[] a) {
int N = a.length;
for (int i = 0; i < N; i++)
int min = i;
for (int j = i+1; j < N; j++)
if ((a[j]<a[min]) { min = j; } }
int temp = a[i];
a[i]= a[min];
a[min]=temp;
return a;
Find code template next slide

32. public class SelectionSorter{
//TODO: generic selection sort method
public static void main(String args[])
Integer[] intArray = {1,30,20, 10, 3};
intArray = sort(intArray);
for(int n: intArray)
System.out.print(" "+ n); }

33. Answer public class SelectionSorter {
public static <T extends Comparable<T>> T[] sort(T[] a)
int N = a.length;
for (int i = 0; i < N; i++)
int min = i;
for (int j = i+1; j < N; j++)
if ((a[j].compareTo(a[min]))<0) { min = j; } }
T temp = a[i];
a[i]= a[min];
a[min]=temp;
return a;
public static void main(String args[])
Integer[] intArray = {1,30,20, 10, 3};
intArray = sort(intArray);
for(int n: intArray)
System.out.print(" "+ n);

34. Read more: