Collections in Java

Introduction

Collections represent a group. In arrays there is a size restriction, but in collections there is no size restriction. It grows and shrinks at run time. This is the main advantage of collections. The following are the four flavours of collections.

• List
• Set
• Queue
• Map

List

It is further divided into :

• Array List
• Vector (oldest list provided by Java)
• Linked List

Array List

As far as Array Lists are concerned, they can grow or shrink, that's why they are different from arrays. Array lists are initialized by an initial size, but if we need more or less size then it will automatically grow or shrink accordingly. So if you do not know the size then it is better to use an Array List.

Example:

package myclass1;

import java.util.*;

class Myclass1

{

 public static void main(String args[])

 {

  ArrayList AL = new ArrayList();

  AL.add("aman");

  AL.add("varun");

  AL.add("tarun");

  AL.add("raman");

  System.out.println("AL: " + AL);

 

 }

}

Output:

Vector

As far as vector is considered, it implements an array, but that array is dynamic. It is the oldest list provided by Java. It is similar to Array Lists, but has some differences. It is synchronized, on the other hand Array List is not.

Example:

package myclass1;

import java.util.*;

class Myclass1

{

 public static void main(String args[])

 {

      Vector vec = new Vector(4, 3);

      vec.addElement(new Integer(21));

      vec.addElement(new Integer(22));

      vec.addElement(new Integer(23));

      Enumeration vecEnum = vec.elements();

      System.out.println("\nElements:");

      while(vecEnum.hasMoreElements())

      System.out.print(vecEnum.nextElement() + " ");

      System.out.println();

   }

}

Output:

Linked List

 

This is also an implementation of a list. Like Array List, it is also not synchronized. It has a contiguous memory allocation. It allows duplicate values.

 

Example:

 

package myclass1;

import java.util.*;

class Myclass1

{

 public static void main(String args[])

 {

  LinkedList LL = new LinkedList();

  LL.add("aman");

  LL.add("varun");

  LL.add("tarun");

  LL.add("raman");

  System.out.println("LL: " + LL);

 

 }

}

Output:

Set

 

It is further divided into:

• Hash Set

• Tree Set

• Linked Hash Set

Hash Set

 

It uses Hash Table to store the elements. It contains only unique elements. The process of storing elements is known as hashing.

 

Example:

 

package myclass1;

import java.util.*;

class Myclass1

{

 public static void main(String args[])

 {

  HashSet TS = new HashSet();

  HS.add("a");

  HS.add("v");

  HS.add("tn");

  HS.add("ra");

  System.out.println("HS: " + HS);

 

 }

}

Output:

Tree Set

 

It also contains unique elements. The ascending order of elements is maintained in a Tree Set, hence it's access and retrieval time is very fast, that's why it is very useful.

 

Example:

package myclass1;

import java.util.*;

class Myclass1

{

 public static void main(String args[])

 {

  TreeSet TS = new TreeSet();

  TS.add("amm");

  TS.add("vnn");

  TS.add("tnn");

  TS.add("ran");

  System.out.println("TS: " + TS);

 

 }

}

Output:

Linked Hash Set

 

It also contains unique elements. The insertion order of the elements is maintained in a Linked Hash Set.

 

Example:

 

package myclass1;

import java.util.*;

class Myclass1

{

 public static void main(String args[])

 {

  LinkedHashSet LHS = new LinkedHashSet();

  LHS.add("m");

  LHS.add("n");

  LHS.add("t");

  LHS.add("a");

  System.out.println("LHS: " + LHS);

 

 }

}

Output:

 

Queue

 

It is further divided into:

• Priority Queue

Priority Queue

 

It uses a queue, but like a queue its elements are not in FIFO (first in first out) order. The elements are ordered naturally depending on their order. It does not allow null elements.

 

Example:

 

package myclass1;

import java.util.*;

class Myclass1

{

 public static void main(String args[])

 {

 PriorityQueue qu = new PriorityQueue();

  qu.add("man");

  qu.add("nan");

  qu.add("tan");

  qu.add("aan");

  System.out.println("qu: " + qu);

 

 }

}

Output:

Map

 

It is further divided into:

• Hash Table

• Hash Map

• Tree Map

Hash Table

 

We have a key and a value in a hash table. It cannot contain any null key or value. It also contains unique elements. It is also synchronized.

 

Example:

 

package myclass1;

import java.util.*;

class Myclass1

{

 public static void main(String args[])

 {

      Hashtable ht = new Hashtable();

      Enumeration name;

      String str;

      double bal;

 

      ht.put("ankur", new Double(1112.24));

      ht.put("Manu", new Double(1124.42));

      ht.put("Arun", new Double(1348.50));

      ht.put("Danik", new Double(9933.24));

      name = ht.keys();

      while(name.hasMoreElements())

      {

         str = (String) name.nextElement();

         System.out.println(str + ": " +

         ht.get(str));

      }

      System.out.println();

      bal = ((Double)ht.get("ankur")).doubleValue();

      ht.put("ankur", new Double(bal+1000));

      System.out.println("ankur's new ht: " +

      ht.get("ankur"));

 }

}

Output:

Hash Map

 

Unlike a Hash Table it can have one null key and many null values. No order is maintained. It is completely based on the key.

 

Example:

 

package myclass1;

import java.util.*;

class Myclass1

{

 public static void main(String args[])

 {

     Map<String, String> hashMap = new HashMap<String, String>();

      hashMap.put("Na", "four");

      hashMap.put("times", "5");

      hashMap.put("cost", "15000");

      System.out.println("Elements:");

      System.out.println(hashMap);

  }

}

Output:

Tree Map

 

It is also based on the key. Unlike a Hash Map it cannot have a null key, but can have many null values. Ascending order is maintained in a Tree Map. Retrieval is very fast here.

 

Example:

 

package myclass1;

import java.util.*;

class Myclass1

{

 public static void main(String args[])

 {

      TreeMap tm = new TreeMap();

      tm.put("amyra", new Double(1314.134));

      tm.put("rahul", new Double(1221.221));

      tm.put("raj", new Double(1372.67));

      Set set = tm.entrySet();

      Iterator i = set.iterator();

      while(i.hasNext())

      {

        Map.Entry me = (Map.Entry)i.next();

        System.out.print(me.getKey() + ": ");

        System.out.println(me.getValue());

      }

      System.out.println();

      double balance = ((Double)tm.get("amyra")).doubleValue();

      tm.put("amyra", new Double(balance + 20000));

      System.out.println("amyra's new balance: " +

      tm.get("amyra"));

 }

}

Output:

Summary

 

This article explained collections and the various flavours of collections. These collections are very useful in Java.