JavaHotSpotBlog

Collections in Java

2011-10-20T07:55:00.001-07:00

ZR4WWVV6HFVA

What is Collection?

Collection is general term that means something like container that holds bunch of objects stored in ordered manner. Or Collection is an object that groups multiple elements into a single unit. Collections are used to store, retrieve, manipulate, and communicate groups of data.

Collections are one of the most powerful parts of any programming language. Collections implement data structures that lie at the heart of managing complex information and relationships.

The Collections Framework

A framework is a set of classes that form the basis for building advanced functionality. A framework contains superclasses with useful functionality, policies, and mechanisms. The user of a framework forms subclasses to extend the functionality without having to reinvent the basic mechanisms. For example, Swing is a framework for user interfaces.

The Java collections library forms a framework for collection classes. It defines a number of interfaces and abstract classes for implementers of collections.

The following diagram shows the interfaces of the Collection Framework

Interfaces of the Collection Framework

The four basic collection interfaces are:

Collection: Collection interface support grouping of objects.
List: List extends Collection interface and used to implement list of objects. Allows duplicate objects and positional indexing.
Set: Set extends Collection interface and used to implement set of objects. Duplicates are not allowed.
Map: Map extends Collection interface used to implement special type of lists.

Interface	Implementation
Set	HashSet		TreeSet
List		ArrayList		LinkedList
Map	HashMap		TreeMap

Related Articles:

Stack

Vector

HashTable

TreeMap

HashMap

TreeSet

HashSet

LinkedList

ArrayList

Stack in Java

2011-10-20T06:12:00.001-07:00

A stack is a data structure that allows data to be inserted at one end called push operation and removed at another end called pop.
Stack class extends Vector class and implements standard Last in First out (LIFO) data structure.
Stack doesn’t require any fix dimension like String array and int array.

The following table demonstrates methods of the stack class

Method	Meaning
push()	Adds an item into the top of stack.
pop()	Removes the item from the stack and returns that item.
peek()	Returns the item from the top of the stack without removing it.
empty()	Returns true if the stack is empty.
search()	Returns the position of an object on the stack.

The following program shows a simple use of Stack.

Example:

/**

From SimpleStack.java

import java.util.Stack;

/**

* @author JavaHotSpot

public class SimpleStack

{

public static void main(String args[])

{

Stack<String> st = new Stack<String>();

st.push("Red");

st.push("Green");

st.push("Blue");

st.push("Orange");

st.push("Yellow");

st.push("White");

st.push("Black");

System.out.println("Stack Elements are");

System.out.println(st.pop());

}

Output:

Stack Elements are

Black

White

Yellow

Orange

Blue

Green

Red

The following program shows of Stack with Iterator Interface.

Example:

/**

From StackWithIterator.java

import java.util.Iterator;

import java.util.Stack;

/**

* @author JavaHotSpot

public class StackWithIterator

{

public static void main(String args[])

{

Stack<String> st = new Stack<String>();

st.push("Red");

st.push("Green");

st.push("Blue");

st.push("Orange");

st.push("Yellow");

st.push("White");

st.push("Black");

System.out.println("Stack Elements are");

Iterator it = st.iterator();

while(it.hasNext())

{

System.out.println(it.next());

}

Output:

Stack Elements are

Red

Green

Blue

Orange

Yellow

White

Black

Related Articles:

ZR4WWVV6HFVA

Vector in Java

2011-10-20T06:11:00.001-07:00

Vector class extends AbstractList and implements List interface.
Vector is dynamic array which can grow automatically according to the required size.
Vectors can hold only objects and not primitive types (eg: int,float,double etc). If you want to put a primitive type in a Vector, put it inside an object.
Vector value can get by Enumeration interface.
Vector is synchronized and hence thread – safe.
Vector can be used in multi – threaded environment.
The default size of vector is 10.
Vector provides basic operations such as addElement(), elementAt( ), firstElement( ), lastElement( ), indexOf( ), lastIndexOf( ), removeElement( ) and removeElementAt( ) method.

The following table demonstrates the constructors of the Vector class and its meaning.

Constructor	Meaning
Vector()	Constructs an empty vector.
Vector(Collection c)	Constructs a vector containing the elements of the given collection.
Vector(int capacity)	Constructs a vector with the given initial capacity.
Vector(int capacity, int incr)	Constructs a vector with the given initial capacity and incremental value

The following program shows a simple use of Vector.

Example:

/**

From SimpleVector.java

import java.util.Vector;

/**

* @author JavaHotSpot

public class SimpleVector

{

public static void main(String args[])

{

Vector v = new Vector();

v.addElement("Item1");

v.addElement("Item2");

v.addElement("Item3");

v.addElement("Item4");

v.addElement("Item5");

v.addElement("Item6");

v.addElement("Item7");

System.out.println("Size="+v.size());

System.out.println("First Element="+v.firstElement());

System.out.println("Last Element="+v.lastElement());

System.out.println("The Vector elements are"+"\n"+v);

}

Output:

Size=7

First Element=Item1

Last Element=Item7

The Vector elements are

[Item1, Item2, Item3, Item4, Item5, Item6, Item7]

The following program shows use of Vector with Enumeration Interface.

Example:

/**

From VectorwithEnumeration.java

import java.util.Enumeration;

import java.util.Vector;

/**

* @author JavaHotSpot

public class VectorwithEnumeration

{

public static void main(String args[])

{

Vector v = new Vector();

v.addElement("Item1");

v.addElement("Item2");

v.addElement("Item3");

v.addElement("Item4");

v.addElement("Item5");

v.addElement("Item6");

v.addElement("Item7");

System.out.println("The Vector elements are");

Enumeration em = v.elements();

while(em.hasMoreElements())

{

System.out.println(em.nextElement());

}

Output:

The Vector elements are

Item1

Item2

Item3

Item4

Item5

Item6

Item7

Related Articles:

Collections in Java

Stack

HashTable

TreeMap

HashMap

TreeSet

HashSet

LinkedList

ArrayList

HashTable in Java

2011-10-20T06:09:00.001-07:00

The HashTable class extends Dictionary and implements Map interface.
The Hashtable internally contains buckets in which it stores the key or value pairs.
The HashTable can only store objects that override the hashCode() and equals() methods that are defined by Object.
The HashTable value can get by Enumeration interface.
The HashTable do not permit null values as key and value.
The HashTable is synchronized.
The HashTable is less efficient compared to HashMap.
The two most important HashTables methods are:

get(Object Key) - returns the value associated with specified key in this hash table, or null if there is no value for this key.

put(Object Ket, Object Value) - associates the specified value with the specified key in hash table.

The following table demonstrates the constructors of HashTable and their meanings.

Constructor	Meaning
HashTable()	Constructs a new empty map object.
HashTable(Map m)	Constructs a new map with the given map.
HashTable(int Capacity)	Constructs a new map with the given capacity.
HashTable(int Capacity, float loadfactor)	Constructs a new map with the given capacity and the given load factor.

The following program shows a simple use of HashTable.

Example:

/**

From SimpleHashTable.java

import java.util.Hashtable;

/**

* @author JavaHotSpot

public class SimpleHashTable

{

public static void main(String args[])

{

Hashtable<String,Float> htable = new Hashtable<String,Float>();

htable.put("Apple", new Float(88.91));

htable.put("Grape", new Float(78.45));

htable.put("Banana", new Float(92.61));

htable.put("Mango", new Float(95.11));

htable.put("Orange", new Float(82.54));

htable.put("Pinapple", new Float(73.41));

System.out.println("The HashTable elements are"+"\n"+htable);

}

Output

The HashTable elements are

{Mango=95.11, Orange=82.54, Pinapple=73.41, Grape=78.45, Apple=88.91, Banana=92.61}

The following program shows use of HashTable with Enumeration Interface.

Example:

/**

From HashTablewithEnumeration.java

import java.util.Enumeration;

import java.util.Hashtable;

/**

* @author JavaHotSpot

public class HashTablewithEnumeration

{

public static void main(String args[])

{

String ss;

Hashtable<String,Float> htable = new Hashtable<String,Float>();

htable.put("Apple", new Float(88.91));

htable.put("Grape", new Float(78.45));

htable.put("Banana", new Float(92.61));

htable.put("Mango", new Float(95.11));

htable.put("Orange", new Float(82.54));

htable.put("Pinapple", new Float(73.41));

System.out.println("The HashTable elements are");

Enumeration em = htable.keys();

while(em.hasMoreElements())

{

ss = (String)em.nextElement();

System.out.println(ss +"="+htable.get(ss));

}

Output

The HashTable elements are

Mango=95.11

Orange=82.54

Pinapple=73.41

Grape=78.45

Apple=88.91

Banana=92.61

Related Articles:

TreeMap in Java

2011-10-20T06:08:00.001-07:00

The TreeMap class extends AbstractMap and implements SortedMap interface.
The TreeMap uses tree Structure for internal storage.
The TreeMap provides an efficient means of storing key or value pairs in sorted order, and allows rapid retrieval.
The TreeMap value can get by Iterator interface.
The TreeMap is not synchronized. If more than one thread wants to access it at the same time then it must be synchronized externally using Collections.synchronizedMap( mapName ).

The following table demonstrates the constructors of TreeMap and corresponding methods.

Constructor	Meaning
TreeMap()	Constructs a new empty map object.
TreeMap (Map m)	Constructs a new map with the given map.
TreeMap (Comparator cmp)	Constructs a new map, sorted according to the given comparator.
TreeMap (SortedMap sp)	Constructs a new map, sorted according to the given sorted map.

The following program shows a simple use of TreeMap.

Example:

/**

From SimpleTreeMap.java

import java.util.TreeMap;

/**

* @author JavaHotSpot

public class SimpleTreeMap

{

public static void main(String args[])

{

TreeMap<String,Float> tmap = new TreeMap<String,Float>();

tmap.put("Apple", new Float(88.91));

tmap.put("Grape", new Float(78.45));

tmap.put("Banana", new Float(92.61));

tmap.put("Mango", new Float(95.11));

tmap.put("Orange", new Float(82.54));

tmap.put("Pinapple", new Float(73.41));

System.out.println("The HashMap elements are"+"\n"+tmap);

}

Output

The HashMap elements are

{Apple=88.91, Banana=92.61, Grape=78.45, Mango=95.11, Orange=82.54, Pinapple=73.41}

The following program shows use of TreeMap with Iterator and Map Interface.

Example:

/**

From TreeMapwithIterator.java

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

import java.util.TreeMap;

/**

* @author JavaHotSpot

public class TreeMapwithIterator

{

public static void main(String args[])

{

TreeMap<String,Float> tmap = new TreeMap<String,Float>();

tmap.put("Apple", new Float(88.91));

tmap.put("Grape", new Float(78.45));

tmap.put("Banana", new Float(92.61));

tmap.put("Mango", new Float(95.11));

tmap.put("Orange", new Float(82.54));

tmap.put("Pinapple", new Float(73.41));

System.out.println("The HashMap elements are");

Set set = tmap.entrySet();

Iterator it = set.iterator();

while(it.hasNext())

{

Map.Entry mapent = (Map.Entry)it.next();

System.out.println(mapent.getKey()+"="+mapent.getValue());

}

Output

The HashMap elements are

Apple=88.91

Banana=92.61

Grape=78.45

Mango=95.11

Orange=82.54

Pinapple=73.41

Related Articles:

Collections in Java

Stack

Vector

HashTable

HashMap

TreeSet

HashSet

LinkedList

ArrayList

HashMap in Java

2011-10-20T06:05:00.001-07:00

The HashMap let you store data as key or value pairs, where both the key and the value are objects.
The HashMap class extends AbstractMap and implements Map interface.
The HashMap uses hash table for internal storage.
The HashMap permits null value and null key.
HashMap is not synchronized. If more than one thread wants to access it at the same time then it must be synchronized externally.
The two most important HashMap's methods are:

get(Object Key) - returns the value associated with specified key in this hash map, or null if there is no value for this key.

put(Object Ket, Object Value) - associates the specified value with the specified key in this map.

The following table demonstrates the constructors of HashMap and corresponding methods.

Constructor	Meaning
HashMap()	Constructs a new empty map object.
HashMap (Map m)	Constructs a new map with the given map.
HashMap (int Capacity)	Constructs a new map with the given capacity.
HashMap (int Capacity, float loadfactor)	Constructs a new map with the given capacity and the given load factor.

The following program shows a simple use of HashMap.

Example:

/**

From SimpleHashMap.java

import java.util.HashMap;

/**

* @author JavaHotSpot

public class SimpleHashMap

{

public static void main(String args[])

{

HashMap<String,Float> hmap = new HashMap<String,Float>();

hmap.put("Apple", new Float(88.91));

hmap.put("Grape", new Float(78.45));

hmap.put("Banana", new Float(92.61));

hmap.put("Mango", new Float(95.11));

hmap.put("Orange", new Float(82.54));

hmap.put("Pinapple", new Float(73.41));

System.out.println("The HashMap elements are"+"\n"+hmap);

}

Output:

The HashMap elements are

{Pinapple=73.41, Mango=95.11, Apple=88.91, Orange=82.54, Banana=92.61, Grape=78.45}

The following program shows use of HashMap with Iterator and Map Interface.

Example:

/**

From HashmapwithIterator.java

import java.util.HashMap;

import java.util.Iterator;

import java.util.Set;

import java.util.Map;

/**

* @author JavaHotSpot

public class HashmapwithIterator

{

public static void main(String args[])

{

HashMap<String,Float> hmap = new HashMap<String,Float>();

hmap.put("Apple", new Float(88.91));

hmap.put("Grape", new Float(78.45));

hmap.put("Banana", new Float(92.61));

hmap.put("Mango", new Float(95.11));

hmap.put("Orange", new Float(82.54));

hmap.put("Pinapple", new Float(73.41));

System.out.println("The HashMap elements are");

Set set = hmap.entrySet();

Iterator it = set.iterator();

while(it.hasNext())

{

Map.Entry mapent = (Map.Entry)it.next();

System.out.println(mapent.getKey()+"="+mapent.getValue());

}

Output:

The HashMap elements are

Pinapple=73.41

Mango=95.11

Apple=88.91

Orange=82.54

Banana=92.61

Grape=78.45

Related Articles:

Collections in Java

Stack

Vector

HashTable

TreeMap

TreeSet

HashSet

LinkedList

ArrayList

TreeSet in Java

2011-10-20T06:04:00.000-07:00

The TreeSet class extends AbstractSet and implements set interface.
The TreeSet uses tree structure for internal storage.
The TreeSet stores objects in a sorted manner because TreeSet stores its elements in a tree structure.
In TreeSet, Access and retrieval times are quite fast.
The TreeSet value can get by Iterator interface.
The TreeSet provides basic operation such as add(), addAll(), first(), last(), contains(), remove() and size() methods.
TreeSet is not synchronized. If more than one thread wants to access it at the same time then it must be synchronized externally.

The following table demonstrates the constructors of TreeSet and corresponding methods.

Constructor	Meaning
TreeSet()	Constructs empty TreeSet Object.
TreeSet (Collection C)	Constructs a new set containing the elements of the given collection.
TreeSet (Comparator cmp)	Constructs empty set with sorted according to given comparator.
TreeSet (SortedSet sst)	Constructs new set that contains elements of the given sorted set.

The following program shows a simple use of TreeSet.

Example:

/**

From SimpleTreeSet.java

import java.util.TreeSet;

/**

* @author JavaHotSpot

public class SimpleTreeSet

{

public static void main(String args[])

{

TreeSet<String> tset = new TreeSet<String>();

tset.add("Book0");

tset.add("Book1");

tset.add("Book2");

tset.add("Book3");

tset.add("Book4");

tset.add("Book5");

tset.add("Book6");

System.out.println("The TreeSet elements are"+"\n"+tset);

}

Output:

The TreeSet elements are

[Book0, Book1, Book2, Book3, Book4, Book5, Book6]

The following program shows a use of TreeSet with Iterator Interface.

Example:

/**

From TreeSetwithIterator.java

import java.util.Iterator;

import java.util.TreeSet;

/**

* @author JavaHotSpot

public class TreeSetwithIterator

{

public static void main(String args[])

{

String ss;

TreeSet<String> tset = new TreeSet<String>();

tset.add("Book0");

tset.add("Book1");

tset.add("Book2");

tset.add("Book3");

tset.add("Book4");

tset.add("Book5");

tset.add("Book6");

System.out.println("The TreeSet elements are");

Iterator it = tset.iterator();

while(it.hasNext())

{

ss=(String)it.next();

System.out.println(ss);

}

Output:

The TreeSet elements are

Book0

Book1

Book2

Book3

Book4

Book5

Book6

Related Articles:

Collections in Java

Stack

Vector

HashTable

TreeMap

HashMap

HashSet

LinkedList

ArrayList

HashSet in Java

2011-10-20T06:02:00.000-07:00

The HashSet class extends AbstractSet and implements set interface.
A Set is collection of unique elements.
The HashSet class supports sets using a hash internally for storage by using mechanism called hashing.
The HashSet doesn’t allow duplicate element.
If you try to add a duplicate element in add method of set then it will return false.
In hashing, The informational content of a key is used to determine a unique value, called hash code.
The HashSet provides basic operation such as add(), contains(), remove() and size() method.
HashSet is not synchronized. If more than one thread wants to access it at the same time then it must be synchronized externally.

The following table demonstrates the constructors of HashSet and corresponding methods.

Constructor	Meaning
HashSet()	Constructs empty HashSet Object.
HashSet(Collection c)	Constructs a new set containing the elements of the given collection.
HashSet(int Capacity)	Constructs empty set with given initial capacity.
HashSet(int Capacity, float loadfactor)	Constructs empty set with given initial capacity and the given load factor.

The following program shows a simple use of HashSet.

Example:

/**

From SimpleHashSet.java

import java.util.HashSet;

/**

* @author JavaHotSpot

public class SimpleHashSet

{

public static void main(String args[])

{

HashSet<String> set = new HashSet<String>();

set.add("Book1");

set.add("Book2");

set.add("Book3");

set.add("Book4");

set.add("Book5");

set.add("Book6");

System.out.println("The HashSet elements are"+"\n"+set);

}

Output:

The HashSet elements are

[Book2, Book1, Book4, Book3, Book6, Book5]

Note:

In HashSet, you can’t guarantee the order in which element are strored internally, In fact, when you print the hashset you can see that all the elements are stored in randomly sometimes exactly reverse order.

The following program shows a simple use of HashSet with use of Iterator Interaface.

Example:

/**

From HashSerwithIterator.java

import java.util.HashSet;

import java.util.Iterator;

/**

* @author JavaHotSpot

public class HashSerwithIterator

{

public static void main(String args[])

{

String ss;

HashSet<String> set = new HashSet<String>();

set.add("Book0");

set.add("Book1");

set.add("Book2");

set.add("Book3");

set.add("Book4");

set.add("Book5");

set.add("Book6");

System.out.println("The HashSet elements are");

Iterator it = set.iterator();

while(it.hasNext())

{

ss=(String)it.next();

System.out.println(ss);

}

Output:

The HashSet elements are

Book0

Book2

Book1

Book4

Book3

Book6

Book5

Related Articles:

Collections in Java

Stack

Vector

HashTable

TreeMap

HashMap

TreeSet

LinkedList

ArrayList

LinkedList in Java

2011-10-20T05:58:00.000-07:00

LinkedList class extends AbstractSequentialList class and implements List Interface.
The LinkedList class provides methods to get, remove and insert an element at the beginning and end of the list.
The LinkedList can be used as stack, queue, or double-ended queue.
LinkedList is not synchronized and hence it must be synchronized externally when it is using multi - threaded program.
The LinkedList will return Iterator and ListIterator method.
To create LinkedList, you can use add, addFirst and addLast methods.
To get elements from the List, you can use get, getFirst and getLast methods.
To set element’s value, you can use set method.
To remove elements, you can use remove, removeFirst and removeLast methods.
To remove all the elements, you can use clear() method.

The following table demonstrates the constructors of LinkedList and corresponding methods.

Constructor	Meaning
LinkedList()	Constructs LinkedList Object.
LinkedList(Collection c)	Constructs a list containing the elements of the given collection.

The following program shows a simple use of LinkedList.

Example:

/**

From SimpleLinkedList.java

import java.util.LinkedList;

/**

* @author JavaHotSpot

public class SimpleLinkedList

{

public static void main(String args[])

{

LinkedList list = new LinkedList();

list.add("Book2");

list.add("Book3");

list.add("Book4");

list.add("Book5");

list.addFirst("Book1");

list.addLast("Book6");

System.out.println("The elements are"+"\n"+list);

list.removeFirst();

list.removeLast();

System.out.println("After removing First and Last element"+"\n"+"Now elements are"+"\n"+list);

list.set(0, "One");

list.set(1, "Two");

list.set(2, "Three");

list.set(3, "Four");

System.out.println("Setting the elements "+"\n"+"Now elements are"+"\n"+list);

}

Output:

The elements are

[Book1, Book2, Book3, Book4, Book5, Book6]

After removing First and Last element

Now elements are

[Book2, Book3, Book4, Book5]

Setting the elements

Now elements are

[One, Two, Three, Four]

Related Articles:

Collections in Java

Stack

Vector

HashTable

TreeMap

HashMap

TreeSet

HashSet

ArrayList

ArrayList in Java

2011-10-20T05:57:00.000-07:00

The ArrayList class in Java extends AbstractList and implements List Interface and also allows null.
The ArrayList class is a dynamic array that can grow and shrink at runtime.
ArrayList class is expandable or re – sizable array and used behalf of array because array is fixed size and cannot modify once we create it.
ArrayList allows duplicate elements.
ArrayList support both Iterator and ListIterator for iteration purpose.
ArrayList is not synchronized and hence it not thread safe.
ArrayList support single dimensional and heterogeneous data.

The following table demonstrates the constructors of the ArrayList class and its methods.

Constructor	Meaning
ArrayList	Constructs an Empty ArrayList Object.
ArrayList(Collection c)	Constructs a list containing the elements of the given collection.
ArrayList(int capacity)	Constructs an ArrayList object with the given initial capacity.

The following program shows a simple use of ArrayList. An array list is created, and then objects of type String are added to it. The list is then displayed.

Example:

/**

From SimpleArrayList.java

import java.util.ArrayList;

/**

* @author JavaHotSpot

public class SimpleArrayList

{

public static void main(String args[])

{

ArrayList alist = new ArrayList();

alist.add("Book1");

alist.add("Book2");

alist.add("Book3");

alist.add("Book4");

alist.add("Book5");

alist.add("Book6");

alist.add("Book7");

System.out.println("The size of the ArrayList="+alist.size());

System.out.println("The elements of ArrayList are..."+"\n"+alist);

alist.remove("Book7");

System.out.println("The size of the ArrayList after removing single item="+alist.size());

System.out.println("The elements of ArrayList are..."+"\n"+alist);

}

Output:

The size of the ArrayList=7

The elements of ArrayList are...

[Book1, Book2, Book3, Book4, Book5, Book6, Book7]

The size of the ArrayList after removing single item=6

The elements of ArrayList are...

[Book1, Book2, Book3, Book4, Book5, Book6]

The following program shows example of ArrayList with using Iterator Interface.

Example:

/**

From ArrayListwithIterator.java

import java.util.ArrayList;

import java.util.Iterator;

/**

* @author JavaHotSpot

public class ArrayListwithIterator

{

public static void main(String args[])

{

String ss;

ArrayList<String> alist = new ArrayList<String>();

alist.add("Book1");

alist.add("Book2");

alist.add("Book3");

alist.add("Book4");

alist.add("Book5");

alist.add("Book6");

alist.add("Book7");

System.out.println("Using Iterator Interface"+"\n"+"The elements of ArrayList are...");

Iterator it = alist.iterator();

while(it.hasNext())

{

ss = (String)it.next();

System.out.println(ss);

}

Output:

Using Iterator Interface

The elements of ArrayList are...

Book1

Book2

Book3

Book4

Book5

Book6

Book7

The following program shows example of ArrayList with using ListIterator Interface.

Example:

/**

From ArrayListwithListIterator.java

import java.util.ArrayList;

import java.util.ListIterator;

/**

* @author JavaHotSpot

public class ArrayListwithListIterator

{

public static void main(String args[])

{

String ss;

ArrayList<String> alist = new ArrayList<String>();

alist.add("Book1");

alist.add("Book2");

alist.add("Book3");

alist.add("Book4");

alist.add("Book5");

alist.add("Book6");

alist.add("Book7");

ListIterator it = alist.listIterator();

System.out.println("Using ListIterator Interface");

System.out.println("The elements of ArrayList are(Ascending Order)...");

while(it.hasNext())

{

ss = (String)it.next();

System.out.println(ss);

}

System.out.println("The elements of ArrayList are(Descending Order)...");

while(it.hasPrevious())

{

ss = (String)it.previous();

System.out.println(ss);

}

Output:

Using ListIterator Interface

The elements of ArrayList are(Ascending Order)...

Book1

Book2

Book3

Book4

Book5

Book6

Book7

The elements of ArrayList are(Descending Order)...

Book7

Book6

Book5

Book4

Book3

Book2

Book1

Related Articles:

Collections in Java

Stack

Vector

HashTable

TreeMap

HashMap

TreeSet

HashSet

LinkedList

Streams: Basic I/O in Java

2011-10-20T05:22:00.000-07:00

A stream represents a flow of data, or a channel of communication with a writer at one end and a reader at the other. To handle input and output we use java.io package. Let us discuss the classification of I/O streams.

Classification of I/O streams

Byte Streams
Character Streams
Buffered Streams
Terminal I/O or Console I/O
Data Streams
Object Streams

1. Byte Streams:

The byte streams are used to perform input and output of 8 – bit bytes. All byte stream classes are derived from InputStream and OutputStream.

InputStream and OutputStream are abstract classes that define the lowest-level interface for all byte streams. They contain methods for reading or writing an unstructured sequence of bytes.

Java implements subclasses of these for activities such as reading from and writing to files. Because all byte streams inherit the structure of InputStream or OutputStream, the various kinds of byte streams can be used interchangeably.

All the methods of this class will throw an IO Exception. Some of the byte streams are

FileInputStream

FileOutputStream

2. Character Streams:

The Character Streams are used for reading or writing a sequence of character data, with support for Unicode. All other character streams in Java are built on top of Reader and Writer. Reader and Writer are very much like InputStream and OutputStream, except that they deal with characters instead of bytes. As true character streams, these classes correctly handle Unicode characters. InputStreamReader and OutputStreamWriter are special classes that use a character-encoding scheme to translate between character and byte streams.

All the methods of this class will throw an IO Exception. Some of the byte streams are

InputStreamReader

FileReader

FileWriter

OutputStreamWriter

3. Buffered Streams:

A buffer can increase efficiency by reducing the number of physical read or write operations that correspond to read( ) or write( ) method calls.

Java platform implements buffered I/O streams. Buffered input streams read data from a memory area known as a buffer; the native input API is called only when the buffer is empty. Similarly, buffered output streams write data to a buffer, and the native output API is called only when the buffer is full.

Some of the buffered streams are

BufferedInputStream

BufferedOutputStream

BufferedReader

BufferedWriter

4. Terminal I/O or Console I/O

The terminal or console refers to command line environment or command prompt. The most commonly used standard output is System.out and System.err is derived from OutputStream object and standard input is System.in is derived from InputStream object. The following example shows the correspondence.

InputStream stdin = System.in;

OutputStream stdout = System.out;

OutputStream stderr = System.err;

System.out

System.out is the first instance of the OutputStream class most programmers encounter. Specifically, System.out is the static out field of the java.lang.System class. It's an instance of java.io.PrintStream, a subclass of java.io.OutputStream.

System.out corresponds to stdout in C. Normally; output sent to System.out appears on the console. As a general rule, the console converts the numeric byte data System.out sends to it into ASCII. Thus, the following lines write the string "Hello World!" on the console:

byte[] hello = {72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 10,13};

System.out.write(hello);

Sytem.err

C programmers are familiar with stderr, which is commonly used for error messages. stderr is a separate file pointer from stdout, but often means the same thing. Generally, stderr and stdout both send data to the console, whatever that is. However, stdout and stderr can be redirected to different places. For instance, output can be redirected to a file while error messages still appear on the console.

System.err is Java's version of stderr. Like System.out, System.err is an instance of java.io.PrintStream, a subclass of java.io.OutputStream. System.err is most commonly used inside the catch clause of a TRy/catch block, as shown here:

try

  // Do something that may throw an exception.

catch (Exception ex)

  System.err.println(ex);

System.in

System.in is the input stream connected to the console, much as System.out is the output stream connected to the console. In C terms, System.in is stdin and can be redirected from a shell in the same fashion. System.in is the static in field of the java.lang.System class. It's an instance of java.io.InputStream.

We can read a single byte at a time from standard input with the InputStream's read( ) method. If you look closely at the API, you'll see that the read( ) method of the base InputStream class is an abstract method. What lies behind System.in is a particular implementation of InputStream that provides the real implementation of the read( ) method:

try

        int val = System.in.read(  );

catch ( IOException e )

...

The following example reads each byte from an input stream and prints its value:

    int val;

try

           while( (val=System.in.read(  )) != -1 )

            System.out.println((byte)val);

catch ( IOException e )

{ ... }

5. Data Streams

Data streams support binary I/O of primitive data type values such as boolean, char, byte, short, int, long, float, and double as well as String values. All data streams are derived from either the DataInput interface or the DataOutput interface. The Data Streams are shown below.

DataInputStream

DataOutputStream

DataInputStream and DataOutputStream are filter streams that let you read or write strings and primitive data types comprised of more than a single byte. DataInputStream and DataOutputStream implement the DataInput and DataOutput interfaces, respectively. These interfaces define methods for reading or writing strings and all of the Java primitive types, including numbers and Boolean values. DataOutputStream encodes these values in a machine-independent manner and then writes them to its underlying byte stream. DataInputStream does the converse.

6. Object Streams

Object streams support I/O of objects similarly, just as data streams support I/O of primitive data types.

The object stream classes are ObjectInputStream and ObjectOutputStream. These classes implement ObjectInput and ObjectOutput, which are subinterfaces of DataInput and DataOutput. ObjectInputStream and ObjectOutputStream, are used to serialize primitive types and objects.

ObjectInputStream

ObjectOutputStream

FileInputStream in Java

2011-10-20T05:21:00.000-07:00

The FileInputStream class is specially designed to work with byte – oriented input from the files. The FileInputStream is derived from abstract class InputStream. FileInputStream class can throw FileNotFoundException when its unable find input file.

Let us look a simple example of FileInputStream to read byte streams from the file as illustrated below.

Example:

//From FileInputStreamExample.java

import java.io.FileInputStream;

/**

* @author JavaHotSpot

public class fileInputStreamExample

{

public static void main(String args[])

{

try

{

int size;

FileInputStream fi = new FileInputStream("C:\\file.txt");

size=fi.available();

System.out.println("The available bytes ="+size);

byte[] bt=new byte[1000];

fi.read(bt);

System.out.println("File Content is =\n"+ new String(bt,0,size));

fi.close();

}

catch(Exception ex)

{

System.err.println(ex);

}

Output:

The available bytes =177

File Content is =

A stream represents a flow of data,

or a channel of communication with a

writer at one end and a reader at the other.

To handle input and output we use java.io package.

Related Articles:

FileOutputStream

InputStreamReader

FileReader

FileWriter

BufferedInputStream

BufferedOutputStream

BufferedReader

BufferedWriter

DataInputStream

DataOutputStream

ObjectInputStream

ObjectOutputStream

FileOutputStream in Java

2011-10-20T05:20:00.000-07:00

The FileOutputStream class is used to write data, byte by byte to a file. The FileOutputStream is derived from abstract class OutputStream. It can throw FileNotFoundException or SecurityException. We need to remember that creation of FileOutputStream is not dependent on the file that already exists. In fact FileOutStream will create the file before opening it for output. If we attempt to open a read only file the throw an IOException. The return type of FileOutputStream is void.

Example:

//From fileOutputStreamExample.java

import java.io.FileInputStream;

import java.io.FileOutputStream;

/**

* @author JavaHotSpot

public class fileOutputStreamExample

{

public static void main(String args[])

{

try

{

String s1= "This is example of fileoutputstream class";

byte[] data=s1.getBytes(); // Converts string into bytes

byte[] indata=new byte[1000];

int n=data.length;

int size;

System.out.println("Writing data, byte by byte...");

FileOutputStream fo=new FileOutputStream("C:\\file1.txt");

for(int i=0;i<n;i++)

{

fo.write(data[i]);

}

System.out.println("Writing is Done...!");

fo.close();

System.out.println("Reading....");

FileInputStream fi=new FileInputStream("C:\\file1.txt");

size=fi.available();

fi.read(indata);

System.out.println("File Content is =\n"+new String(indata,0,size));

fi.close();

}

catch(Exception ex)

{

System.err.println(ex);

}

Output:

Writing data, byte by byte...

Writing is Done...!

Reading....

File Content is =

This is example of fileoutputstream class

InputStreamReader in Java

2011-10-20T05:19:00.000-07:00

InputStreamReader is used to read keys from the keyboard, initially we construct an InputStreamReader stream from System.in and then use the InputStreamReader class’s read method to read what the user has typed. InputStreamReader class is derived from the Reader class.

The following example just read keys from the keyboard and displays them.

Example:

/**

From InputStreamReaders.java

import java.io.InputStreamReader;

/**

* @author JavaHotSpot

public class InputStreamReaders

{

public static void main(String args[])

{

try

{

int ch;

InputStreamReader ins=new InputStreamReader(System.in);

while((ch=ins.read())!=-1)

{

System.out.print((char)ch);

}

catch(Exception ex)

{

System.err.println(ex);

}

Output:

Hello from java

Hello from java

Related Articles:

FileInputStream

FileOutputStream

FileReader

FileWriter

BufferedInputStream

BufferedOutputStream

BufferedReader

BufferedWriter

DataInputStream

DataOutputStream

ObjectInputStream

ObjectOutputStream

FileReader in Java

2011-10-20T05:18:00.000-07:00

The FileReader class is used to create a character based stream that reads from file. The FileReader class is inherited from InputStreamReader and this will throw a FileNotFoundException.

Let us look at the following example that will open the text file and reads the content and display it.

Example:

/**

From FileReaderExample.java

import java.io.FileReader;

/**

* @author JavaHotSpot

public class FileReaderExample

{

public static void main(String args[])

{

try

{

char ch[]=new char[1000];

int size;

FileReader fr= new FileReader("C:\\file1.txt");

size=fr.read(ch);

System.out.println("File Content is \n"+new String(ch,0,size));

fr.close();

}

catch(Exception ex)

{

System.err.println(ex);

}

Output:

File Content is

This is example of fileoutputstream class

Related Articles:

FileInputStream

FileOutputStream

InputStreamReader

FileWriter

BufferedInputStream

BufferedOutputStream

BufferedReader

BufferedWriter

DataInputStream

DataOutputStream

ObjectInputStream

ObjectOutputStream

FileWriter in Java

2011-10-20T05:16:00.000-07:00

The FileWriter class is used to write a character based stream to the file. The FileWriter is derived from the OutputStream class and this will throw IOException.

The FileWriter constructor is not dependent on the file already existing. It will create the file before opening it for output when an object is created. If we try to open a read – only file, an IOException will be thrown.

Consider the following example that will write data from a character buffer to file, character by character by using FileWriter.

Example:

/**

From FileWriterExample.java

import java.io.FileWriter;

/**

* @author JavaHotSpot

public class FileWriterExample

{

public static void main(String args[])

{

try

{

char ch[]={'T','h','i','s','i','s','e','x','a','m','p','l','e',

'o','f','F','i','l','e','R','e','d','e','r'};

FileWriter fw = new FileWriter("C:\\file1.txt");

for(int i=0;i<ch.length;i++)

{

fw.write(ch[i]);

}

fw.close();

System.out.println("Done...!");

}

catch(Exception ex)

{

System.err.println(ex);

}

Output:

Done…!

Related Articles:

FileInputStream

FileOutputStream

InputStreamReader

FileReader

BufferedInputStream

BufferedOutputStream

BufferedReader

BufferedWriter

DataInputStream

DataOutputStream

ObjectInputStream

ObjectOutputStream

BufferedInputStream in Java

2011-10-20T05:15:00.001-07:00

BufferedInputStream uses mark and reset methods to move backward in the buffered input stream. The mark( ) method sets the return point in the stream. It takes an integer value that specifies the number of bytes that can be read before the stream gives up and forgets about the mark. The reset( ) method returns the stream to the marked point; any data read after the call to mark( ) is read again.

The bufferedInputStream is derived from InputStream class.

Example:

/**

From BufferedInpuStreams.java

import java.io.BufferedInputStream;

import java.io.FileInputStream;

/**

* @author JavaHotSpot

public class BufferedInpuStreams

{

public static void main(String args[])

{

try

{

int i;

byte b[]=new byte[1000];

FileInputStream fins = new FileInputStream("C:\\file.txt");

BufferedInputStream buff = new BufferedInputStream(fins);

i=buff.read(b);

System.out.println("File Content is \n"+new String(b,0,i));

}

catch(Exception ex)

{

System.err.println(ex);

}

Output:

File Content is

A stream represents a flow of data,

or a channel of communication with a

writer at one end and a reader at the other.

To handle input and output we use java.io package.

Related Articles:

FileInputStream

FileOutputStream

InputStreamReader

FileReader

FileWriter

BufferedOutputStream

BufferedReader

BufferedWriter

DataInputStream

DataOutputStream

ObjectInputStream

ObjectOutputStream

BufferedOutputStream in Java

2011-10-20T05:14:00.001-07:00

The BufferedOutputStream is the output counterpart of BufferedInputStream class. In BufferedOutputStream class output is buffered so no need to write data to disk every time a byte is written. Here we use flush() method to force write operation.

Example:

/**

From BufferedOutputStreams.java

import java.io.BufferedOutputStream;

import java.io.FileOutputStream;

/**

* @author JavaHotSpot

public class BufferedOutputStreams

{

public static void main(String args[])

{

try

{

String s1="This is exampleof BufferedOutputStream Class";

byte data[]=s1.getBytes();

FileOutputStream fo = new FileOutputStream("C:\\file1.txt");

BufferedOutputStream buff = new BufferedOutputStream(fo);

for(int i=0;i<data.length;i++)

{

buff.write(data[i]);

}

buff.flush();

buff.close();

System.out.println("Done...!");

}

catch(Exception ex)

{

System.err.println(ex);

}

Output:

Done…!

Related Articles:

FileInputStream

FileOutputStream

InputStreamReader

FileReader

FileWriter

BufferedInputStream

BufferedReader

BufferedWriter

DataInputStream

DataOutputStream

ObjectInputStream

ObjectOutputStream

BufferedReader in Java

2011-10-20T05:13:00.001-07:00

The BufferedReader class provides a buffered character reader class. The BufferedReader class provides readLine() method instead of read() method. BufferedReader has two constructors. In the first form a buffered character stream uses a default buffer size. In the second, the size of the buffer is passes into the constructor as show below.

Constructor	Meaning
BufferedReader(Reader rd);	Construct a buffering character input stream
BufferedReader(Reader rd, int size)	Construct a buffering character input stream along with given buffered size

Consider the following example which reads the file file.txt line by line with readLine() method and prints the content of that file using BufferedReader class.

Example:

/**

From bufferedReader.java

import java.io.BufferedReader;

import java.io.FileReader;

/**

* @author JavaHotSpot

public class bufferedReader

{

public static void main(String args[])

{

try

{

FileReader fr = new FileReader("C:\\file.txt");

BufferedReader buff = new BufferedReader(fr);

String ss;

System.out.println("File Content is \n");

while((ss=buff.readLine())!=null)

{

System.out.println(ss);

}

catch(Exception ex)

{

System.err.println(ex);

}

Output:

File Content is

A stream represents a flow of data,

or a channel of communication with a

writer at one end and a reader at the other.

To handle input and output we use java.io package.

Related Articles:

BufferedWriter in Java

2011-10-20T05:12:00.001-07:00

The BufferedWriter class provides a buffered character writer class. The BufferedReader class has two constructors. In the first form a buffered character stream uses a default buffer size. In the second, the size of the buffer is passes into the constructor as show below.

Constructor	Meaning
BufferedWriter(Writer wr);	Construct a buffering character output stream
BufferedWriter(Writer wr, int size)	Construct a buffering character output stream along with given buffered size

Consider the following example which opens file1.txt and writes buffering string into the file.

Example:

/**

From bufferedWriter.java

import java.io.BufferedWriter;

import java.io.FileWriter;

/**

* @author JavaHotSpot

public class bufferedWriter

{

public static void main(String args[])

{

try

{

FileWriter fw = new FileWriter("C:\\file1.txt");

BufferedWriter buff = new BufferedWriter(fw);

buff.write("This is example of BufferedWriter");

buff.flush();

System.out.println("Done...!");

}

catch(Exception ex)

{

System.err.println(ex);

}

Output:

Done…!

DataInputStream in Java

2011-10-20T05:11:00.000-07:00

DataInputStream is filter streams that is used to read strings and primitive data types comprised of more than a single byte. DataInputStream implement the DataInput interface. This interface defines methods for reading strings and all of the Java primitive types, including numbers and Boolean values.

We can construct a DataInputStream from an InputStream and then use a method such as readLine() to read a String data type:

    DataInputStream dis = new DataInputStream( System.in );

    String ss = dis.readLine();

Consider the following example which reads primitive data types such as int, double from the text file file2.txt and prints the result.

Example:

/**

From dataInputStream.java

import java.io.DataInputStream;

import java.io.FileInputStream;

/**

* @author JavaHotSpot

public class dataInputStream

{

public static void main(String args[])

{

try

{

int roll;

char name;

double percentage;

FileInputStream fs = new FileInputStream("C:\\file2.txt");

DataInputStream dins = new DataInputStream(fs);

while(fs.available()>0)

{

roll=dins.readInt();

percentage=dins.readDouble();

System.out.println(roll+" "+percentage);

}

catch(Exception ex)

{

System.err.println(ex);

}

Output:

1 98.34

2 97.32

3 89.65

4 87.34

5 78.12

DataOutputStream in Java

2011-10-20T05:10:00.000-07:00

DataOutputStream is filter streams that is used to write strings and primitive data types comprised of more than a single byte. DataOutputStream implement the DataOutput interface. This interface defines methods for writing strings and all of the Java primitive types, including numbers and Boolean values.

We can construct a DataOutputStream from an OutputStream and then use a method such as writeInt(), writeDouble, writeFloat() etc to write primitive data types as follows:

    DataOutputStream dins = new DataOutputStream(FileOutputStream file);

    dins.writeInt();

    dins.writeFloat();

    dins.writeDouble();

Consider the following example which opens a text file and writes primitive data types such as int, double to a text file file2.txt.

Example:

/**

From dataOutputStream.java

import java.io.DataOutputStream;

import java.io.FileOutputStream;

/**

* @author JavaHotSpot

public class dataOutputStream

{

public static void main(String args[])

{

try

{

int[] roll={1,2,3,4,5};

double[] percentage={98.34,97.32,89.65,87.34,78.12};

FileOutputStream fs = new FileOutputStream("C:\\file2.txt");

DataOutputStream ds = new DataOutputStream(fs);

for(int i=0;i<roll.length;i++)

{

ds.writeInt(roll[i]);

ds.writeDouble(percentage[i]);

}

System.out.append("Done...!");

}

catch(Exception ex)

{

System.err.println(ex);

}

Output:

Done…!

Related Articles:

FileInputStream

FileOutputStream

InputStreamReader

FileReader

FileWriter

BufferedInputStream

BufferedOutputStream

BufferedReader

BufferedWriter

DataInputStream

ObjectInputStream

ObjectOutputStream

ObjectInputStream in Java

2011-10-20T05:09:00.000-07:00

The Object stream is a mixture of primitive data type and object values. The ObjectInputStream class is a lot like DataInputStream class, except that it includes the powerful readObject() method. The ObjectInputStream class implements ObjectInput class which is sub interface of DataInput class.

Example:

/**

From objectInputStream.java

import java.io.FileInputStream;

import java.io.ObjectInputStream;

import java.util.Hashtable;

/**

* @author JavaHotSpot

public class objectInputStream

{

public static void main(String args[])

{

try

{

FileInputStream fs = new FileInputStream("C:\\file2.txt");

ObjectInputStream obj = new ObjectInputStream(fs);

Hashtable ht = (Hashtable)obj.readObject();

System.out.append(ht.toString());

}

catch(Exception ex)

{

System.err.println(ex);

}

Output:

{Roll=12, Percentage=98.56, Name=ABC}

Related Articles:

FileInputStream

FileOutputStream

InputStreamReader

FileReader

FileWriter

BufferedInputStream

BufferedOutputStream

BufferedReader

BufferedWriter

DataInputStream

DataOutputStream

ObjectOutputStream

ObjectOutputStream in Java

2011-10-20T05:08:00.000-07:00

The Object stream is a mixture of primitive data type and object values. The ObjectOutputStream class is a lot like DataOutputStream class, except that it includes the powerful writeObject() method. The ObjectInputStream class implements ObjectOutput class which is sub interface of DataOutput class.

Example:

/**

From objectOutputStream.java

import java.io.FileOutputStream;

import java.io.ObjectOutputStream;

import java.util.Hashtable;

/**

* @author JavaHotSpot

public class objectOutputStream

{

public static void main(String args[])

{

try

{

Hashtable ht = new Hashtable();

ht.put("Name","ABC");

ht.put("Roll", new Integer(12));

ht.put("Percentage", new Double(98.56));

FileOutputStream fs = new FileOutputStream("C:\\file2.txt");

ObjectOutputStream obj = new ObjectOutputStream(fs);

obj.writeObject(ht);

obj.close();

System.out.append("Done...!");

}

catch(Exception ex)

{

System.err.println(ex);

}

Output:

File Class in Java

2011-10-20T05:06:00.001-07:00

The java.io.File class encapsulates access to information about a file or directory. It can be used to get attribute information about a file, list the entries in a directory, and perform basic filesystem operations, such as removing a file or making a directory. While the File object handles these "meta" operations, it doesn't provide the API for reading and writing file data; there are specialized streams for that purpose.

The following table summarizes the methods provided by the File class.


Method	Return type	Meaning
canRead( )	Boolean	Is the file (or directory) readable?
canWrite( )	Boolean	Is the file (or directory) writable?
createNewFile( )	Boolean	Creates a new file.
createTempFile (String *pfx, String* *sfx*)	File	Static method to create a new file, with the specified prefix and suffix, in the default temp file directory.
delete( )	Boolean	Deletes the file (or directory).
deleteOnExit( )	Void	When it exits, Java runtime system deletes the file.
exists( )	boolean	Does the file (or directory) exist?


getName( )	String	Returns the name of the file (or directory).
getParent( )	String	Returns the name of the parent directory of the file (or directory).
getPath( )	String	Returns the path of the file (or directory).

isDirectory( )	boolean	Is the item a directory?
isFile( )	boolean	Is the item a file?
isHidden( )	boolean	Is the item hidden? (System-dependent.)
lastModified( )	long	Returns the last modification time of the file (or directory).
length( )	long	Returns the length of the file.
list( )	String []	Returns a list of files in the directory.
listFiles( )	File[]	Returns the contents of the directory as an array of File objects.
listRoots( )	File[]	Returns array of root filesystems if any (e.g., C:/, D:/).
mkdir( )	boolean	Creates the directory.
mkdirs( )	boolean	Creates all directories in the path.
renameTo(File *dest*)	boolean	Renames the file (or directory).
setLastModified( )	boolean	Sets the last-modified time of the file (or directory).
setReadOnly( )	boolean	Sets the file to read-only status.

Example:

import java.io.File;

/**

* @author JavaHotSpot

public class FileClass

{

public static void main(String args[])

{

File f;

f=new File("C:\\p1.txt");

if(f.isFile())

{

System.out.println("File: "+f.getName()+ " is a File");

}

else

{

System.out.println("File: "+f.getName()+ " is a Directory");

}

System.out.println("The Size of the File: "+f.length());

System.out.println("The Path of the File: "+f.getPath());

System.out.println("The Parent of the File: "+f.getParent());

System.out.println("The File was last modified: "+f.lastModified());

if(f.exists())

{

System.out.println("The File is exists");

}

else

{

System.out.println("The File does not exists");

}

if(f.canRead())

{

System.out.println("The File can be read");

}

else

{

System.out.println("The File can not be read");

}

if(f.canWrite())

{

System.out.println("The File can be write");

}

else

{

System.out.println("The File can not be write");

}

if(f.canExecute())

{

System.out.println("The File can be executable");

}

else

{

System.out.println("The File can not be executable");

}

Output:

File: p1.txt is a File

The Size of the File: 41

The Path of the File: C:\p1.txt

The Parent of the File: C:\

The File was last modified: 1306337871062

The File is exists

The File can be read

The File can be write

The File can be executable

Related Articles:

StringBuffer

StringTokenizer

Split

Scanner

String Class

Wrapper Class