Scribd
Upload
46 views10 pages

3 Rdiimafull

Generics allow type-safety when working with collections by specifying the type of elements a collection can contain. This avoids casting and enables compile-time type checking rather than runtime checks. Common collection classes like ArrayList, LinkedList, and HashMap have been "genericized" to support generics. Generic methods allow specifying the type of parameters. Wildcards can be used when the specific type is unknown to avoid warnings. The new way to declare array lists is to specify the element type in angle brackets rather than relying on inheritance from Object.

Uploaded by

dineshdev
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
46 views10 pages

3 Rdiimafull

Generics allow type-safety when working with collections by specifying the type of elements a collection can contain. This avoids casting and enables compile-time type checking rather than runtime checks. Common collection classes like ArrayList, LinkedList, and HashMap have been "genericized" to support generics. Generic methods allow specifying the type of parameters. Wildcards can be used when the specific type is unknown to avoid warnings. The new way to declare array lists is to specify the element type in angle brackets rather than relying on inheritance from Object.

Uploaded by

dineshdev
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 10

Generics

Mar 4, 2017
Generics
Old way :
Instead of saying: List words = new ArrayList();
New way
You'll have to say:

List<String> words = new ArrayList<String>();


The good news:
Replaces runtime type checks with compile-time checks
No casting; instead of
String title = (String) words.get(i);
you use
String title = words.get(i);
Some classes and interfaces that have been genericized are:
Vector, ArrayList, LinkedList, Hashtable, HashMap, Stack,
Queue, PriorityQueue, Dictionary, TreeMap and TreeSet
Generic Iterators
To iterate over generic collections, its a good idea to
use a generic iterator
List<String> listOfStrings = new LinkedList<String>();
...
for (Iterator<String> i = listOfStrings.iterator(); i.hasNext(); ) {
String s = i.next();
System.out.println(s);
}
Writing generic methods
private void printListOfStrings(List<String> list) {
for (Iterator<String> i = list.iterator(); i.hasNext(); ) {
System.out.println(i.next());
}
}
This method should be called with a parameter of type
List<String>, but it can be called with a parameter of
type List
The disadvantage is that the compiler wont catch errors;
instead, errors will cause a ClassCastException
This is necessary for backward compatibility
Similarly, the Iterator need not be an Iterator<String>
Type wildcards
Heres a simple (no generics) method to print out any list:
private void printList(List list) {
for (Iterator i = list.iterator(); i.hasNext(); ) {
System.out.println(i.next());
}
}
The above still works in Java 1.5, but now it generates warning
messages
Java 1.5 incorporates lint (like C lint) to look for possible problems
You should eliminate all errors and warnings in your final code, so you
need to tell Java that any type is acceptable:
private void printListOfStrings(List<?> list) {
for (Iterator<?> i = list.iterator(); i.hasNext(); ) {
System.out.println(i.next());
}
}
Creating a ArrayList the old way
The syntax for creating ArrayLists has changed
between Java 1.4 and Java 5
For compatibility reasons, the old way still works, but
will give you warning messages
Here are the (old) constructors:
import java.util.ArrayList;
ArrayList vec1 = new ArrayList();

Constructs an ArrayList with an initial capacity of 10
ArrayList vec2 = new ArrayList(initialCapacity);
Creating a ArrayList the new way
Specify, in angle brackets after the name, the type of
object that the class will hold
Examples:
ArrayList<String> vec1 = new ArrayList<String>();
ArrayList<String> vec2 = new ArrayList<String>(10);

To get the old behavior, but without the warning


messages, use the <?> wildcard
Example: ArrayList<?> vec1 = new ArrayList<?>();
Accessing with and without generics
Object get(int index)
Returns the component at position index

Using get the old way:


ArrayList myList = new ArrayList();
myList.add("Some string");
String s = (String)myList.get(0);

Using get the new way:


ArrayList<String> myList = new ArrayList<String>();
myList.add("Some string");
String s = myList.get(0);

Notice that casting is no longer necessary when we retrieve an


element from a genericized ArrayList
Summary
If you think of a genericized type as a type, you wont
go far wrong
Use it wherever a type would be used
ArrayList myList becomes ArrayList<String> myList
new ArrayList() becomes new ArrayList<String>()
public ArrayList reverse(ArrayList list) becomes
public ArrayList<String> reverse(ArrayList<String> list)
Advantage: Instead of having collections of Objects,
you can control the type of object
Disadvantage: more complex, more typing
The End

You might also like