COLLECTIONfRAMEWORK
--------------------
It is the collection of classes and interfaces to represent a group of object as a
single entity.
9 KEY INTERFACES OF COLLECTIONfRAMEWORK
----------------------------------------
1-Collection
2-List
3-Set
4-SortedSet
5-Navigableset
6-Queue
7-Map
8-SortedMap
9-NavigableMap
Collection
============
1-If we want to represent a group of indivisual object as a single entity then we
should go for COLLECTION interface.
METHODS OF COLLECTION INTERFACE
================================
1-boolean add(Object o)
-------------------------
* It is used to add an element in Collection.
* It returns true if the element is added successfully and it returns false if the
element not added successfully.
import java.util.*;
class Test
{
public static void main(String[] args)
{
ArrayList l1=new ArrayList();
l1.add("aaa");
l1.add("bbb");
System.out.println(l1);//[aaa, bbb]
System.out.println(l1.add("ccc"));//true
System.out.println(l1);//[aaa, bbb, ccc]
}
}
2-boolean addAll(Collection c)
-------------------------------
* It is used to add a group of element at a time.
import java.util.*;
class Test
{
public static void main(String[] args)
{
ArrayList l1=new ArrayList();
l1.add("aaa");
l1.add("bbb");
l1.add("ccc");
System.out.println(l1);//[aaa, bbb, ccc]
ArrayList l2=new ArrayList();
System.out.println(l2);//[]
l2.addAll(l1);
System.out.println(l2);//[aaa, bbb, ccc]
}
}
3-boolean remove(Object o)
---------------------------
* It is uded to remove the Specified element.
import java.util.*;
class Test
{
public static void main(String[] args)
{
ArrayList l1=new ArrayList();
l1.add("aaa");
l1.add("bbb");
l1.add("ccc");
System.out.println(l1);//[aaa, bbb, ccc]
l1.remove("ccc");
System.out.println(l1);//[aaa, bbb]
}
}
4-boolean removeAll(Collection c)
----------------------------------
* It is used to remove a group of element at a time.
import java.util.*;
class Test
{
public static void main(String[] args)
{
ArrayList l1=new ArrayList();
l1.add("aaa");
l1.add("bbb");
l1.add("ccc");
System.out.println(l1);//[aaa, bbb, ccc]
ArrayList l2=new ArrayList();
System.out.println(l2);//[]
l2.addAll(l1);
System.out.println(l2);//[aaa, bbb, ccc]
l2.removeAll(l1);
System.out.println(l2);//[]
}
}
5-boolean contains(Object o)
-----------------------------
* It checks wheather a particular element is present or not.
import java.util.*;
class Test
{
public static void main(String[] args)
{
ArrayList l1=new ArrayList();
l1.add("aaa");
l1.add("bbb");
l1.add("ccc");
System.out.println(l1);//[aaa, bbb, ccc]
System.out.println(l1.contains("bbb"));//true
System.out.println(l1.contains("zzz"));//false
}
}
6-boolean isEmpty()
--------------------
* It is used to check wheather the Collection is empty or not.
import java.util.*;
class Test
{
public static void main(String[] args)
{
ArrayList l1=new ArrayList();
l1.add("aaa");
l1.add("bbb");
l1.add("ccc");
System.out.println(l1);//[aaa, bbb, ccc]
System.out.println(l1.isEmpty());//false
}
}
7-int size()
-------------
* It returns the number of elements present in the Collection.
import java.util.*;
class Test
{
public static void main(String[] args)
{
ArrayList l1=new ArrayList();
l1.add("aaa");
l1.add("bbb");
l1.add("ccc");
System.out.println(l1);//[aaa, bbb, ccc]
System.out.println(l1.size());//3
}
}
8-void clear()
---------------
* It removes all the elements from the Collection.
import java.util.*;
class Test
{
public static void main(String[] args)
{
ArrayList l1=new ArrayList();
l1.add("aaa");
l1.add("bbb");
l1.add("ccc");
System.out.println(l1);//[aaa, bbb, ccc]
l1.clear();
System.out.println(l1);//[]
}
}
LIST
=====
* It is the child interface of Collection Interface.
* If we want to represent a group of indivisual Objects in to a single entity where
insertion is preserved and duplicates Objects are allowed then we should go for list
interface.
* We can differenctiate duplicate elements with respect to index,hence index plays
an important role in list interface.
METHODS OF LIST INTERFACE
==========================
1-boolean add()
----------------
* It is used to add element in the list.
import java.util.*;
class Test
{
public static void main(String[] args)
{
ArrayList l1=new ArrayList();
l1.add("aaa");
l1.add("bbb");
l1.add("ccc");
System.out.println(l1);//[aaa, bbb, ccc]
}
}
2-boolean add(int index,Object o)
----------------------------------
* It is used to add element at a specified index.
import java.util.*;
class Test
{
public static void main(String[] args)
{
ArrayList l1=new ArrayList();
l1.add("aaa");
l1.add("bbb");
l1.add("ccc");
System.out.println(l1);//[aaa, bbb, ccc]
l1.add(2,"ddd");
System.out.println(l1);//[aaa, bbb, ddd, ccc]
}
}
3-boolean addAll(int index, Collection c)
------------------------------------------
* It is used to add a group of element at a specified index.
import java.util.*;
class Test
{
public static void main(String[] args)
{
ArrayList l1=new ArrayList();
l1.add("aaa");
l1.add("bbb");
l1.add("ccc");
System.out.println(l1);//[aaa, bbb, ccc]
ArrayList l2=new ArrayList();
l2.add("ddd");
l2.add("eee");
l2.add("fff");
System.out.println(l2);//[aaa, bbb, ccc]
l1.addAll(2,l2);
System.out.println(l1);//[aaa, bbb, ddd, eee, fff, ccc]
}
}
4-Object get(int index)
------------------------
* It is used to retrive the element present in a specified index.
import java.util.*;
class Test
{
public static void main(String[] args)
{
ArrayList l1=new ArrayList();
l1.add("aaa");
l1.add("bbb");
l1.add("ccc");
System.out.println(l1);//[aaa, bbb, ccc]
System.out.println(l1.get(1));//bbb
}
}
5-Object remove(int index)
---------------------------
* It is used to remove an element to a specified index.
import java.util.*;
class Test
{
public static void main(String[] args)
{
ArrayList l1=new ArrayList();
l1.add("aaa");
l1.add("bbb");
l1.add("ccc");
System.out.println(l1);//[aaa, bbb, ccc]
l1.remove(1);
System.out.println(l1);//[aaa, ccc]
}
}
6- Object set(int index,Object o)
----------------------------------
* It is used to replace the element present at a specified index.
import java.util.*;
class Test
{
public static void main(String[] args)
{
ArrayList l1=new ArrayList();
l1.add("aaa");
l1.add("bbb");
l1.add("ccc");
System.out.println(l1);//[aaa, bbb, ccc]
l1.set(1,"zzz");
System.out.println(l1);//[aaa, zzz, ccc]
}
}
7-int indexOf(Object o)
------------------------
* It is used to get the index of a specified Object.
import java.util.*;
class Test
{
public static void main(String[] args)
{
ArrayList l1=new ArrayList();
l1.add("aaa");
l1.add("bbb");
l1.add("ccc");
System.out.println(l1);//[aaa, bbb, ccc]
System.out.println(l1.indexOf("bbb"));//1
}
}
8-int lastIndexOf(Object o)
----------------------------
It is used to get the last index of an object.
import java.util.*;
class Test
{
public static void main(String[] args)
{
ArrayList l1=new ArrayList();
l1.add("aaa");
l1.add("bbb");
l1.add("aaa");
l1.add("ccc");
System.out.println(l1);//[aaa, bbb, aaa, ccc]
System.out.println(l1.lastIndexOf("aaa"));//2
}
}
ARRAYLIST
==========
* The underlying data structure is resizeable array or growable array.
* Duplicates are allowed.
* Insertion order is preserved.
* Heterogenious objects are allowed.
* Null insertion is possible.
* If our frequent operation is insertion and deletion from middle then ArrayList is
the bad choice
* If our frequent operation is retrival operation then ArrayList is the best
choicwe.
CONSTRUCTOR OF ARRAYLIST
=========================
1-ArrayList l1=new ArrayList();
* The default capacity of ArrayList is 10.
* If we reach the the max capacity then the new capacity will be like
new capacity=(current capacity*3/2) + 1
........................................
2-ArrayList l1=new ArrayList(int initialcapacity);
* Create an ArrayList with a Specified Size.
* ex:-ArrayList l1=new ArrayList(5);
3-ArrayList l1=new ArrayList(Collection c);
* Creats an equivalent ArrayList Object for the given collection
* ArrayList l1=new ArrayList();
l1.add("aaa");
l1.add("bbb");
l1.add("aaa");
l1.add("ccc");
System.out.println(l1);//[aaa, bbb, aaa, ccc]
System.out.println(l1.size());//4
ArrayList l2=new ArrayList(l1);
System.out.println(l2.size());//4
METHODS OF ARRAYLIST
=====================
1-add(Object o)
2-remove(Object o)
3-contains(Object o)
4-isEmpty()
5-size()
6-add(int index)
7-remove(int index)
9-indexOf(Object o)
LINKEDLIST
===========
* The underlying data structure is doubly linked list
* Duplicates are allowed.
* Insertion order is preserved.
* Heterogenious objects are allowed.
* Null insertion is possible.
* If our frequent operation is insertion and deletion from middle then LinkedList is
the best choice
* If our frequent operation is retrival operation then LinkedList is the bad
choicwe.
CONSTRUCTOR OF LINKEDLIST
==========================
1-LinkedList l1=new LinkedList();
* It is used to create an empty LinkedList object
2-LinkedList l1=new LinkedList(Collection c);
* It is used to create an equivalent LinkedList object.
METHODS OF LINKEDLIST
======================
1-add(Object 0)
2-addFirst(Object o)
3-addLast(Object o)
4-removeFirst()
5-removeLast()
LinkedList l1=new LinkedList();
l1.add("a");
l1.add("10");
l1.add("b");
l1.add("10.5");
l1.add("a");
l1.add("null");
System.out.println(l1);//[a, 10, b, 10.5, a, null]
l1.addFirst("zzz");
System.out.println(l1);//[zzz, a, 10, b, 10.5, a, null]
l1.addLast("xxx");
System.out.println(l1);//[zzz, a, 10, b, 10.5, a, null, xxx]
l1.removeFirst();
System.out.println(l1);//[a, 10, b, 10.5, a, null, xxx]
l1.removeLast();
System.out.println(l1);//[a, 10, b, 10.5, a, null]
VECTOR
=======
* It is a legacy class(the class which is introduced in 1.0 version of java).
* The underlying data structure is resizable array or growable array.
* Duplicates objects are allowed.
* Insertion order is preserved.
* Heterogenious elements are allowed.
* Null insertion is possible
CONSTRUCTOR OF VECTOR
======================
1-Vector v=new Vector();
* The default capacity of vector is 10
* If we reach the the max capacity then the new capacity will be like
New capacity=Initial capacity * 2
..................................
2-Vector v=new Vector(int initialcapacity);
3-Vector v=new Vector(Collection c);
METHODS OF VECTOR
==================
1-addElement(Object o)
2-capacity()
3-elementAt(int index)
4-firstelement()
5-lastelement()
Vector v=new Vector();
v.addElement("1");
v.addElement("2");
v.addElement("3");
v.addElement("4");
v.addElement("5");
System.out.println(v);//[1, 2, 3, 4, 5]
System.out.println(v.capacity());//10
System.out.println(v.elementAt(3));//4
System.out.println(v.firstElement());//1
System.out.println(v.lastElement());//5
STACK
======
* It is the child interface of vector.
* Whenever LIFO(last in first out) order is required then we should go for stack.
CONSTRUCTOR OF STACK
=====================
* It contains only one constructor
* Stack s=new Stack();
METHODS OF STACK
=================
1-Object push(Object O)
------------------------
* It is used to insert an object in to the stack.
2-Object pop()
---------------
* It is used to remove and return top of the stack.
3-Object peek()
----------------
* It is used to return the top of the stack without removing it.
4-boolean empty()
------------------
* It is used to check the corresponding stack is empty or not.
5-int search(Object o)
-----------------------
* It is used to return offset if the element is available and otherwise it returns
-1.
Stack s=new Stack();
s.push("a");
s.push("b");
s.push("c");
s.push("d");
s.push("e");
System.out.println(s);//[a, b, c, d, e]
System.out.println(s.pop());//e
System.out.println(s);//[a, b, c, d]
System.out.println(s.peek());//d
System.out.println(s);//[a, b, c, d]
System.out.println(s.isEmpty());//false
System.out.println(s.search("c"));//2
System.out.println(s.search("z"));//-1
SET
===
* Set is the child interface of Collection interface.
* If we want to representb a group of indivisual object as a single entity where
duplicates are not allowed and insertion order is not preserved then we should go
for Set interface.
* It does not contains any new method,so that we have to use the Collection
interface methods only.
HASHSET
=======
* It is introduced in 1.2v of java.
* Here the insertion order is not preserved.
* Duplicates objects are not allowed,if we are trying to add any duplicate element
then it will not showing any compile time error or run time exception,it simply
returns false.
* Heterogenious objects are allowed.
* Null insertion is possible but only once.
CONSTRUCTOR OF HASHSET
======================
1-HashSet h1=new HashSet();
2-HashSet h1=new HashSet(int initialcapacity)
3-HashSet h1=new HashSet(Collection c)
METHODS OF HASHSET
==================
HashSet h1=new HashSet();
h1.add("null");
h1.add("a");
h1.add("b");
h1.add("c");
h1.add("10");
System.out.println(h1);//[a, b, c, null, 10]
System.out.println(h1.add("a"));//false
System.out.println(h1);//[a, b, c, null, 10]
System.out.println(h1.size());//5
LINKEDHASHSET
=============
* It is the child interface of HashSet.
* LinkedHashSet is exactly same as HashSet.
* In LinkedHashSet insertion order is preserved.
LinkedHashSet h1=new LinkedHashSet();
h1.add("null");
h1.add("a");
h1.add("b");
h1.add("c");
h1.add("10");
System.out.println(h1);//[null, a, b, c, 10]
System.out.println(h1.add("a"));//false
System.out.println(h1);//[null, a, b, c, 10]
System.out.println(h1.size());//5
SORTEDSET
=========
* It is the chid interface of set interface.
* If we want to represent a group of indivisual object as a single entity where
duplicates are not allowed and the elements are inserted according to some sorting
order then we should go for SortedSet.
* There are two types of sorting
1- Default Natural Sorting(ASCENDING)
2- Customized Sorting(DESCENDING)
METHODS OF SORTEDSET
====================
1- Object first()
2- Object last()
3- SortedSet headSet()
4- SortedSet tailSet()
TREESET
=======
* The underlying data structure is balanced tree.
* Duplicates objects are not allowed.
* Insertion order is not preserved hence it based on some sorting order.
* Heterogenious objects are not allowed, if we are trying to insert any duplicate
then it will throw an exception like ClassCastException.
* Null insertion is possyble but only once.
CONSTRUCTOR OF TREESET
======================
1-TreeSet t1=new TreeSet();
2-TreeSet t1=new TreeSet(Comparator c);
3-TreeSet t1=new TreeSet(Collection c);
TreeSet h1=new TreeSet();
h1.add("a");
h1.add("b");
h1.add("c");
h1.add("d");
h1.add("e");
System.out.println(h1);//[a, b, c, d, e]
h1.add(10);
System.out.println(h1);//ClassCastException
h1.add(null);
System.out.println(h1);//NullPoingterException
COMPARABLE INTERFACE
====================
* It is present in java.lang package.
* It contains only one method i.e "compareTo()" method.
syn-> public int compareTo(Object o)
ex
--
obj1.compareTo(obj2)
--------------------
-> it returns -ve if obj1 has to be come before obj2.
-> it returns +ve if obj1 has to be come after obj2.
-> it returns 0(zero) if obj1 and obj2 are equal.
TreeSet t1=new TreeSet();
t1.add(10);
t1.add(15);
t1.add(35);
t1.add(7);
t1.add(20);
t1.add(8);
System.out.println(t1);//[7, 8, 10, 15, 20, 35]
COMPARATOR INTERFACE
=====================
* It is present in java.util package.
* It contains two mwthods i.e
1:-public int compare()
-> it returns -ve if obj1 has to be come before obj2.
-> it returns +ve if obj1 has to be come after obj2.
-> it returns 0(zero) if obj1 and obj2 are equal.
2:-public boolean equals()
Example:-
========
import java.util.*;
class Test
{
public static void main(String[] args)
{
TreeSet t1=new TreeSet(new MyComparator());
t1.add(10);
t1.add(15);
t1.add(35);
t1.add(7);
t1.add(20);
t1.add(8);
System.out.println(t1);//[35, 20, 15, 10, 8, 7]
}
}
class MyComparator implements Comparator
{
public int compare(Object obj1,Object obj2)
{
Integer i1=(Integer) obj1;
Integer i2=(Integer) obj2;
if(i1 < i2)
return +1;
else if(i1 > i2)
return -1;
else
return 0;
}
}
* If we are not passing any Comparator object then jvm will always calls compareTo()
which is meant for default natural sorting order(ascending order),hence in this case
the o/p is [7, 8, 10, 15, 20, 35].
*If we are passing Comparator Object Then jvm calls compare() of MyComparator class
which is meant for customized sorting order(descending order),hence in this case the
o/p is [35, 20, 15, 10, 8, 7].
MAP
===
* If we want to represent a group of objects as "key-value" pain then we should go
for map interface.
* In map both key and value are objects.
* Duplicates keys are not allowes but the value can be duplicates.
* Each key value pair is called entry.
* Map interface is not the child interface of collection interface so we can not
apply the collection interface methods here.
METHODS OF MAP INTERFACE
========================
1-Object put(Object key,Object value);
->it is used to insert key value pair/one entry in to the map.
2-void putAll(Map m);
->it is used to insert a group of entry in to the map.
3-Object get(Object key);
->it is used to get the Object on a particular key.
4-Object remove(Object key);
->->it is used to remove the Object on a particular key.
5-boolean containsKey(Object key);
6-boolean containsValue(Object value);
7-boolean isEmpty();
8-int size();
9-void clear();
HASHMAP
=======
* It is the implemented class of Map interface.
* In hashset duplicate keys are not allowed but values can be duplicates.
* Insertion order is not preserved,it is based on the hashcode number of keys.
* Heterogenious objects are allowed for both key and value.
* Null is allowed for keys(only once) and for values(any number of times).
* It is suitable for searching operations.
* It Is introduced in 1.2v.
CONSTRUCTOR OF HASHMAP
======================
1-HashMap m=new HahMap();
2-HashMap m=new HahMap(int initialcapacity);
3-HashMap m=new HahMap(Map m);
HashMap m=new HashMap();
m.put("101","aaa");
m.put("102","bbb");
m.put("103","ccc");
m.put("104","ddd");
m.put("105","eee");
System.out.println(m);//{101=aaa, 102=bbb, 103=ccc, 104=ddd,
105=eee}
System.out.println(m.get("103"));//ccc
System.out.println(m.remove("105"));
System.out.println(m);//{101=aaa, 102=bbb, 103=ccc, 104=ddd}
System.out.println(m.containsKey("101"));//true
System.out.println(m.containsValue("bbb"));//true
System.out.println(m.isEmpty());//false
System.out.println(m.size());//4
m.clear();
System.out.println(m);//{}
LINKEDHASHMAP
=============
* It is exactly same as HashMap except the following differences like
->insertion order is preserved.
->it is introduced in 1.4v.
IDENTITYHASHMAP
===============
* It is exactly same as hashmap except the following differences like
* In the case of hashmap jvm will always use "equals()" to identify
duplicate keys.which is meant for content cpmparision.
HashMap m=new HashMap();
Integer i1=new Integer(10);
Integer i2=new Integer(10);
m.put(i1,"aaa");
m.put(i2,"bbb");
System.out.println(m);//{10=bbb}
* In the case of identityhashmap jvm will always use " == " to identify
duplicate keys.whwich is meant for reference comparision.
IdentityHashMap m=new IdentityHashMap();
Integer i1=new Integer(10);
Integer i2=new Integer(10);
m.put(i1,"aaa");
m.put(i2,"bbb");
System.out.println(m);//{10=aaa, 10=bbb}
WEAKERHASHMAP
=============
* In the case of normal hashmap an object is not eligible for garbage collector even
it does not have any references.bcz the hashmap dominates the garvage collector.
* In the case of weakerhashmap if an object does not have any object reference then
it is eligible for garbage collector.bcz garbage collector dominates weakerhashmap.
IMPORTANT QUESTIONS OF COLLECTION
FRAMEWORK
===========================================
01- What is Collection Framework in java ?
02- What is Collection in java ?
03- What is Collections in java ?
04- What is the difference between Collection and Collections ?
05- what are the key interfaces of Collection ?
06- What is List ?
07- What is ArrayList ?
08- What is LinkedList ?
09- What is the difference between ArrayList and LinkedList ?
10- What is Stack ?
11- What is Vector ?
12- What is the difference Between ArrayList and Vector ?
13- What is LEGACY class ?
14- What is UTILITY class ?
15- What is Set ?
16- What is TreeSet ?
17- What is Map ?
18- What is the difference between HashMap and LinkedHashMap ?
19- What is the difference between HashMap and IdentityHashMap ?
20- What is the difference between HashMap and WeakerHashMap ?
21- What is Comparable inyerface explain briefly ?
22- What is Comparator inyerface explain briefly ?
23- What is the dihherence between HashSet and LinkedHashSet ?
24- Which method is used to insert an object in to the Stack ?
25- Why Collection Came to the picture explain briefly ?
