Generics and Collections The document discusses generics and collections in Java. It defines generics as a style of programming that allows algorithms to operate on objects of different types while providing compile-time type safety. The Java collections framework supports generics to specify the type of objects stored in a collection. Common collection classes like ArrayList, LinkedList, and HashMap are discussed along with their key characteristics.

1. Generics and Collections
Visit http://gsbprogramming.blogspot.in

2. Generic programming is a style of computer programming in which algorithms are
written in terms of types to-be-specified-later that are then instantiated when
needed for specific types provided as parameters.
Generics are a facility of generic programming that were added to the Java
programming language in 2004 within version J2SE 5.0. They were designed to
extend Java's type system to allow “a type or method to operate on objects of
various types while providing compile-time type safety”
The Java collections framework supports generics to specify the type of objects
stored in a collection instance.

3. According to Java Language Specification:
1. A type variable is an unqualified identifier. Type variables are introduced by generic class
declarations, generic interface declarations, generic method declarations, and by generic
constructor declarations.
2. A class is generic if it declares one or more type variables. These type variables are known as the type
parameters of the class. It defines one or more type variables that act as parameters. A generic class
declaration defines a set of parameterized types, one for each possible invocation of the type
parameter section. All of these parameterized types share the same class at runtime.
3. An interface is generic if it declares one or more type variables. These type variables are known as the
type parameters of the interface. It defines one or more type variables that act as parameters. A
generic interface declaration defines a set of types, one for each possible invocation of the type
parameter section. All parameterized types share the same interface at runtime.
4. A method is generic if it declares one or more type variables. These type variables are known as the
formal type parameters of the method. The form of the formal type parameter list is identical to a type
parameter list of a class or interface.
5. A constructor can be declared as generic, independently of whether the class that the constructor is
declared in is itself generic. A constructor is generic if it declares one or more type variables. These
type variables are known as the formal type parameters of the constructor. The form of the formal
type parameter list is identical to a type parameter list of a generic class or interface.

4. Consider the following example:
Although the code is compiled without error, it throws a runtime exception (java.lang.ClassCastException) when
executing the second last statement of code. This type of problem can be avoided by using generics

5. With Generics:
Compiling this fragment with J2SE 5.0 (or later) will yield a compile-time error because the
compiler will detect that list.get(2) returns String instead of Integer

6. Entry<String, String> grade = new Entry<String, String>("Mike", "A");
Entry<String, Integer> mark = new Entry<String, Integer>("Mike", 100);
System.out.println("grade: " + grade);
System.out.println("mark: " + mark);
Entry<Integer, Boolean> prime =
new Entry<>(13, true); //Diamond Operator
if (prime.getValue())
System.out.println(prime.getKey() + " is prime.");
else
System.out.println(prime.getKey() + " is not prime.");
Output:
grade: (Mike, A)
mark: (Mike, 100)
13 is prime.

7. Note: If we remove the first <Type> in the above method, we will get compilation
error (cannot find symbol 'Type') since it represents the declaration of the symbol.
In many cases the user of the method need not indicate the type parameters, as
they can be inferred:
Entry<String, String> pair = Entry.twice("Hello");
The parameters can be explicitly added if needed:
Entry<String, String> pair = Entry.<String>twice("Hello");

8. Output:
java.lang.Integer = 11
java.lang.String = GeeksForGeeks
java.lang.Double = 1.0

9. Programs that uses Generics has got many benefits over non-generic code.
1. Code Reuse: We can write a method/class/interface once and use for any type we want.
2. Type Safety : Generics make errors to appear compile time than at run time (It’s always
better to know problems in your code at compile time rather than making your code fail
at run time).
3. Individual Type Casting is not required
ArrayList <String> al= new ArrayList<String> ();
al.add(“Gurpreet");
// Typecasting is not needed
String s1 = al.get(0);
4. Implementing generic algorithms: By using generics, we can implement algorithms that
work on different types of objects and at the same they are type safe too.

10. What is Collection in java?
Collection represents a single unit of objects i.e. a group.
What is framework in java?
•provides readymade architecture.
•represents set of classes and interface.
•is optional.
What is Collection framework?
Collection framework represents a unified architecture for storing and manipulating group of
objects. It has:
•Interfaces and its implementations i.e. classes
•Algorithm

12. Java ArrayList class uses a dynamic array for storing the elements. It inherits
AbstractList class and implements List interface.
The important points about Java ArrayList class are:
•Java ArrayList class can contain duplicate elements.
•Java ArrayList class maintains insertion order.
•Java ArrayList class is non synchronized.
•Java ArrayList allows random access because array works at the index basis.
•In Java ArrayList class, manipulation is slow because a lot of shifting needs to
be occurred if any element is removed from the array list.

14. Java LinkedList class uses doubly linked list to store the elements. It provides a
linked-list data structure. It inherits the AbstractList class and implements List
and Deque interfaces.
The important points about Java LinkedList are:
•Java LinkedList class can contain duplicate elements.
•Java LinkedList class maintains insertion order.
•Java LinkedList class is non synchronized.
•In Java LinkedList class, manipulation is fast because no shifting needs to
be occurred.
•Java LinkedList class can be used as list, stack or queue.

17. Java HashMap class implements the map interface by using a hashtable. It
inherits AbstractMap class and implements Map interface.
The important points about Java HashMap class are:
•A HashMap contains values based on the key.
•It contains only unique elements.
•It may have one null key and multiple null values.
•It maintains no order.

19. For more Visit:
http://gsb-programming.blogspot.in/search/label/Java