What is a
collection framework?
- A collection
framework is a class library to handle the group of objects.
- Collection
framework is implemented in java.util package.
|
Interface
type
|
Implementation
classes
|
|
Set
|
HashSet
|
|
List
|
Stack
LinkedList
ArrayLIst
Vector
|
|
Que
|
LInkedList
|
|
Map
|
HashMap
HashTable
|
Why Should we
use collection frame even though we have an array to store group of objects?
It is possible to store
a group of onjects into an array
Let us take
an example where we want to store 100 object of employee class into an array.
Employee arr[]=new Employee[100];
For(int i=0; i<100;i++)
{
Arr[i]=new Employee(data);
}
So, here we can observe that how can we store group of object into an array and
retrieve them easily. But we have some inconveniences by using this mechanism,
they are as follows
We cannot store different
objects into the same array, because we knows that an array can store one data
type of elements.
Adding the objects at
the end of an array is easy, but inserting and deleting the elements in the
middle of an array is very difficult/complicated.
Retrieving elements from
an array is easy but after retrieving
the elements, if we want to process them, then there is no methods available to
carry out this.
Due to have of above problems, programmers want a better mechanism to
store a group of objects. That mechanism is collection framework to handle
group of objects of different type.
What is a
set?
- A
set represents a group of elements arranged just like an array.
- The
set will grow dynamically when the elements are stored into it.
- A
set will not allow duplicate elements.
- If
we try to pass same element that is already available in the set, then it
is not stored into it.
- Set
will not maintain the same order of elements as in which
they were entered.
What is
lists in collection framework?
- Lists
are like Sets.
- They
store a group of elements,
- But
Lists allow duplicate values to be stored.
What
is the difference between ArrayList and Vector?
|
ArrayList
|
Vector
|
|
It is not synchronized
|
Vector is
synchronized
|
|
In case of
single thread, ArrayList is faster than Vector
|
In case of
multiple threads, Vector is advisable, with single thread model Vector
becomes slow
|
|
ArrayList
increases it’s size by half every time
|
Vector
increase it’s size double
|
What is a
queue in collections framework?
- A
queue represents arrangements of elements in FIFO(Firs In First Out)
order.
- This
means that element that is stored as a first element into the queue will
be removed first from the queue.
What is
map in collection framework?
- Maps
stored elements in the form of key and value pairs.
- If
key is provided then its corresponding value can be obtained.
- Of
course key should have unique values.
What is the difference between
HashMap and HashTable?
|
Hash Map
|
Hash Table
|
|
Hash Map is not synchronized
|
Hash Table is synchronized
|
|
In case of
single thread, Hash Map is faster than Hash Table
|
In case of multiple threads
Hash Table is advisable, with single thread model it becomes slow
|
|
Hash Map allows null keys and null
values
|
Hash table does not allow null
keys or null values
|
|
Iterator in Hash Map is fail-fast
means it will produce exception if concurrent updates made to Hash Map
|
Enumeration for Hash table is not
fail-fast means even if concurrent updates are done to Hash Table, Enum will
not produce any incorrect results
|
What is
the difference between Iterator and ListIterator?
- Both
are useful to retrieve elements from a collection.
- Iterator can retrieve
the elements only in forward direction.
- But
ListIterator can retrieve the elements in forward and
backward direction also.
- So
ListIterator is preferred than Iterator
·
What is the difference between Iterator and
Enumeration?
|
Iterator
|
Enumeration
|
|
It is
useful to retrieve object
From a
collection
|
It’s also
useful to retrieve object
From a
collection
|
|
Iterator
has methods whose
Names are
easy to follow
|
Enumeration
has methods whose
Names are
difficult to remember
|
|
Iterator
has an option to remove
Objects
from a collection
|
Which is
not available
|
|
So Iterator is preferred than Enumeration
|
How can we
assign multiple values to a single key in HashMap?
HashMap can
be used to store values in key-value pair format, but some times you might be
want store multiple values for the same key like
for key A, you want to store Apple and America
for key B, you want to store Bat and Bangladesh
for key C, you want to store Cat and China
the following code snippet will show how to store multiple values for the same
key.
HashMap-single
key multiple values using LIST
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class SingleKeyMultipleValuesUsingList
{
public static void main(String[] args)
{
// create map to store
Map<String, List<String>>
map = new HashMap<String, List<String>>();
// create list one and
store values
List<String> l1 = new
ArrayList<String>();
l1.add("Apple");
l1.add("America");
// create list two and
store values
List<String> l2 = new
ArrayList<String>();
l2.add("Bat");
l2.add("Bangladesh");
// create list three and
store values
List<String> l3 = new
ArrayList<String>();
l3.add("Cat");
l3.add("China");
// put values into map
map.put("A", l1);
map.put("B", l2);
map.put("C", l3);
// iterate and display
values
System.out.println("Fetching Keys
and corresponding MULTIPLE Values n");
for (Map.Entry<String,
List<String>> entry : map.entrySet())
{
String key = entry.getKey();
List<String> values =
entry.getValue();
System.out.println("Key = "
+ key);
System.out.println("Values =
" + values + "/n");
}
}
}
HashMap-single
key multiple values using Collections
import
java.util.Set;
import org.apache.commons.collections.MultiMap;
import org.apache.commons.collections.map.MultiValueMa;
public class SingleKeyMultipleValuesUsingApacheCollections
{
public static void main(String[] args)
{
// create multimap to store key and
values
MultiMap multiMap = new
MultiValueMap();
// put values into map
for A
multiMap.put("A",
"Apple");
multiMap.put("A",
"America");
// put values into map
for B
multiMap.put("B",
"Bat");
multiMap.put("B",
"Bangladesh");
// put values into map
for C
multiMap.put("C",
"Cat");
multiMap.put("C",
"China");
// retrieve and display
values
System.out.println("Fetching Keys
and corresponding MULTIPLE Values n");
// get all the set of
keys
Set<String> keys =
multiMap.keySet();
// iterate through the
key set and display key and values
for (String key : keys)
{
System.out.println("Key = "
+ key);
System.out.println("Values =
" + multiMap.get(key) + "/n");
}
}
}
Which is the
best one from the following i.e List l =new ArrayList() and ArrayList al=new
ArrayList()
The First one List l = new
ArrayList()
allows
you to use the List1 to refer to any object that is a sub class of list
The
second one ArrayList al = new ArrayList()
will
allow you to refer to only object that is an ArrayList Object
Logically the second way should be faster. But, since the binding happens
at runtime, it shouldnt matter really. Its
actually more to do with
polymorphism. When you know you are going to be
referencing object that may
be sub classes and want to reuse the object ref.
It's simple, List is a Interface and "Arraylist, LinkedList, Vector"
are your implementation. Each one with its own benefit, when you use the List
any moment you can change your implementation, your application becomes more flexible.
Example:
List list = new ArrayLista();
for(String s : list){
...
}
list = new LinkedList();
for(String s : list){
...
}
