Legacy Class in Java

In the past decade, the Collection framework didn't include in Java. In the early version of Java, we have several classes and interfaces which allow us to store objects. After adding the Collection framework in JSE 1.2, for supporting the collections framework, these classes were re-engineered. So, classes and interfaces that formed the collections framework in the older version of Java are known as Legacy classes. For supporting generic in JDK5, these classes were re-engineered.

All the legacy classes are synchronized. The java.util package defines the following legacy classes:

HashTable
Stack
Dictionary
Properties
Vector

Vector Class

Vector is a special type of ArrayList that defines a dynamic array. ArrayList is not synchronized while vector is synchronized. The vector class has several legacy methods that are not present in the collection framework. Vector implements Iterable after the release of JDK 5 that defines the vector is fully compatible with collections, and vector elements can be iterated by the for-each loop.

Vector class provides the following four constructors:

1) Vector()

It is used when we want to create a default vector having the initial size of 10.

2) Vector(int size)

It is used to create a vector of specified capacity. It accepts size as a parameter to specify the initial capacity.

3) Vector(int size, int incr)

It is used to create a vector of specified capacity. It accepts two parameters size and increment parameters to specify the initial capacity and the number of elements to allocate each time when a vector is resized for the addition of objects.

4) Vector(Collection c)

It is used to create a vector with the same elements which are present in the collection. It accepts the collection as a parameter.

VectorExample.java

import java.util.*;
public class VectorExample
{
  public static void main(String[] args)
   {
      Vector<String> vec = new Vector<String>();
       vec.add("Emma");
       vec.add("Adele");
	   vec.add("Aria");
       vec.add("Aidan");
       vec.add("Adriana");
       vec.add("Ally");
       Enumeration<String> data = vec.elements();
       while(data.hasMoreElements())
       {
           System.out.println(data.nextElement());
       }
   }
}

Output:

Hashtable Class

The Hashtable class is similar to HashMap. It also contains the data into key/value pairs. It doesn't allow to enter any null key and value because it is synchronized. Just like Vector, Hashtable also has the following four constructors.

1) Hashtable()

It is used when we need to create a default HashTable having size 11.

2) Hashtable(int size)

It is used to create a HashTable of the specified size. It accepts size as a parameter to specify the initial size of it.

3) Hashtable(int size, float fillratio)

It creates the Hashtable of the specified size and fillratio. It accepts two parameters, size (of type int) and fillratio (of type float). The fillratio must be between 0.0 and 1.0. The fillratio parameter determines how full the hash table can be before it is resized upward. It means when we enter more elements than its capacity or size than the Hashtable is expended by multiplying its size with the fullratio.

4) Hashtable(Map< ? extends K, ? extends V> m)

It is used to create a Hashtable. The Hashtable is initialized with the elements present in m. The capacity of the Hashtable is the twice the number elements present in m.

HashtableExample.java

import java.util.*;
class HashtableExample
{
  public static void main(String args[])
  {
    Hashtable<Integer,String> student = new Hashtable<Integer, String>();
    student.put(new Integer(101), "Emma");
    student.put(new Integer(102), "Adele");
    student.put(new Integer(103), "Aria");
    student.put(new Integer(104), "Ally");
    Set dataset = student.entrySet();
    Iterator iterate = dataset.iterator();
    while(iterate.hasNext())
    {
      Map.Entry map=(Map.Entry)iterate.next();
      System.out.println(map.getKey()+" "+map.getValue());
    }
  }
}

Output:

Properties Class

Properties class extends Hashtable class to maintain the list of values. The list has both the key and the value of type string. The Property class has the following two constructors:

1) Properties()

It is used to create a Properties object without having default values.

2) Properties(Properties propdefault)

It is used to create the Properties object using the specified parameter of properties type for its default value.

The main difference between the Hashtable and Properties class is that in Hashtable, we cannot set a default value so that we can use it when no value is associated with a certain key. But in the Properties class, we can set the default value.

PropertiesExample.java

import java.util.*;
public class PropertiesExample
{	
   public static void main(String[] args)
   {
     Properties prop_data = new Properties();
     prop_data.put("India", "Movies.");
     prop_data.put("United State", "Nobel Laureates and Getting Killed by Lawnmowers.");
     prop_data.put("Pakistan", "Field Hockey.");
     prop_data.put("China", "CO2 Emissions and Renewable Energy.");
     prop_data.put("Sri Lanka", "Cinnamon."); 
     Set< ?> set_data = prop_data.keySet();	 
     for(Object obj: set_data)
     {
         System.out.println(obj+" is famous for "+ prop_data.getProperty((String)obj));
     }	 
   }  
}

Output:

Stack Class

Stack class extends Vector class, which follows the LIFO(LAST IN FIRST OUT) principal for its elements. The stack implementation has only one default constructor, i.e., Stack().

1) Stack()

It is used to create a stack without having any elements.

There are the following methods can be used with Stack class:

The push() method is used to add an object to the stack. It adds an element at the top of the stack.
The pop() method is used to get or remove the top element of the stack.
The peek() method is similar to the pop() method, but it can't remove the stack's top element using it.
The empty() method is used to check the emptiness of the stack. It returns true when the stack has no elements in it.
The search() method is used to ensure whether the specified object exists on the stack or not.

StackExample.java

import java.util.*;
class StackExample {
          public static void main(String args[]) {
                       Stack stack = new Stack();
                       stack.push("Emma");
                       stack.push("Adele");
                       stack.push("Aria");
                       stack.push("Ally");
                       stack.push("Paul");
                       Enumeration enum1 = stack.elements();
                       while(enum1.hasMoreElements())
                                   System.out.print(enum1.nextElement()+" ");
                       stack.pop();
                       stack.pop();
                       stack.pop();
                       System.out.println("\nAfter removing three elements from stack");
                       Enumeration enum2 = stack.elements();
                       while(enum2.hasMoreElements())
                                  System.out.print(enum2.nextElement()+" ");
           }
}

Output:

Dictionary Class

The Dictionary class operates much like Map and represents the key/value storage repository. The Dictionary class is an abstract class that stores the data into the key/value pair. We can define the dictionary as a list of key/value pairs.

The dictionary class provides the following methods:

The put(K key, V value) method is used to add a key-value pair to the dictionary.
The elements() method is used to get the value representation in the dictionary.
The get(Object key) method is used to get the value mapped with the argumented key in the dictionary.
The isEmpty() method is used to check whether the dictionary is empty or not.
The keys() method is used to get the key representation in the dictionary.
The remove(Object key) method removes the data from the dictionary.
The size() method is used to get the size of the dictionary.

DictionaryExample.java

import java.util.*; 
public class DictionaryExample
{ 
    public static void main(String[] args) 
    { 
        // Initializing Dictionary object
        Dictionary student = new Hashtable(); 
  
        // Using put() method to add elements
        student.put("101", "Emma"); 
        student.put("102", "Adele");
        student.put("103", "Aria");
        student.put("104", "Ally");
        student.put("105", "Paul");
  
        //Using the elements() method 
        for (Enumeration enum1 = student.elements(); enum1.hasMoreElements();) 
        { 
            System.out.println("The data present in the dictionary : " + enum1.nextElement()); 
        } 
  
        // Using the get() method 
        System.out.println("\nName of the student 101 : " + student.get("101")); 
        System.out.println("Name of the student 102 : " + student.get("102")); 
  
        //Using the isEmpty() method 
        System.out.println("\n Is student dictionary empty? : " + student.isEmpty() + "\n"); 
  
        // Using the keys() method
        for (Enumeration enum2 = student.keys(); enum2.hasMoreElements();) 
        { 
            System.out.println("Ids of students: " + enum2.nextElement()); 
        } 
  
        // Using the remove() method
        System.out.println("\nDelete : " + student.remove("103")); 
        System.out.println("The name of the deleted student : " + student.get("123")); 
  
        System.out.println("\nThe size of the student dictionary is : " + student.size()); 
  
    } 
}

Output:

All the classes that we have discussed above are known as legacy classes. For supporting generic in JDK5, the above-discussed classes were re-engineered.

Next TopicCharacter Array in Java

← prev next →