Advance-Java-munotes

Page 1

1Chapter 1: Collection and Generics
Module 1
1 COLLECTION AND GENERICS
Unit Structure
1.0 Objectives
1.1 Introduction to Generics
1.1.1 Advantages of Generics
1.1.2 Generic Classes
1.1.3 Generic Methods
1.1.4 Bounded Type Parameters
1.2 Wildcards
1.2.1 Types of Wildcards
1.3 Introduction to Java Collections
1.3.1 Java Collection Framework
1.3.2 Java Collection Hierarchy
1.3.3 Advantages of Collection
1.3.4 Framework Basic and Bulk Operations on Java Collection
1.4 List
1.4.1 Methods of List Interface
1.4.2 How to create List - ArrayList and LinkedList
1.4.3 Iterating through the List
1.5 Set
1.5.1 Methods of Set Interface
1.5.2 HashSet Class
1.5.3 TreeSet Class
1.6 Map
1.6.1 Methods of Map Interface
1.6.2 HashM ap Class
1.6.2 LinkedHashMap Class
1.6.3 TreeMap Class
1.7 Let Us Sum Up
1.8 List of References
1.9 Chapter End Exercises
munotes.in

Page 2

2 ADVANCE JAVA
1.0 Objectives
After going through this chapter, you will be able to:
• Understand the Collections API
• Learn what is generics and how to write Generic Classes and Methods
• Perform basic operations on Collection
• Learn what are wildcard characters and types of wildcards
• Understand List, Set and Maps
1.1 Introduction to Generics
The Java Generics was added to JDK 1.5 which allowed programming generically. It allows creating classes and methods that work in the same way on
different types of objects while providing type -safety right at the compile -time It
makes the code stable by detecting the bugs at compile time.
Before generics, we can store any type of objects in the collection, i.e., non -generic.
Now generics force the java programmer to store a specific type of objects.
1.1.1 ADVANTAGE OF GENERICS
There are mainly 3 advantages of generics. The y are as follows:
1) Type -safety
We can hold only a single type of objects in generics. It doesn’t allow to
store other objects. Without Generics, we can store any type of objects.
Example :
List list = new ArrayList();
list.add(10); //Storing an int value in list
list.add("10"); //Storing a String value in list
With Generics, it is required to specify the type of object we need to store.
List list = new ArrayList();
list.add(10);
list.add("10");// compile -time error
2) Type casting is not required
There is no need to typecast the object. Before Generics, we need to type cast.
Example :
List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0); //typecasting
After Generics, we don't need to typecast the object.

munotes.in

Page 3

3Chapter 1: Collection and Generics
Example:
List list = new ArrayList();
list.add("hello");
String s = list.get(0);
3) Compile -Time Checking: Type checking is done at compile time so errors
will not occur at runtime.
Example:
List list = new ArrayList();
list.add("hello");
list.add(32);//Compile Time Error
1.1.2 GENERIC CLASSES
Generics is not only limited to collecti on. It is also possible to use Generics with
classes. A generic class declaration looks like a non -generic class declaration,
except that the class name is followed by a type parameter section.
The type parameter section of a generic class can have one or more type parameters
separated by commas. These classes are known as parameterized classes or
parameterized types because they accept one or more parameters.
Example: Program that demonstrates Generic Classes
public class Shape {
private T t;
public void add(T t) {
this.t = t;
}
public T get() {
return t;
}
public static void main(String[] args) {
Shape intShape = new Shape();
Shape strShap e = new Box();

intShape.add(new Integer(25));
strShape.add(new String("Generic Classes"));
System.out.printf("Integer Value :%d \n\n", intShape.get());
System.out.printf("String Value :%s \n", strShape.get());
}
} munotes.in

Page 4

4 ADVANCE JAVA

Output
Integer Value :25
String Value : Generic Classes
In this program, Box is coded as a Generic Class. Technically, Box is a parametric
class and T is the type parameter. T serves as a placeholder for holding any type of
Object. We can use the above cla ss by substituting any kind of object for the
placeholder T.
1.1.3 GENERIC METHODS
A generic method declaration can have arguments of different types. Based on the
types of the arguments passed to the generic method, the compiler handles each
method call appropriately. Unlike a Generic Class, a generic method containing
different parameters affects only that method. alone. Hence, a class which is not
generic can contain generic and non -generic methods.
Rules for defining Generic Methods
• All generic method declarations have a type parameter section delimited by
angle brackets (< and >) that precedes the method's return type < T >
• Each type parameter section contains one or more type parameters
separated by commas. A type parameter is an i dentifier that specifies a
generic type name.
• The type parameters can be used to declare the return type and act as
placeholders for the types of the arguments passed to the generic method,
which are known as actual type arguments.
• A generic method's body is declared like that of any other method.
• Note that type parameters can represent only reference types, not primitive
types (like int, double and char).
Example 1: Program that prints the type of data passed using a single Generic
method
public class GenericMethodsEx1
{ // generic method print
public static void print(T t)
{ System.out.println(t.getClass().getName());
}
public static void main(String args[]) {
GenericMethodsEx1.print(“Hello World”);
GenericMethodsEx1.print(100);
}
} munotes.in

Page 5

5Chapter 1: Collection and Generics

Output;
java.lang.String
java.lang.Integer
In this program, the static method print has a return type void and it takes a single
parameter called T. T stands for parametric type which can be substituted with any
of the Java types by a client application.
Example 2: Program that prints an array of different type using a single
Generic method
public class GenericMethodEx2 {
// generic method prin tArray
public static < T > void printArray( E[] i )
{
// Display array elements
for(T element : i) {
System.out.printf("%s ", element);
}
System.out.println();
}
public static void main(String args[]) {
// Create arrays of Integer, Double and Character
Integer[] intArray = { 1, 2, 3, 4, 5 };
Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
System.out.println("Array integerArr ay 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
}
} munotes.in

Page 6

6 ADVANCE JAVA
Output
Array integerArray contains:
1 2 3 4 5
Array doubleArray contains:
1.1 2.2 3.3 4.4
Array characterArray contains:
H E L L O
In this program, the static method printArray has a return type void and it takes a
single parameter called T. T stands for parametric type which can be substituted
with any of the Java types by a client application. The main method passes arrays
with diff erent types and the single generic method is used to print all of the array
elements.
1.1.4 BOUNDED TYPE PARAMETERS
Sometimes it is required to restrict the kinds of types that are allowed to be passed
to a type parameter. Example, a method that operates on numbers might only want
to accept instances of Number or its subclasses. In such cases, bounded type
parameters can be used.
To declare a bounded type parameter, list the type parameter's name, followed by
the extends keyword, followed by its upper boun d like below:
class Example
Example: Program that calculates the average of numbers either integer or
double
package p1;
public class Test {
T[] numArr;
Test(T[] numArr) {
this.numArr = numArr;
}
public double getAvg() {
double sum = 0.0;
for (int i = 0; i < numArr.length; i++) {
sum += numArr[i].doubleValue();
}
double avg = sum / numArr.length;
return avg;
}
public static void main(String[] args) { munotes.in

Page 7

7Chapter 1: Collection and Generics
Integer i1[] = {12, 13, 14, 15, 16};
Double d[] = {1.0, 2.0, 3.0, 4.0};
Test e1 = new Test(i1);
Test e2 = new Test(d);
double ai = e1.getAvg();
Double a d = e2.getAvg();
System.out.println("Average of Integers = " + ai);
System.out.println("Average of Double =" + ad);
}

Output
Average of Integers = 14.0
Average of Double =2.5
1.2 WILDCARD CHARACTER
‡ The question mark (?) is known as the wildcard in generic programming . It
represents an unknown type.
‡ The wildcard can be used in a variety of situations such as the type of a
parameter, field, or local variable; sometimes as a return type.
‡ Unlike arrays, different instantiations of a ge neric type are not compatible
with each other, not even explicitly. This incompatibility may be softened by
the wildcard if ? is used as an actual type parameter.
1.2.1 TYPES OF WILDCARDS
There are three types of wildcards: They are:
1. UPPER BOUNDED WILD CARDS
¾ These wildcards can be used when you want to relax the restrictions on a
variable.
¾ For example, say you want to write a method that works on List < Integer >,
List and List < Number > , you can do this using an upper bounded
wildcard.
¾ To declare an upper -bounded wildcard, use the wildcard character (‘?’),
followed by the extends keyword, followed by its upper bound
Ex: public static void add(List list)

munotes.in

Page 8

8 ADVANCE JAVA
Example: Program that demonstrates Upper Bounded Wildcards
import java.util.Arrays;
import java.util.List;
class UpperBoundedWildcardDemo
{
public static void main(String[] args)
{
//Upper Bounded Integer List
List list1= Arrays.asList(4,5,6,7);

//printing the sum of elements in list1
System.out.println("Total sum is:"+sum(list1));
//Upper Bounded Double list
List list2=Arrays.asList(4.1,5.1,6.1);

//printing the sum of elements in list2
System.out.print("Total sum is:"+sum(list2));
}
private static double sum(List list)
{
double sum=0.0;
for (Number i: list)
{
sum+=i.doubleValue();
}
return sum;
}
}

Output
Total sum is:22.0
Total sum is:15.299999999999999
Here, the sum method is used to calculate the sum of both Integer list and Double
list elements as it accepts list as a parameter whse upper bound is Number.

munotes.in

Page 9

9Chapter 1: Collection and Generics
2. LOWER BOUNDED WILDCARDS
• If we use the lower -bounded wildcards you can restrict the type of the “?” to
a particular type or a super type of it.
• It is expressed using the wildcard character (‘?’), followed by the super
keyword, followed by its lower bound:
Syntax : Collectiontype
Example: Program that demonstrates Lower Bounded Wildcards
import java.util.Arrays;
import java.util.List;
class LowerBoundedWildcardDemo {
public static void main(String[] args) {
//Lower Bounded Integer List
List list1 = Arrays.asList(1,2,3,4);
//Integer list object is being passed
print(list1);
//Lower Bounded Number list
List list2 = Arrays.asList(1,2,3,4);
//Integer list object is being passed
print(list2);
}

public static vo id print(List list) {
System.out.println(list);
}
}

Output
[1, 2, 3, 4]
[1, 2, 3, 4]
Here, the print method is used to calculate the print both Integer list and Number
list elements as it accepts list as a parameter whse lower bound is Integer.
3. UNBOUNDED WILDCARDS
The unbounded wildcard type is specified using the wildcard character (?), for
example, List. This is called a list of unknown type .
munotes.in

Page 10

10 ADVANCE JAVA
Consider the following method, printList:
public static void printList(List