Answer Posted / vikneswarank

COLLECTION
1. Collecion 2. Set - HashSet

3. Set - TreeSet 4. List - ArrayList

5. List - Vector 6. List - LinkedList

7. Map - HashMap 8. Map - Hashtable

9. Map - Properties

Collection sample

--------------------------------------------------------------------------------


import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.TreeSet;
import java.util.Vector;

/**
* @author Vikneshwaran
* @version 1.0
* #################### Template #####################
* class class_name
* {
* Collection coll_obj1 = new HashSet();
* Collection coll_obj2 = new TreeSet();
* Collection coll_obj3 = new ArrayList();
* Collection coll_obj4 = new Vector();
* Collection coll_obj5 = new LinkedList();
*
* coll_obj1.add(...);
* coll_obj1.remove(...);
* coll_obj1.contains(...);
* int size = coll_obj1.size();
* Iterator itr_obj = coll_obj1.iterator();
* Object[] obj = coll_obj1.toArray();
* }
*
* ####################################################
*/


//1. Collection allows duplicate value
//2. Collection allows null value
//3. Collection allows different type of data types in
single object
//4. Not synchronized one
public class CollectionSample1
{
public static void main (String args[])
{
//since collection is interface, object cannt be
created as follows
//Collection listObj = new Collection();

//using implemented class like ArrayList, Vector &
LinkedList, can do
Collection coll_obj1 = new HashSet();
Collection coll_obj2 = new TreeSet();
Collection coll_obj3 = new ArrayList();
Collection coll_obj4 = new Vector();
Collection coll_obj5 = new LinkedList();

//cannt do
//Collection arrlist_obj2 = new ArrayList(10);
//Collection arrlist_obj2 = new ArrayList(10, 2);

//collection interface(Set, List) and Map interface
allows object only,
//primitive value cannt be added as follows
/*

int a = 50;
double b = 10.00;
long c = 100;

coll_obj1.add(10);
coll_obj1.add(10.00);
coll_obj1.add(test);

coll_obj1.add(a);
coll_obj1.add(b);
coll_obj1.add(c);
*/

//but can add as follows
int a = 40;
double b = 50.00;
long c = 60;
String d = "test3";

coll_obj1.add(new Integer(10));
coll_obj1.add(new Double(20.00));
coll_obj1.add(new Long(30));
coll_obj1.add("test1");
coll_obj1.add(new String("test2"));

coll_obj1.add(new Integer(a));
coll_obj1.add(new Double(b));
coll_obj1.add(new Long(c));
coll_obj1.add(d);

//collection allows duplicate value
coll_obj1.add("test4");
coll_obj1.add("test4");

//collection allows null value
coll_obj1.add(null);

//remove the entry
coll_obj1.remove("test2");
coll_obj1.remove(new Integer(10));
coll_obj1.remove(new Double(b));

//check the entry is already there or not
boolean cont = coll_obj1.contains("test4");//return
boolean true or false

//remove all the entry
//coll_obj1.clear();

//size
int size = coll_obj1.size();

System.out.println("Size of collection is " + size);

//to get or display all the entry
//1. using iterator
Iterator itr = coll_obj1.iterator();

while (itr.hasNext())
{
//if all the entry are same data type, then can
typecast and store in varibale as follows
//String entry = (String) itr.next();
//Double entry = (Double) itr.next();
//System.out.println("Iterator : Value = " + entry);

//if all the entry are different, then can store it
as follows
//Object obj = itr.next();
//System.out.println("Iterator : Value = " + obj);

System.out.println("Iterator : Value = " + itr.next());
}

//2. using toArray
Object[] obj = coll_obj1.toArray();

for (int i = 0; i < coll_obj1.size(); i++)
{
System.out.println("toArray : Value = " + obj[i]);
}

Collection collObj2 = new Vector();

collObj2.add("newtest");

//add all the entry from coll_obj1 to collObj2.
collObj2.addAll(coll_obj1);

coll_obj1.remove("test1");
coll_obj1.remove("test3");

//remove all entry of coll_obj1 in collObj2.
collObj2.removeAll(coll_obj1);

}
}

Set - HashSet sample
--------------------------------------------------------------------------------


import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/**
* @author Vikneshwaran
* @version 1.0
* #################### Template #####################
* class class_name
* {
* Set set_obj1 = new HashSet();
* HashSet hashset_obj1 = new HashSet();
*
* hashset_obj1.add(...);
* hashset_obj1.remove(...);
* hashset_obj1.contains(...);
* int size = hashset_obj1.size();
* Iterator itr_obj = hashset_obj1.iterator();
* Object[] obj = hashset_obj1.toArray();
* }
*
* ####################################################
*/

//1. HashSet doesnt allows duplicate value
//2. HashSet allows null value
//3. HashSet allows different type of data types in single
object
//4. Not synchronized one
public class SetSample1
{
public static void main (String args[])
{
//since set is interface object cannt be created as
follows
//Set setObj = new Set();

//using implemented class like HashSet and TreeSet,
can do

Set setObj1 = new HashSet(); //dynamic binding or
runtime polymorphim
HashSet hashsetObj1 = new HashSet();

//also can do
HashSet hashset_obj1 = new HashSet(10);//after size is
full, it will be increased to double size
HashSet hashset_obj2 = new HashSet(10, 2);//after size
is full, it will be increased by 2

//collection interface(Set, List) and Map interface
allows object only,
//primitive value cannt be added as follows
/*

int a = 50;
double b = 10.00;
long c = 100;

hashsetObj2.add(10);
hashsetObj2.add(10.00);
hashsetObj2.add(test);

hashsetObj2.add(a);
hashsetObj2.add(b);
hashsetObj2.add(c);
*/

//but can add as follows
int a = 40;
double b = 50.00;
long c = 60;
String d = "test3";

hashsetObj1.add(new Integer(10));
hashsetObj1.add(new Double(20.00));
hashsetObj1.add(new Long(30));
hashsetObj1.add("test1");
hashsetObj1.add(new String("test2"));

hashsetObj1.add(new Integer(a));
hashsetObj1.add(new Double(b));
hashsetObj1.add(new Long(c));
hashsetObj1.add(d);

//hashset doesnt allows duplicate value, can add as
follows but it will store single entry only
hashsetObj1.add("test4");
hashsetObj1.add("test4");

//hashset allows null value
hashsetObj1.add(null);

//remove the entry
hashsetObj1.remove("test2");
hashsetObj1.remove(new Integer(10));
hashsetObj1.remove(new Double(b));

//check the entry is already there or not
boolean cont = hashsetObj1.contains("test4");//return
boolean true or false

//remove all the entry
//hashsetObj2.clear();

//size
int size = hashsetObj1.size();

System.out.println("Size of hashset is " + size);

//to get or display all the entry in hashset
//1. using iterator
Iterator itr = hashsetObj1.iterator();

while (itr.hasNext())
{
//if all the entry are same data type, then can
typecast and store in varibale as follows
//String entry = (String) itr.next();
//Double entry = (Double) itr.next();
//System.out.println("Iterator : Value = " + entry);

//if all the entry are different, then can store it
as follows
//Object obj = itr.next();
//System.out.println("Iterator : Value = " + obj);

System.out.println("Iterator : Value = " + itr.next());
}

//2. using toArray
Object[] obj = hashsetObj1.toArray();

for (int i = 0; i < hashsetObj1.size(); i++)
{
System.out.println("toArray : Value = " + obj[i]);
}

HashSet hashsetObj2 = new HashSet();

hashsetObj2.add("newtest");
//add all the entry from hashsetObj1 to hashsetObj2.
hashsetObj2.addAll(hashsetObj1);

hashsetObj1.remove("test1");
hashsetObj1.remove("test3");

//remove all entry of hashsetObj1 in hashsetObj2.
hashsetObj2.removeAll(hashsetObj1);

}
}

Set - TreeSet sample
--------------------------------------------------------------------------------

import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

/**
* @author Vikneshwaran
* @version 1.0
* #################### Template #####################
* class class_name
* {
* Set set_obj1 = new TreeSet();
* TreeSet treeset_obj1 = new TreeSet();
*
* treeset_obj1.add(...);
* treeset_obj1.remove(...);
* treeset_obj1.contains(...);
* int size = treeset_obj1.size();
* Iterator itr_obj = treeset_obj1.iterator();
* Object[] obj = treeset_obj1.toArray();
* }
*
* ####################################################
*/

//1. TreeSet allows duplicate value
//2. TreeSet doesnt allows null value
//3. TreeSet doesnt allows different type of data types in
single object
//4. Not synchronized one
//5. stores object or entry in sorted order
public class SetSample2
{
public static void main (String args[])
{
//since set is interface, object cannt be created as
follows
//Set setObj = new Set();

//using implemented class like HashSet and TreeSet,
can do.
Set setObj1 = new TreeSet(); //dynamic binding or
runtime polymorphim
TreeSet treesetObj1 = new TreeSet();

//cannt do
//TreeSet treeset_obj1 = new TreeSet(10);
//TreeSet treeset_obj2 = new TreeSet(10, 2);

//collection interface(Set, List) and Map interface
allows object only,
//primitive value cannt be added as follows
/*
int a = 50;
double b = 10.00;
long c = 100;

treesetObj1.add(10);
treesetObj1.add(10.00);
treesetObj1.add(test);

treesetObj2.add(a);
treesetObj2.add(b);
treesetObj2.add(c);
*/

//but can add as follows
/*
int a = 40;
double b = 50.00;
long c = 60;
String d = "test3";

treesetObj1.add(new Integer(10));
treesetObj1.add(new Double(20.00));
treesetObj1.add(new Long(30));
treesetObj1.add("test1");
treesetObj1.add(new String("test2"));

treesetObj1.add(new Integer(a));
treesetObj1.add(new Double(b));
treesetObj1.add(new Long(c));
treesetObj1.add(d);
*/

//since it doesnt allows different data type in single
objet
//if string object added first then other string
object should be added
treesetObj1.add("test2");

//suppose next entry is added as follows,
//it will through exception during runtime, since
string object is added already
//treesetObj1.add(new Integer(10));

treesetObj1.add("newtest1");

//treeset doesnt allows duplicate value, can add as
follows but it will store single entry only
treesetObj1.add("test1");
treesetObj1.add("test1");

treesetObj1.add("test4");
treesetObj1.add("test3");

//treeset doesnt allows null value
//treesetObj1.add(null);

//remove the entry
treesetObj1.remove("test1");

//check the entry is already there or not
boolean cont = treesetObj1.contains("test4");//return
boolean true or false

//remove all the entry
//treesetObj1.clear();

//size
int size = treesetObj1.size();

System.out.println("Size of treeset is " + size);

//to get or display all the entry in hashset
//1. using iterator
Iterator itr = treesetObj1.iterator();

while (itr.hasNext())
{
//if all the entry are same data type, then can
typecast and store in varibale as follows
//String entry = (String) itr.next();
//Double entry = (Double) itr.next();
//System.out.println("Iterator : Value = " + entry);

//if all the entry are different, then can store it
as follows
//Object obj = itr.next();
//System.out.println("Iterator : Value = " + obj);

System.out.println("Iterator : Value = " + itr.next());
}

//2. using toArray
Object[] obj = treesetObj1.toArray();

for (int i = 0; i < treesetObj1.size(); i++)
{
System.out.println("toArray : Value = " + obj[i]);
}

TreeSet treesetObj2 = new TreeSet();

treesetObj2.add("newtest");
//add all the entry from treesetObj1 to treesetObj2.
treesetObj2.addAll(treesetObj1);

treesetObj1.remove("test1");
treesetObj1.remove("test2");

//remove all entry of treesetObj1 in treesetObj2.
treesetObj2.removeAll(treesetObj1);
}
}

List - ArrayList sample
--------------------------------------------------------------------------------

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
* @author Vikneshwaran
* @version 1.0
* #################### Template #####################
* class class_name
* {
* List list_obj1 = new ArrayList();
* ArrayList arrlist_obj1 = new ArrayList();
*
* arrlist_obj1.add(...);
* arrlist_obj1.remove(...);
* arrlist_obj1.contains(...);
* int size = arrlist_obj1.size();
* Iterator itr_obj = arrlist_obj1.iterator();
* Object[] obj = arrlist_obj1.toArray();
*
* arrlist_obj1.add(.., ..);
* arrlist_obj1.set(.., ..);
* arrlist_obj1.get(...);
* arrlist_obj1.indexOf(...);
* }
*
* ####################################################
*/

//1. ArrayList allows duplicate value
//2. ArrayList allows null value
//3. ArrayList allows different type of data types in single
object
//4. Not synchronized one
//5. stores the values in indexed way.
public class ListSample1
{
public static void main (String args[])
{
//since list is interface, object cannt be created as
follows
//List listObj = new List();

//using implemented class like ArrayList, Vector &
LinkedList, can do
List listObj1 = new ArrayList(); //dynamic binding or
runtime polymorphim
ArrayList arrlistObj1 = new ArrayList();

//also can do
ArrayList arrlist_obj1 = new ArrayList(10);//after
size is full, it will be increased to double size

//cannt do
//ArrayList arrlist_obj2 = new ArrayList(10, 2);

//collection interface(Set, List) and Map interface
allows object only,
//primitive value cannt be added as follows
/*
int a = 50;
double b = 10.00;
long c = 100;

arrlistObj1.add(10);
arrlistObj1.add(10.00);
arrlistObj1.add(test);

arrlistObj1.add(a);
arrlistObj1.add(b);
arrlistObj1.add(c);
*/

//but we can add as follows
int a = 40;
double b = 50.00;
long c = 60;
String d = "test3";

arrlistObj1.add(new Integer(10));
arrlistObj1.add(new Double(20.00));
arrlistObj1.add(new Long(30));
arrlistObj1.add("test1");
arrlistObj1.add(new String("test2"));

arrlistObj1.add(new Integer(a));
arrlistObj1.add(new Double(b));
arrlistObj1.add(new Long(c));
arrlistObj1.add(d);

//arraylist allows duplicate value
arrlistObj1.add("test4");
arrlistObj1.add("test4");

//arraylist allows null value
arrlistObj1.add(null);

//remove the entry from arraylist
arrlistObj1.remove("test2");
arrlistObj1.remove(new Integer(10));
arrlistObj1.remove(new Double(b));

//check the entry is already there or not
boolean cont = arrlistObj1.contains("test4");//return
boolean true or false

//remove all the entry
//arrlistObj1.clear();

//some list interface's method
//can add or replace value to particular index.
//index shouldnt exceeds actual arraylist size
//if arraylist's size is 20, then can add or replace
value from 0 to 19th index,
//cannt add or replace value for more than 19th index
//arrlistObj1.add(22, "newtest1");
//arrlistObj1.aet(25, "newtest1");

arrlistObj1.add(1, "newtest1");
arrlistObj1.set(3, "newtest2");

//some list interface's method
//index should not exceeds arraylist size
System.out.println("value in 3rd position is " +
arrlistObj1.get(3));

//some list interface's method
//can get the index of particular value in arraylist
System.out.println("Index of test1 is " +
arrlistObj1.indexOf("test1"));

//size
int size = arrlistObj1.size();

System.out.println("Size of arraylist is " + size);

//to get or display all the entry in arraylist
//1. using iterator
Iterator itr = arrlistObj1.iterator();

while (itr.hasNext())
{
//if all the entry are same data type, then can
typecast and store in varibale as follows
//String entry = (String) itr.next();
//Double entry = (Double) itr.next();
//System.out.println("Iterator : Value = " + entry);

//if all the entry are different, then can store it
as follows
//Object obj = itr.next();
//System.out.println("Iterator : Value = " + obj);

System.out.println("Iterator : Value = " + itr.next());
}

//2. using toArray
Object[] obj = arrlistObj1.toArray();

for (int i = 0; i < arrlistObj1.size(); i++)
{
System.out.println("toArray : Value = " + obj[i]);
}

ArrayList arrlistObj2 = new ArrayList();

arrlistObj2.add("newtest");
//add all the entry from arrlistObj1 to arrlistObj2.
arrlistObj2.addAll(arrlistObj1);

arrlistObj1.remove("test1");
arrlistObj1.remove("test3");

//remove all entry of arrlistObj1 in arrlistObj2.
arrlistObj2.removeAll(arrlistObj1);

}
}


List - Vector sample
--------------------------------------------------------------------------------

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;

/**
* @author Vikneshwaran
* @version 1.0
* #################### Template #####################
* class class_name
* {
* List list_obj1 = new Vector();
* Vector veclist_obj1 = new Vector();
*
* veclist_obj1.add(...);
* veclist_obj1.remove(...);
* veclist_obj1.contains(...);
* int size = veclist_obj1.size();
* Iterator itr_obj = veclist_obj1.iterator();
* Object[] obj = veclist_obj1.toArray();
*
* veclist_obj1.add(.., ..);
* veclist_obj1.set(.., ..);
* veclist_obj1.get(...);
* veclist_obj1.indexOf(...);
* }
*
* ####################################################
*/

//1. Vector allows duplicate value
//2. Vector allows null value
//3. Vector allows different type of data types in single object
//4. Synchronized one
//5. stores the values in indexed way.
public class ListSample2
{
public static void main (String args[])
{
//since list is interface, object cannt be created as
follows
//List listObj = new List();

//using implemented class like ArrayList, Vector &
LinkedList, can do
List listObj1 = new Vector(); //dynamic binding or
runtime polymorphim
Vector veclistObj1 = new Vector();

//also can do
Vector veclist_obj1 = new Vector(10);//after size is
full, it will be increased to double size
Vector veclist_obj2 = new Vector(10, 5);//after size
is full, it will be increased by 2

//collection interface(Set, List) and Map interface
allows object only,
//primitive value cannt be added as follows
/*
int a = 50;
double b = 10.00;
long c = 100;

veclistObj1.add(10);
veclistObj1.add(10.00);
veclistObj1.add(test);

veclistObj1.add(a);
veclistObj1.add(b);
veclistObj1.add(c);
*/

//but we can add as follows
int a = 40;
double b = 50.00;
long c = 60;
String d = "test3";

veclistObj1.add(new Integer(10));
veclistObj1.add(new Double(20.00));
veclistObj1.add(new Long(30));
veclistObj1.add("test1");
veclistObj1.add(new String("test2"));

veclistObj1.add(new Integer(a));
veclistObj1.add(new Double(b));
veclistObj1.add(new Long(c));
veclistObj1.add(d);

//vector allows duplicate value
veclistObj1.add("test4");
veclistObj1.add("test4");

//vector allows null value
veclistObj1.add(null);

//remove the entry from vector
veclistObj1.remove("test2");
veclistObj1.remove(new Integer(10));
veclistObj1.remove(new Double(b));

//check the entry is already there or not
boolean cont = veclistObj1.contains("test4");//return
boolean true or false

//remove all the entry
//veclistObj1.clear();

//some list interface's method
//can add or replace value to particular index.
//index shouldnt exceeds actual arraylist size
//if arraylist's size is 20, then can add or replace
value from 0 to 19th index,
//cannt add or replace value for more than 19th index
//veclistObj1.add(22, "newtest1");
//veclistObj1.aet(25, "newtest1");

veclistObj1.add(1, "newtest1");
veclistObj1.set(3, "newtest2");

//some list interface's method
//index should not exceeds arraylist size
System.out.println("value in 3rd position is " +
veclistObj1.get(3));

//some list interface's method
//can get the index of particular value in arraylist
System.out.println("Index of test1 is " +
veclistObj1.indexOf("test1"));

//some vector class's method
veclistObj1.addElement("newelement1");
veclistObj1.setElementAt("newelement2", 1);
veclistObj1.setElementAt("newelement3", 2);
System.out.println("Element at 1 is " +
veclistObj1.elementAt(1));
veclistObj1.removeElementAt(1);

//size
int size = veclistObj1.size();

System.out.println("Size of vector is " + size);

//to get or display all the entry in vector
//1. using iterator
Iterator itr = veclistObj1.iterator();

while (itr.hasNext())
{
//if all the entry are same data type, then can
typecast and store in varibale as follows
//String entry = (String) itr.next();
//Double entry = (Double) itr.next();
//System.out.println("Iterator : Value = " + entry);

//if all the entry are different, then can store it
as follows
//Object obj = itr.next();
//System.out.println("Iterator : Value = " + obj);

System.out.println("Iterator : Value = " + itr.next());
}

//2. using toArray
Object[] obj = veclistObj1.toArray();

for (int i = 0; i < veclistObj1.size(); i++)
{
System.out.println("toArray : Value = " + obj[i]);
}

Vector veclistObj2 = new Vector();

veclistObj2.add("newtest");
//add all the entry from veclistObj1 to veclistObj2.
veclistObj2.addAll(veclistObj1);

veclistObj1.remove("test1");
veclistObj1.remove("test3");

//remove all entry of veclistObj1 in veclistObj2.
veclistObj2.removeAll(veclistObj1);

}
}

List - LinkedList sample
--------------------------------------------------------------------------------

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

/**
* @author Vikneshwaran
* @version 1.0
* #################### Template #####################
* class class_name
* {
* List list_obj1 = new LinkedList();
* LinkedList linklist_obj1 = new LinkedList();
*
* linklist_obj1.add(...);
* linklist_obj1.remove(...);
* linklist_obj1.contains(...);
* int size = linklist_obj1.size();
* Iterator itr_obj = linklist_obj1.iterator();
* Object[] obj = linklist_obj1.toArray();
*
* }
*
* ####################################################
*/

//1. LinkedList allows duplicate value
//2. LinkedList allows null value
//3. LinkedList allows different type of data types in
single object
//4. not Synchronized one
//5. stores the values in indexed way.
//6. can add or remove entry at front and end of LinkedList
public class ListSample3
{
public static void main (String args[])
{
//since list is interface, object cannt be created as
follows
//List listObj = new List();

//using implemented class like ArrayList, Vector &
LinkedList, can do
List listObj1 = new LinkedList(); //dynamic binding or
runtime polymorphim
LinkedList linklistObj1 = new LinkedList();

//cannt do
//LinkedList linklist_obj1 = new LinkedList(10);
//LinkedList linklist_obj2 = new LinkedList(10, 5);

//collection interface(Set, List) and Map interface
allows object only,
//primitive value cannt be added as follows
/*
int a = 50;
double b = 10.00;
long c = 100;

linklistObj1.add(10);
linklistObj1.add(10.00);
linklistObj1.add(test);

linklistObj1.add(a);
linklistObj1.add(b);
linklistObj1.add(c);
*/

//but can add as follows
int a = 40;
double b = 50.00;
long c = 60;
String d = "test3";

linklistObj1.add(new Integer(10));
linklistObj1.add(new Double(20.00));
linklistObj1.add(new Long(30));
linklistObj1.add("test1");
linklistObj1.add(new String("test2"));

linklistObj1.add(new Integer(a));
linklistObj1.add(new Double(b));
linklistObj1.add(new Long(c));
linklistObj1.add(d);

//vector allows duplicate value
linklistObj1.add("test4");
linklistObj1.add("test4");

//vector allows null value
linklistObj1.add(null);

//remove the entry from vector
linklistObj1.remove("test2");
linklistObj1.remove(new Integer(10));
linklistObj1.remove(new Double(b));

//check the entry is already there or not
boolean cont = linklistObj1.contains("test4");//return
boolean true or false

//remove all the entry
//linklistObj1.clear();

//some list interface's method
//can add or replace value to particular index.
//index shouldnt exceeds actual arraylist size
//if arraylist's size is 20, then can add or replace
value from 0 to 19th index,
//cannt add or replace value for more than 19th index
//linklistObj1.add(22, "newtest1");
//linklistObj1.aet(25, "newtest1");

linklistObj1.add(1, "newtest1");
linklistObj1.set(3, "newtest2");

//some list interface's method
//index should not exceeds arraylist size
System.out.println("value in 3rd position is " +
linklistObj1.get(3));

//some list interface's method
//can get the index of particular value in arraylist
System.out.println("Index of test1 is " +
linklistObj1.indexOf("test1"));

//some linkedlist class's methods
linklistObj1.addFirst("newelement1");
linklistObj1.addFirst("newelement2");
linklistObj1.addLast("newelement5");
linklistObj1.addLast("newelement6");
System.out.println("value at first is " +
linklistObj1.getFirst());
System.out.println("value at last is " +
linklistObj1.getLast());
linklistObj1.removeFirst();
linklistObj1.removeLast();

//size
int size = linklistObj1.size();

System.out.println("Size of vector is " + size);

//to get or display all the entry in linkedlist
//1. using iterator
Iterator itr = linklistObj1.iterator();

while (itr.hasNext())
{
//if all the entry are same data type, then can
typecast and store in varibale as follows
//String entry = (String) itr.next();
//Double entry = (Double) itr.next();
//System.out.println("Iterator : Value = " + entry);

//if all the entry are different, then can store it
as follows
//Object obj = itr.next();
//System.out.println("Iterator : Value = " + obj);

System.out.println("Iterator : Value = " + itr.next());
}

//2. using toArray
Object[] obj = linklistObj1.toArray();

for (int i = 0; i < linklistObj1.size(); i++)
{
System.out.println("toArray : Value in linkedlist =
" + obj[i]);
}

LinkedList linklistObj2 = new LinkedList();

linklistObj2.add("newtest");
//add all the entry from linklistObj1 to linklistObj2.
linklistObj2.addAll(linklistObj1);

linklistObj1.remove("test1");
linklistObj1.remove("test3");

//remove all entry of linklistObj1 in linklistObj2.
linklistObj2.removeAll(linklistObj1);
}
}

Map - HashMap sample
--------------------------------------------------------------------------------

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
* @author Vikneshwaran
* @version 1.0
* #################### Template #####################
* class class_name
* {
* Map map_obj1 = new HashMap();
* HashMap hashmap_obj1 = new HashMap();
*
* hashmap_obj1.put(.., ..);
* hashmap_obj1.remove(...);
* hashmap_obj1.containsKey(...);
* hashmap_obj1.containsValue(...);
* int size = hashmap_obj1.size();
* Set set_obj = hashmap_obj1.KeySet();
* Iterator itr_obj = set_obj.iterator();
* Collection coll_obj = hashmap_obj1.Values();
* Object[] obj = coll_obj.toArray();
* }
*
* ####################################################
*/

//1. HashMap doesnt allows duplicate value
//2. HashMap doesnt allows null value
//3. HashMap allows different type of data types in single
object
//4. not Synchronized one
//5. Stores the entry in key value pair way
public class MapSample2
{
public static void main (String args[])
{
//since map is interface, object cannt be created as
follows
//Map mapObj = new Map();

//using implemented class like HashMap, HashTable and
Properties, can do
Map mapObj1 = new HashMap(); //dynamic binding or
runtime polymorphim
HashMap hashmapObj1 = new HashMap();

//can do as follows
HashMap hashmap_obj1 = new HashMap(10);//after the size
is full, it will be increased to double size
HashMap hashmap_obj2 = new HashMap(10, 5);//after the
size is full, it will be increased by 5

//collection interface(Set, List) and Map interface
allows object only,
//primitive value cannt be added as follows
/*
int a = 50;
double b = 10.00;
long c = 100;

hashmapObj1.put(10, "value1");
hashmapObj1.put(10.00, "value2");
hashmapObj1.put(test, "value3");

hashmapObj1.put(a, "value4");
hashmapObj1.put(b, "value5");
hashmapObj1.put(c, "value6");
*/

//but we can do as follows
int a = 40;
double b = 50.00;
long c = 60;
String d = "test3";

hashmapObj1.put(new Integer(10), "value1");
hashmapObj1.put(new Double(20.00), "value2");
hashmapObj1.put(new Long(30), "value3");
hashmapObj1.put("test1", "value4");
hashmapObj1.put(new String("test2"), "value5");

hashmapObj1.put(new Integer(a), "value6");
hashmapObj1.put(new Double(b), "value7");
hashmapObj1.put(new Long(c), "value8");
hashmapObj1.put(d, "value9");

//hashmap doesnt allows duplicate value, can add as
follows but it will store single entry only
hashmapObj1.put("test4", "value10");
hashmapObj1.put("test4", "value11");
//hashmap allows null value
hashmapObj1.put(null, "value12");
hashmapObj1.put(null, null);

//remove the entry
hashmapObj1.remove("test2");
hashmapObj1.remove(new Integer(10));
hashmapObj1.remove(new Double(b));

//check the key is already there or not
boolean cont1 =
hashmapObj1.containsKey("test4");//return boolean true or false

//check the value is already there or not
boolean cont2 =
hashmapObj1.containsValue("value4");//return boolean true or
false


//get the value for particular key
System.out.println("value of key test4 is " +
hashmapObj1.get("test4"));

//remove all the entry
//hashmapObj1.clear();

//size of the set
int size = hashmapObj1.size();

System.out.println("Size of HashMap is " + size);

//to get or display all the entry in hashmap
//1. using keyset and iterator
//get all the keys from hashmap
Set setObj = hashmapObj1.keySet();
Iterator itr = setObj.iterator();

while (itr.hasNext())
{
//if all the entry are same data type, then can
typecast and store in varibale as follows
//String entry = (String) itr.next();
//Double entry = (Double) itr.next();
//System.out.println("Iterator : Value = " + entry);

//if all the entry are different, then can store it
as follows
Object obj = itr.next();
System.out.println("Key in Hashmap = " + obj);
System.out.println("Value in Hashmap is " +
hashmapObj1.get(obj));
}

//get the all the values from hashmap
Collection collObj = hashmapObj1.values();

//2. using toArray
Object[] obj = collObj.toArray();

for (int i = 0; i < collObj.size(); i++)
{
System.out.println("Value in HashMap = " + obj[i]);
}

HashMap hashmapObj2 = new HashMap();

hashmapObj2.put("newtest", "newvalue1");
//add all the entry from hashmapObj1 to hashmapObj2.
hashmapObj2.putAll(hashmapObj1);

//removeall method is not available.
//hashmapObj2.removeAll(hashmapObj1);

}
}

Map - Hashtable sample
--------------------------------------------------------------------------------

import java.util.Collection;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
* @author Vikneshwaran
* @version 1.0
* #################### Template #####################
* class class_name
* {
* Map map_obj1 = new Hashtable();
* Hashable hashtable_obj1 = new Hashtable();
*
* hashtable_obj1.put(.., ..);
* hashtable_obj1.remove(...);
* hashtable_obj1.containsKey(...);
* hashtable_obj1.containsValue(...);
* int size = hashtable_obj1.size();
* Set set_obj = hashtable_obj1.KeySet();
* Iterator itr_obj = set_obj.iterator();
* Collection coll_obj = hashtable_obj1.Values();
* Object[] obj = coll_obj.toArray();
*
* }
*
* ####################################################
*/

//1. HashTable doesnt allows duplicate value
//2. HashTable doesnt allows null value
//3. HashTable allows different type of data types in single
object
//4. Synchronized one
//5. Stores the entry in key value pair way
public class MapSample1
{
public static void main (String args[])
{
//since map is interface, object cannt be created as
follows
//Map mapObj = new Map();

//using implemented class like HashMap, HashTable and
Properties, can do
Map mapObj1 = new Hashtable(); //dynamic binding or
runtime polymorphim
Hashtable hashtableObj1 = new Hashtable();

//can do as follows
Hashtable hashtable_obj1 = new Hashtable(10);//after
the size is full, it will be increased to double size
Hashtable hashtable_obj2 = new Hashtable(10,
5);//after the size is full, it will be increased by 5

//collection interface(Set, List) and Map interface
allows object only,
//primitive value cannt be added as follows
/*
int a = 50;
double b = 10.00;
long c = 100;

hashtableObj1.put(10, "value1");
hashtableObj1.put(10.00, "value2");
hashtableObj1.put(test, "value3");

hashtableObj1.put(a, "value4");
hashtableObj1.put(b, "value5");
hashtableObj1.put(c, "value6");
*/

//but can add as follows
int a = 40;
double b = 50.00;
long c = 60;
String d = "test3";

hashtableObj1.put(new Integer(10), "value1");
hashtableObj1.put(new Double(20.00), "value2");
hashtableObj1.put(new Long(30), "value3");
hashtableObj1.put("test1", "value4");
hashtableObj1.put(new String("test2"), "value5");

hashtableObj1.put(new Integer(a), "value6");
hashtableObj1.put(new Double(b), "value7");
hashtableObj1.put(new Long(c), "value8");
hashtableObj1.put(d, "value9");

//hashtable doesnt allows duplicate value, can add as
follows but it will store single entry only
hashtableObj1.put("test4", "value10");
hashtableObj1.put("test4", "value11");

//hashtable doesnt allows null value
//hashtableObj1.put(null, "value12");
//hashtableObj1.put(null, null);

//remove the entry
hashtableObj1.remove("test2");
hashtableObj1.remove(new Integer(10));
hashtableObj1.remove(new Double(b));

//check the key is already there or not
boolean cont1 =
hashtableObj1.containsKey("test4");//return boolean true or
false

//check the value is already there or not
boolean cont2 =
hashtableObj1.containsValue("value4");//return boolean true
or false

//get the value for particular key
System.out.println("value of key test4 is " +
hashtableObj1.get("test4"));

//remove all the entry
//hashtableObj1.clear();

//size of the set
int size = hashtableObj1.size();

System.out.println("Size of Hashtable is " + size);

//to get or display all the entry in hashmap
//1. using keyset and iterator
//get all the keys from hashmap
Set setObj = hashtableObj1.keySet();
Iterator itr = setObj.iterator();

while (itr.hasNext())
{
//if all the entry are same data type, then can
typecast and store in varibale as follows
//String entry = (String) itr.next();
//Double entry = (Double) itr.next();
//System.out.println("Iterator : Value = " + entry);

//if all the entry are different, then can store it
as follows
Object obj = itr.next();
System.out.println("Key in Hashtable = " + obj);
System.out.println("Value in Hashtable is " +
hashtableObj1.get(obj));
}


//get the all the values from hashmap
Collection collObj = hashtableObj1.values();

//2. using toArray
Object[] obj = collObj.toArray();

for (int i = 0; i < collObj.size(); i++)
{
System.out.println("Value in Hashtable = " + obj[i]);
}

Hashtable hashtableObj2 = new Hashtable();

hashtableObj2.put("newtest", "newvalue1");
//add all the entry from hashtableObj1 to hashtableObj2.
hashtableObj2.putAll(hashtableObj1);

//removeall method is not available.
//hashtableObj2.removeAll(hashtableObj1);

}
}

Map - Properties sample
--------------------------------------------------------------------------------

import java.util.Collection;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

/**
* @author Vikneshwaran
* @version 1.0
* #################### Template #####################
* class class_name
* {
* Map map_obj1 = new Properties();
* Hashtable hashmap_obj1 = new Properties();
* Properties prop_obj1 = new Properties();
*
* prop_obj1.put(.., ..);
* prop_obj1.remove(...);
* prop_obj1.containsKey(...);
* prop_obj1.containsValue(...);
* int size = prop_obj1.size();
* Set set_obj = prop_obj1.KeySet();
* Iterator itr_obj = set_obj.iterator();
* Collection coll_obj = prop_obj1.Values();
* Object[] obj = coll_obj.toArray();
*
* }
*
* ####################################################
*/

//1. Properties doesnt allows duplicate value
//2. Properties doesnt allows null value
//3. Properties allows different type of data types in
single object
//4. not Synchronized one
//5. Stores the entry in key value pair way
public class MapSample3
{
public static void main (String args[])
{
//since map is interface, object cannt be created as
follows
//Map mapObj = new Map();

//using implemented class like HashMap, HashTable and
Properties, can do
Map mapObj1 = new Properties(); //dynamic binding or
runtime polymorphim
//Since its a subclass of hashtable,
Hashtable propObj2 = new Properties();

Properties propmapObj1 = new Properties();

//cannt do as follows
//Properties proppmap_obj1 = new Properties(10);
//Properties propmap_obj2 = new Properties(10, 5);

//collection interface(Set, List) and Map interface
allows object only,
//primitive value cannt be added as follows
/*
int a = 50;
double b = 10.00;
long c = 100;

propmapObj1.put(10, "value1");
propmapObj1.put(10.00, "value2");
propmapObj1.put(test, "value3");

propmapObj1.put(a, "value4");
propmapObj1.put(b, "value5");
propmapObj1.put(c, "value6");
*/

//but can add as follows
int a = 40;
double b = 50.00;
long c = 60;
String d = "test3";

propmapObj1.put(new Integer(10), "value1");
propmapObj1.put(new Double(20.00), "value2");
propmapObj1.put(new Long(30), "value3");
propmapObj1.put("test1", "value4");
propmapObj1.put(new String("test2"), "value5");

propmapObj1.put(new Integer(a), "value6");
propmapObj1.put(new Double(b), "value7");
propmapObj1.put(new Long(c), "value8");
propmapObj1.put(d, "value9");

//properties doesnt allows duplicate value, can add as
follows but it will store single entry only
propmapObj1.put("test4", "value10");
propmapObj1.put("test4", "value11");
//properties doesnt allows null value
//propmapObj1.put(null, "value12");
//propmapObj1.put(null, null);

//properties extra's methods
propmapObj1.setProperty("test5", "value11");
//setProperty can hold string key and String value only
//propmapObj1.setProperty(new Integer(10), "value11");

System.out.println("Value of property is " +
propmapObj1.getProperty("test5"));

System.out.println("Value of property is " +
propmapObj1.getProperty("test5", "default value"));

//remove the entry from properties using key
propmapObj1.remove("test2");
propmapObj1.remove(new Integer(10));
propmapObj1.remove(new Double(b));

//check the key is already there or not
boolean cont1 =
propmapObj1.containsKey("test4");//return boolean true or false

//check the value is already there or not
boolean cont2 =
propmapObj1.containsValue("value4");//return boolean true or
false

System.out.println("value of key test4 is " +
propmapObj1.get("test4"));

//remove all the entry
//propmapObj1.clear();

//size of the set
int size = propmapObj1.size();

System.out.println("Size of Properties is " + size);

//to get or display all the entry in hashmap
//1. using keyset and iterator
//get all the keys from hashmap
Set setObj = propmapObj1.keySet();
Iterator itr = setObj.iterator();

while (itr.hasNext())
{
//if all the entry are same data type, then can
typecast and store in varibale as follows
//String entry = (String) itr.next();
//Double entry = (Double) itr.next();
//System.out.println("Iterator : Value = " + entry);

//if all the entry are different, then can store it
as follows
Object key = itr.next();

System.out.println("Key in Properties is " + key);

System.out.println("Value in Properties is " +
propmapObj1.get(key));
}

//get the all the values from properties
Collection collObj = propmapObj1.values();

//2. using toArray
Object[] obj = collObj.toArray();

for (int i = 0; i < collObj.size(); i++)
{
System.out.println("Value in Properties = " + obj[i]);
}

Properties propmapObj2 = new Properties();

propmapObj2.put("newtest", "newvalue1");
//add all the entry from propmapObj1 to propmapObj2.
propmapObj2.putAll(propmapObj1);

//removeall method is not available.
//propmapObj2.removeAll(propmapObj1);

}
}

have any query

cal @9962590014

Can a class be private in java?

537

---

How do you format in java?

545

---

Is main a keyword in java?

534

---

Where is jre installed?

585

---

What is variable and constant explain with example?

528

---

---

what is instanceof operator used in java?

588

---

What is the purpose of tostring() method in java?

549

---

What is identifier in java?

552

---

What does sprintf mean?

527

---

What is a methodologist?

528

---

what is collatration?

2737

---

What is diamond operator in java?

494

---

worst case complexities of Quick sort and Merge sort.

598

---

What is java english?

489

---

What are methods in java?

536

---