TreeSet class implements the Set interface and stores the data in tree structure. The values are stored in sorted and ascending oreder. It is quite fast in retrieval of elements. This makes TreeSet is most prefered choice for storing the large amount of data in sorted order and want to retrieve it fast. This supports the four variant of constructors:

• TreeSet( )
• TreeSet(Collection col)
• TreeSet(Comparator comparator)
• TreeSet(SortedSet set)

TreeSet Methods

• void add(Object o) –> This method adds the new element to set if it is not already present
• boolean addAll(Collection c) –> Takes collection and adds all the elements in the collection to this set
• void clear() –> Clears or removes all the elements from the set
• Object clone() –> Returns a shallow copy of this TreeSet instance
• Comparator comparator() –> This method returns the comparator instance used for this TreeSet
• boolean contains(Object o) –> This method returns true if this set contains the specified element
• Object first() –> This method returns the first element in the sorted set
• SortedSet headSet(Object toElement) –> This method returns the lower elements subset by checking the matching to element value
• boolean isEmpty() –> This method returns true if this set contains no elements and empty.
• Iterator iterator() –> Returns an iterator over the elements in this set.
• Object last() –> This method returns the last element in the sorted set
• boolean remove(Object o) –> This method removes the given element from this set if it is found
• int size() –> This method returns the number of elements in this set
• SortedSet subSet(Object fromElement, Object toElement) –> This method returns the subset by checking the matching from and to element values
• SortedSet tailSet(Object fromElement) –> This method returns the subset by checking the matching from element value

TreeSet Example

[code lang=”java”]
package javabeat.net.core;

import java.util.TreeSet;

public class TreeSetExample {
public static void main(String args[]){
TreeSet<String> treeSet = new TreeSet<String>();
treeSet.add("Element 1");
treeSet.add("Element 3");
treeSet.add("Element 5");
treeSet.add("Element 2");
treeSet.add("Element 4");
System.out.println("Checking ‘Element 2’ : "+treeSet.contains("Element 2"));
System.out.println("Printing TreeSet : "+treeSet);
System.out.println("Removing ‘Element 2’ : "+treeSet.remove("Element 2"));
System.out.println("Checking ‘Element 2’ : "+treeSet.contains("Element 2"));
System.out.println("Printing TreeSet : "+treeSet);
}
}
[/code]

Output for the above example will be:

[code]
Checking ‘Element 2’ : true
Printing TreeSet : [Element 1, Element 2, Element 3, Element 4, Element 5]
Removing ‘Element 2’ : true
Checking ‘Element 2’ : false
Printing TreeSet : [Element 1, Element 3, Element 4, Element 5]
[/code]

This tutorial shows how to use java.util.Comparator and java.lang.Comparable to sort a Java object based on its property value. Here I have created Employee object with Name and Age properties, we will be able to sort the list of objects based on the values in the property’ Lets look at the example.

Employee.java

[code lang=”java”]
package javabeat.net.core;

import java.util.Comparator;

class Employee implements Comparator<Employee>, Comparable<Employee>{
private String empName;
private int empAge;
Employee(){
}

Employee(String name, int age){
empName = name;
empAge = age;
}

public String getEmpName(){
return empName;
}

public int getEmpAge(){
return empAge;
}

// Overriding the compareTo method
public int compareTo(Employee e){
return (this.empName).compareTo(e.empName);
}

// Overriding the compare method to sort the age
public int compare(Employee e, Employee e1){
return e.empAge – e1.empAge;
}
}
[/code]

ComparatorExample.java

[code lang=”java”]
package javabeat.net.core;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ComparatorExample{

public static void main(String args[]){
// Takes a list of Employee objects
List<Employee> empList = new ArrayList<Employee>();

empList.add(new Employee("Zaheer",30));
empList.add(new Employee("Ashwin",25));
empList.add(new Employee("Karnan",31));

// Sorts the array list
Collections.sort(empList);

//displays the sorted list of names
for(Employee a: empList)
System.out.print(a.getEmpName() + ", ");

// Sorts the array list using comparator
Collections.sort(empList, new Employee());
System.out.println(" ");
//displays the sorted list of ages
for(Employee a: empList)
System.out.print(a.getEmpName() +" : "+
a.getEmpAge() + ", ");
}
}
[/code]

Output for the above example will be:

[code]
Ashwin, Karnan, Zaheer,
Ashwin : 25, Zaheer : 30, Karnan : 31,
[/code]

HashTable class was originally added as part of java.utill package and extended the Dictionary class. From Java 2, it is re-engineered to implement the Map interface and made as part of the collections framework. HashTable is similar to HashMap except that HashTable is synchronized. It is very much similar to HashMap, stores the key-value pairs. HashTable supports four variations of constructors.

• Hashtable( )
• Hashtable(int size)
• Hashtable(int size, float fillRatio)
• Hashtable(Map m)

HashTable Methods

• void clear() –> Clears all entries in this map.
• Object clone() –> Returns a clone of the map object
• boolean containsKey(Object key) –> Will return true if the map contains the key
• boolean containsValue(Object value) –> Will return true if this map maps one or more keys to the specified value.
• Enumeration elements( ) –> Returns enumeration of values
• Object get(Object key) –> Will return the value to which the passed key is mapped in this identity hash map, or null if the map contains no mapping for the passed key.
• boolean isEmpty() –> Will return true if this map contains no entries
• Enumeration keys() –> Will return the set of keys in the hashtable object
• Object put(Object key, Object value) –> Will link the key and value passed
• void rehash( ) –>Increaes the size of the table
• Object remove(Object key) –> Will remove the passed key-value from the map
• int size() –> Will return the size of the map
• String toString( ) –>Returns the string equivalent of HashTable

HashTable Example

[code lang=”java”]
package javabeat.net.core;

import java.util.Enumeration;
import java.util.Hashtable;

public class HashTableExample {

public static void main(String args[]) {
// Create a hash map with default constructor
Hashtable<String,String> testHT = new Hashtable<String, String>();
Enumeration values;
String str;
testHT.put("1", "Entry 1");
testHT.put("2", "Entry 2");
testHT.put("3", "Entry 3");

// Show all balances in hash table.
values = testHT.keys();
while (values.hasMoreElements()) {
str = (String) values.nextElement();
System.out.println(str + ": " + testHT.get(str));
}
}
}

[/code]

Output for the abovel example will be:

[code]
3: Entry 3
2: Entry 2
1: Entry 1
[/code]

HashMap uses the hash table to implement the Map interface. Map is key-value pair where key is the reference and value is the actual data. HashMap is very extensively used in the projects when key-value type data is stored. This doesn’t ensure the order of insertion. This class extends the AbstractMap and implements the Map interface.

HaspMap supports the four types of constructors:

• HashMap( )
• HashMap(Map m)
• HashMap(int capacity)
• HashMap(int capacity, float fillRatio)

HashMap Methods

• void clear() –> Clears all entries in this map.
• Object clone() –> Returns a clone of the map object
• boolean containsKey(Object key) –> Will return true if the map contains the key
• boolean containsValue(Object value) –> Will return true if this map maps one or more keys to the specified value.
• Set entrySet() –> Will return true if a collection of the mappings found this map.
• Object get(Object key) –> Will return the value to which the passed key is mapped in this identity hash map, or null if the map contains no mapping for the passed key.
• boolean isEmpty() –> Will return true if this map contains no entries
• Set keySet() –> Will return the set of keys in the map object
• Object put(Object key, Object value) –> Will link the key and value passed
• putAll(Map m) –> Copy all of the amppings to the another map
• Object remove(Object key) –> Will remove the passed key-value from the map
• int size() –> Will return the size of the map
• Collection values() –> Will retrun the collection view of the map values. It may be a list of values

HashMap Example

[code lang=”java”]
package javabeat.net.core;

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

public class HashMapExample {
public static void main(String args[]) {

// Create a default hash map
HashMap<String,String> hashmap = new HashMap<String,String>();
// Add elements to the map
hashmap.put("1", "Entry 1");
hashmap.put("2", "Entry 2");
hashmap.put("3", "Entry 3");

// Get a set of the entries
Set<Entry<String, String>> set = hashmap.entrySet();

// Get an iterator
Iterator<Entry<String, String>> i = set.iterator();

// Display elements
while (i.hasNext()) {
Map.Entry<String,String> mapEntry = i.next();
System.out.print(mapEntry.getKey() + ": ");
System.out.println(mapEntry.getValue());
}
}
}

[/code]

The output for the above example will be:

[code]
3: Entry 3
2: Entry 2
1: Entry 1
[/code]

HastSet is one of the classes available with collections package and it extends the AbstractSet and implements the Set interface. This uses the hash table for storing the values. Hash table internally using hashing mechanism to store the values. In the hashing technique, information is uniquely identified using the hash code. HashSet supports four constructors. This allows the null values.

• Default Constructor – HashSet()
• One with initial set of collections as parameter – HashSet(Collection c)
• Creating HashSet with initial capacity – HashSet(int capacity)
• Initial capacity and the fill ration to grow the capacity after certain elements inserted – HashSet(int capacity, float fillRatio)

HashSet Methods

The following are the list of methods defined in the HashSet class. This apart from the inherited methods from the parent classes.

• boolean add(Object obj) –> Adds the element if it is not aleady there
• void clear() –> Clears all the element from the set
• Object clone() –> Creates a shallow copy of this HashSet instance
• boolean contains(Object obj) –> Checks and returns true if this set contains the specified element
• boolean isEmpty() –> Returns true if this set is empty
• Iterator iterator() –> Returns an iterator over the elements in this set
• boolean remove(Object obj) –> Removes the specified element from this set if it is present
• int size() –> Returns the number of elements in this set (its cardinality)

HashSet Example

[code lang=”java”]
package javabeat.net.core;

import java.util.HashSet;

public class HashSetDemo {
public static void main(String args[]) {
// create a hash set with default constructor
HashSet<String> hashSet = new HashSet<String>();
// add elements to the hash set
hashSet.add("Element 1");
hashSet.add("Element 2");
hashSet.add("Element 3");
System.out.println(hashSet);
}
}

[/code]

Output of the above example will be:

[code]
[Element 3, Element 2, Element 1]
[/code]