List
Fig: List Hierarchy in Collection |
Properties
|
ArrayList
|
LinkedList
|
Vector
|
||
1
|
Duplicate allowed?
|
Allowed
|
Allowed
|
Allowed
|
|
2
|
Insertion order?
|
Preserved
|
Preserved
|
Preserved
|
|
3
|
Heterogeneous allowed?
|
Allowed
|
Allowed
|
Allowed
|
|
4
|
Null allowed?
|
Allowed
|
Allowed
|
Allowed
|
|
5
|
Version
|
1.2
|
1.2
|
1.0
legacy
|
|
6
|
Non-synchronized?
|
Non-sync
|
Non-sync
|
Synchronized
|
|
7
|
Implement Random Access
|
Yes
|
Not
implement
|
Yes
|
|
8
|
Implement interface Serializable, Cloneble?
|
Yes
|
Yes
|
Yes
|
|
9
|
When to use?
|
To
retrieve object
|
To
add & delete object
|
Thread
safety to retrieve object
|
|
10
|
Underlying Data structure
|
Array
|
Doubly
linked list
|
Array
|
|
11
|
How Iteration takes place?
|
Iterator
&
ListIterator
|
Iterator
& ListIterator
|
Iterator
ListIterator and Enumeration too
|
ArrayList:
1. Implements List (I) and extends
AbstractList class.
2. Underlying Data structure is growable Array (resizable array)
3. Insertion order is preserved.
4. Duplicate objects are allowed.
5. Heterogeneous objects allowed.
6. “null” insertion is possible.
7. Initial capacity = 10 and new capacity
will be new capacity= (3/2 current capacity)+1
8. It should use when Retrieval operation
is performs.
9. Should not be used in case of insertion
and deletion of an objects.
10. Can iterate/traverse using ListIterator and Iterator.
11.It also implements Random Access,
serializable and Cloneble interfaces.
12. ArrayList class is same as that of Vector
except all methods in Vector are synchronized and ArrayList .
Please click on link for Oracle Docs for ArrayList
Note: I've not posted any method's declarations here to avoid any human error. This is Oracle website where we can fully trust and can learn all methods definitions, internal design etc.
Programs on Arraylist:
1. Maintain Insertion Order:
import java.util.*;
public class ArayListInsertionOrder {
public static void main(String args[]) {
ArrayList<String>
list = new
ArrayList<String>();
//Creating ArrayList
list.add("John");// Adding
object in ArrayList
list.add("Adam");
list.add("Adam"); //Duplicate entry: allowed
list.add("Chris");
list.add("Des");
System.out.println(list); // Printing
objects of ArrayList
}
}
Output:
[John,
Adam, Adam, Chris, Des]
Note: Here Duplicate elements allowed and Insertion order is maintained using ArrayList i.e. how we insert Objects in ArrayList in that order it will executed.
2. Methods of ArrayList:
public class ArrayListMethods {
public static void main(String args[]) {
ArrayList
list = new ArrayList();
//
Creating Arraylist
/** Check
ArrayList is Empty or not : isEmpty()*/
System.out.println("Is
Empty? " + list.isEmpty());
list.add("John");// Adding
object in Arraylist
list.add("Adam");
list.add("Chris");
list.add("Des");
System.out.println(list); // Printing
objects of Arraylist
/** Check
ArrayList is Empty or not: after adding Elements*/
System.out.println("After
adding elements, Is Empty? " + list.isEmpty());
/** Check size
of ArrayList: size()*/
System.out.println("Size of
ArrayList: " + list.size());
/** Check
Element contained in ArrayList or not: contains()*/
System.out.println("Contains
Element Adam? " + list.contains("Adam"));
System.out.println("Contains
Element Tony? " + list.contains("Tony"));
/** Get
selected Element from ArrayList*/
System.out.println("Get
index at 2: " + list.get(2));
/** Remove an
Element from ArrayList*/
list.remove(2); // Remove
Index at 1st
//list.removeAll(list)
// Remove Index all elements
System.out.println("After
removing index at 3rd place: " + list);
/** Add 1 list
to another: addAll()*/
ArrayList<String>
list2 = new
ArrayList<String>(); // Creating new Arraylist
list2.add("Gary");
list2.add("Matt");
list.addAll(1, list2); //adding list2 at 2nd place to Original list
System.out.println("New
List2 is: "+list2);
System.out.println("Original
List: "+list);
/** Set
data/element in a ArrayList*/
System.out.println("Before
Setting data: " + list);
list.set(2, "Ricky");
System.out.println("After
Setting data: " + list);
/** Clear an
ArrayList: clear()*/
list.clear(); // Clear the
List
System.out.println("List is
cleared now, No data ==>"+list);
System.out.println("Is
Empty: " + list.isEmpty());
System.out.println("End of
ArrayList Tutorial. Thank you....!");
}
}
Output:
Is Empty? true
[John, Adam, Chris, Des]
After adding elements, Is Empty? false
Size of ArrayList: 4
Contains Element Adam? true
Contains Element Tony? false
Get index at 2: Chris
After removing index at 3rd place: [John, Adam, Des]
New List2 is: [Gary, Matt]
Original List: [John, Gary, Matt, Adam, Des]
Before Setting data: [John, Gary, Matt, Adam, Des]
After Setting data: [John, Gary, Ricky, Adam, Des]
List is cleared now, No data ==>[ ]
Is Empty: true
End of ArrayList Tutorial. Thank you....!
3. How to Iterate an ArrayList? :
We ca iterate using :
1. Iterator interface and
2. ListIterator interface
1. Using Iterator interface : (Forward Iteration only)
public class UniDirectionalIteration {
public static void main(String args[]) {
ArrayList
list = new ArrayList();
//
Creating Arraylist
list.add("John");// Adding
object in Arraylist
list.add("Adam");
list.add("Chris");
list.add("Des");
list.add("Dan");
list.add("Des");
System.out.println("ArrayList:
"+list); // Printing objects of Arraylist
System.out.println("Iteration
as below using Iterator:");
Iterator
itr = list.iterator();
while (itr.hasNext()) {
System.out.println(itr.next());
}
}
}
Output:
ArrayList: [John, Adam, Chris, Des, Dan, Des]
Iteration as below:
John
Adam
Chris
Des
Dan
Des
2. Using ListIterator interface : (Forward & Reverse Iteration)
public class BiDirectionalIteration {
public static void main(String args[]) {
ArrayList
list = new ArrayList(); // Creating Arraylist
list.add("John");// Adding
object in Arraylist
list.add("Adam");
list.add("Chris");
list.add("Des");
list.add("Dan");
list.add("Des");
System.out.println("ArrayList:
"+list);
// Forward
iteration
System.out.println("Forward
Iteration :- ");
ListIterator
listItr = list.listIterator();
while (listItr.hasNext()) {
System.out.println(listItr.next());
}
System.out.println("Reverse
iteration:- ");
// Reverse
iteration
while (listItr.hasPrevious())
{
System.out.println(listItr.previous());
}
}
}
ArrayList: [John, Adam, Chris, Des, Dan, Des]
Forward Iteration :-
John
Adam
Chris
Des
Dan
Des
Reverse iteration:-
Des
Dan
Des
Chris
Adam
John
LinkedList
1. Came in 1.2 version, implement List, Cloneble,
serializable.
2. Underlying Data structure is doubly
LinkedList.
3. Best choice when used for insertion and
deletion of an objects.
4. Not good for retrieving an object.
5. Duplicates allowed.
6. Insertion order maintained.
7. “null” insertion possible.
8. Heterogeneous object possible.
9. Not implements Random Access.
Please click on link for Oracle Docs for LinkedList
Programs on LinkedList:
1. Basic program: adding of LinkedList :
public class A {
public class A {
public static void main(String args[]) {
LinkedList linList = new LinkedList(); // Creating LinkedList
LinkedList linList = new LinkedList(); // Creating LinkedList
linList.add("Adam");
linList.add("Chris");
linList.add("John");
linList.add("John");
linList.add("Des");
System.out.println(linList);
System.out.println(linList);
}
}
Output:
[Adam, Chris, John, John, Des]
2. Methods of LinkedList? :
public class LinkedListMethods {
public static void main(String args[]) {
LinkedList
lnkList = new LinkedList();
lnkList.add("Minerals");
lnkList.add("Protein");
lnkList.add("Carbohydrate");
lnkList.add("Fat");
lnkList.add("Calcium");
lnkList.add("Vitamins");
System.out.println(lnkList);
/** peek
methods: Only retrieves element not remove: */
System.out.println("peek:
" + lnkList.peek());
System.out.println("peekFirst:
" + lnkList.peekFirst());
System.out.println("peekLast:
" + lnkList.peekLast());
/** getFirst
and getLast elements: */
System.out.println("getFirst:
" + lnkList.getFirst());
System.out.println("getLast:
" + lnkList.getLast());
/** poll
methods: Retrieves and remove element: */
System.out.println(lnkList);
System.out.println("poll:
" + lnkList.poll());
System.out.println(lnkList);
System.out.println("pollFirst:
" + lnkList.pollFirst());
System.out.println(lnkList);
System.out.println("pollLast:
" + lnkList.pollLast());
System.out.println("LinkList:
" + lnkList);
/** Add first
and last element: */
lnkList.addFirst("Iron");
lnkList.addLast("Sodium");
System.out.println("After
adding first and Last element:" + lnkList);
/** Remove
first and last element: */
System.out.println("removeFirst:
" + lnkList.removeFirst());
System.out.println("removeFirst:
" + lnkList.removeLast());
System.out.println("LinkList:
" + lnkList);
}
}
Output:
[Minerals, Protein, Carbohydrate, Fat, Calcium, Vitamins]
peek: Minerals
peekFirst: Minerals
peekLast: Vitamins
getFirst: Minerals
getLast: Vitamins
[Minerals, Protein, Carbohydrate, Fat, Calcium, Vitamins]
poll: Minerals
[Protein, Carbohydrate, Fat, Calcium, Vitamins]
pollFirst: Protein
[Carbohydrate, Fat, Calcium, Vitamins]
pollLast: Vitamins
LinkList: [Carbohydrate, Fat, Calcium]
After adding first and Last element:[Iron, Carbohydrate, Fat, Calcium, Sodium]
removeFirst: Iron
removeFirst: Sodium
LinkList: [Carbohydrate, Fat, Calcium]
peek: Minerals
peekFirst: Minerals
peekLast: Vitamins
getFirst: Minerals
getLast: Vitamins
[Minerals, Protein, Carbohydrate, Fat, Calcium, Vitamins]
poll: Minerals
[Protein, Carbohydrate, Fat, Calcium, Vitamins]
pollFirst: Protein
[Carbohydrate, Fat, Calcium, Vitamins]
pollLast: Vitamins
LinkList: [Carbohydrate, Fat, Calcium]
After adding first and Last element:[Iron, Carbohydrate, Fat, Calcium, Sodium]
removeFirst: Iron
removeFirst: Sodium
LinkList: [Carbohydrate, Fat, Calcium]
3. How to Iterate an LinkedList? :
It can iterate same as of ArrayList
Vector :
1. Legacy class.
2. Underlying Datastructure growable
array.
3. Duplicates allowed.
4. Insertion order maintained.
5. Heterogeneous object allowed.
6. Null insertion possible.
7. Implements Random access, Serializable,
Cloneble and List.
8. All methods are (thread safe)
synchronized.
9. Same as that of ArrayList except this
synchronized.
10.Initial capacity= 10; new capacity=
current capacity*2;
11.addElement () used to add element.
12.Can iterate using all cursors
Listiterator, iterator and Enumeration.
Please click on link for Oracle Docs for Vector
Note: Methods in ArrayList and Vector are same. So programs will be same
Iteration of vector:
Vector can iterate same as of ArrayList using Iterator and ListIterator interface.
But in List, only Vector can be iterate using Enumeration interface as below:
public class EnumarationIteration
{
public static void main(String args[]) {
Vector
vector = new Vector();
vector.add("Protein");
vector.add("Carbohydrate");
vector.add("Fat");
vector.add("Calcium");
vector.add("Vitamins");
Enumeration
en = vector.elements();
System.out.println("Vector
List: "+vector);
System.out.println("Iteration
using Enumeration:");
while (en.hasMoreElements())
{
System.out.println(en.nextElement());
}
}
}
Vector List: [Protein, Carbohydrate, Fat, Calcium, Vitamins]
Iteration using Enumeration:
Protein
Carbohydrate
Fat
Calcium
Vitamins
Stack: (Subclass of Vector) :
1. Legacy class (1.0).
2. Synchronized.
3. Duplicates allowed.
4. Insertion order maintained.
5. Child class of vector and implement
serializable + Cloneble.
6. When LIFO order used / required then to
for stack.
7. Contains only one constructor.
Methods of Stack:
·
Object
push (obj o) --- add element
·
Object
pop() --- remote and return top element
·
Object
peek () --- return top element without remove
·
Boolean
empty() ---(true) if empty
·
int
search (obj o) --- search element
Program of Stack:
public static void main(String[] args) {
Stack s=new Stack(); //Stack object created
s.push("A");
s.push("B");
s.push("C");
s.push("D"); //added element (A,B,C,D)
System.out.println(s); //[A B C D]
System.out.println(s.pop()); //D
System.out.println(s); //[A B C]
System.out.println(s.peek());//C
System.out.println(s);//[A B C]
System.out.println(s.search("A")); //3
System.out.println(s.search("Z")); //-1
not in list= -1
System.out.println(s.empty()); //false
}