Scribd
Upload
47 views

Java Generics: Compiled From Core Java

Java generics were introduced in JDK 5.0 to provide compile-time type safety for collections and eliminate casting. Generics allow specifying the type of objects stored in a collection using angle brackets (<>) so that the correct types are automatically handled when adding and accessing elements without casting. For example, a List<Integer> will only accept Integers and know that its elements are Integers without needing to cast. This prevents runtime errors from adding the wrong types.

Uploaded by

Uday Kumar
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
47 views

Java Generics: Compiled From Core Java

Java generics were introduced in JDK 5.0 to provide compile-time type safety for collections and eliminate casting. Generics allow specifying the type of objects stored in a collection using angle brackets (<>) so that the correct types are automatically handled when adding and accessing elements without casting. For example, a List<Integer> will only accept Integers and know that its elements are Integers without needing to cast. This prevents runtime errors from adding the wrong types.

Uploaded by

Uday Kumar
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 11

Java Generics

Compiled from Core Java


Technologies Tech Tips
By
Billy B. L. Lim
Introduction
 Prior to the JDK 5.0 release, when you created a
Collection, you could put any object in it.

List myList = new ArrayList(10);


myList.add(new Integer(10));
myList.add("Hello, World");

 Getting items out of the collection required you to use a


casting operation:

Integer myInt = (Integer)myList.iterator().next();


Introduction (cont’d)
 If you accidentally cast the wrong type, the program
would successfully compile, but an exception would be
thrown at runtime.
 Use instanceof to avoid a blind cast

Iterator listItor = myList.iterator();


Object myObject = listItor.next();
Integer myInt = null;
if (myObject instanceof Integer) {
myInt = (Integer)myObject;
}
Generics
 J2SE 5.0 provides compile-time type safety with the
Java Collections framework through generics
 Generics allows you to specify, at compile-time, the types
of objects you want to store in a Collection. Then when
you add and get items from the list, the list already
knows what types of objects are supposed to be
acted on.
 So you don't need to cast anything. The "<>" characters
are used to designate what type is to be stored. If the
wrong type of data is provided, a compile-time exception
is thrown.
Generics (cont’d)
 Example:

import java.util.*;
public class First {
public static void main(String args[]) {
List<Integer> myList = new ArrayList<Integer>(10);
myList.add(10); // OK ???
myList.add("Hello, World"); // OK ???
}
}
Generics (cont’d)
 Example (compile-time exception):

import java.util.*;
public class First {
public static void main(String args[]) {
List<Integer> myList = new ArrayList<Integer>(10);
myList.add(10); //  Autoboxing converted the int type to an Integer
myList.add("Hello, World");
}
}

First.java:7: cannot find symbol symbol :


method add(java.lang.String)
location: interface java.util.List<java.lang.Integer>
myList.add("Hello, World");
^ 1 error
Generics (cont’d)
 Consider this:

import java.util.*;
public class Second {
public static void main(String args[]) {
List list = new ArrayList();
list.add(10); //  the "E" in the "add(E)" call, was never specified.
}
}

 When you compile the program, you get the following warning:

Note: Second.java uses unchecked or unsafe operations.


Note: Recompile with -Xlint:unchecked for details.
Generics (cont’d)
 If you want to get rid of the warning, you can add <Object>
to the List declaration, as follows:

import java.util.*;
public class Second {
public static void main(String args[]) {
List<Object> list = new ArrayList<Object>();
list.add(10);
}
}

 Here, Object is the E, and basically says that anything can


be stored in the List.
Generics (cont’d)
 Another example:

// old way of looping through a List of String objects


// without generics and an enhanced for loop
import java.util.*;
public class Old {
public static void main(String args[]) {
List list = Arrays.asList(args);
Iterator itor = list.iterator();
while (itor.hasNext()) {
String element = (String)itor.next();
System.out.println(element + " / " + element.length());
}}}

 If you compile and run the Old class and then run it with a string, like
this:
 java Old Hello
 you get: Hello / 5
Generics (cont’d)
 Another example:
// old way of looping through a List of String objects
// without generics and an enhanced for loop
import java.util.*;
public class New {
public static void main(String args[]) {
List<String> list = Arrays.asList(args);
for (String element : list) {
System.out.println(element + " / " + element.length());
}
}
}

java New Hello


Hello / 5
For more information:
 Tutorial: Generics in the Java
Programming Language
• http://java.sun.com/j2se/1.5/pdf/generics-tutori
al.pdf

 Generics
• http://java.sun.com/j2se/1.5.0/docs/guide/lang
uage/generics.html

You might also like