What Are Java Collections and How to Implement Them?

Java Collections are the one-stop solutions for all the data manipulation jobs such as storing data, searching, sorting, insertion, deletion, and updating of data. Java collection responds as a single object, and a Java Collection Framework provides various Interfaces and Classes.

We will learn them through the following docket:

  • What is a Java Collection?
  • What is the Java Collection Framework?
  • Java Collection Framework Hierarchy
  • Java Collections Interface Methods
  • Java Collections Interface
  • Java Collection Classes
  • Collection API Algorithms
  • Benefits of Java Collections

What is a Java Collection?

A Java Collection is a predefined architecture capable of storing a group of elements and behaving like a single unit such as an object or a group. 

And now that you’re aware of what exactly is Java Collections, the next step is understanding the term Java Collections Framework.

Full Stack Java Developer Course

The Gateway to Master Web DevelopmentExplore Course
Full Stack Java Developer Course

What is the Java Collection Framework?

Java Collection Framework offers the capability to Java Collection to represent a group of elements in classes and Interfaces.

Java Collection Framework enables the user to perform various data manipulation operations like storing data, searching, sorting, insertion, deletion, and updating of data on the group of elements. Followed by the Java Collections Framework, you must learn and understand the Hierarchy of Java collections and various descendants or classes and interfaces involved in the Java Collections.

Java Collection Framework Hierarchy

Java-collection-java-collection-hierarchy

Java-collection-java-collection-hierarchy-2

The following image depicts the Java Collections Hierarchy.

After the Hierarchy of Java collections; you should also get to know the various methods applied to the Collections in Java to perform the data manipulation operations.

Java Collections Interface Methods

The table below describes the methods available to use against Java Collections for data Manipulation Jobs.

Method

Description

add()

Add objects to collection.

isEmpty()

Returns true if collection is empty

clear()

Removes all elements from the collection

remove()

Remove a selected object

size()

Find the number of elements

stream()

Return Sequential elements

toArray()

Returns elements in array format

hashCode()

Returns Hashcode of the elements

equals(obj X)

Compare an element with the collection

iterator()

Return an iterator over collection

max()

Return max value in the collection

contains()

Returns true is a particular value is present

spliterator()

Creates splietarator over the elements in the collection

retainAll()

Retains elements in the collection

Well, after the quick briefing of all the data manipulating methods that can be used against Java Collections, the next step should be to dive into learning all the Interfaces and classes present in Java Collections with proper definitions and practical examples.

Learn top skills demanded in the industry, including Angular, Spring Boot, Hibernate, Servlets, and JSPs, and SOA to build highly web scalable apps with the Full Stack Java Developer Masters Program.

Java Collections Interface

Set Interface

The set interface is inherited from the Java collections Interface A Set interface cannot store duplicate/redundant elements in it. Here’s an example based on a set interface.

Example:

//Set Interface

package Simplilearn;

import java.util.*;

public class SetExample {

public static void main(String args[]) {

int count[] = { 21, 23, 43, 53, 22, 65 };

Set<Integer> set = new HashSet<Integer>();

try {

for (int i = 0; i <= 5; i++) {

set.add(count[i]);

}

System.out.println(set);

TreeSet<Integer> sortedSet = new TreeSet<Integer>(set);

System.out.println("The sorted list is:");

System.out.println(sortedSet);

System.out.println("First element of the set is: " + (Integer) sortedSet.first());

System.out.println("last element of the set is: " + (Integer) sortedSet.last());

} catch (Exception e) {

}

}

}

List Interface

The List interface is derived from the java util package. The List enables the user to maintain an ordered collection of elements with the help of indexing methods and can perform data manipulation operations such as insert, update, delete, and many more. For instance:

Example:

//List Interface

package Simplilearn;

import java.util.*;

public class ListInterface {

public static void main(String args[]) {

List<String> list = new ArrayList<String>();

list.add("David");

list.add("Jhon");

list.add("Stacy");

//list.add("Stacy");

for (String Students : list)

System.out.println(Students);

}

}

Queue Interface

A Queue interface is inherited from the Java Collections interface. The Queue is a linear Collection that offers data manipulation operations on the collection elements, and follows the FIFO(First In First Out) principle. For example:

Example:

//Queue Interface

package Simplilearn;

import java.util.*;

public class QueueInterface {

public static void main(String[] args) {

Queue<String> queue = new LinkedList<>();

queue.add("Apple");

queue.add("Mango");

queue.add("Grapes");

queue.add("Banana");

System.out.println(queue);

queue.remove("Grapes");

System.out.println(queue);

System.out.println("Queue total Size: " + queue.size());

System.out.println("Queue includes fruit 'Apple'? : " + queue.contains("Apple"));

queue.clear();

}

}

Deque Interface

A Deque interface is inherited from the Java Collections Interface. The term DE-Que stands for Double-Ended Queue. The Deque supports insertion and deletion operations on both sides of the Queue.

Example:

//Deque Interface

package Simplilearn;

import java.util.ArrayDeque;

import java.util.Deque;

public class DequeInterface {

public static void main(String[] args) {

Deque<Integer> num = new ArrayDeque<>();

num.offer(10);

num.offerLast(21);

num.offerFirst(52);

System.out.println("Deque elements: " + num);

int first = num.peekFirst();

System.out.println("First Element is: " + first);

int lastElement = num.peekLast();

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

int removed = num.pollFirst();

System.out.println("Removed First Element: " + removed);

System.out.println("Updated Deque is: " + num);

}

}

Map Interface

The Map interface is inherited from Java Collection Interface. The Map cannot store duplicate elements. A Map stores data using the key-value pair format. The manipulation operations are taken care of through accessing the key-value pairs.

Next up: an example based on the Map interface

Example:

//Map Interface

package Simplilearn;

import java.util.*;

import java.util.Map.Entry;

public class MapInterface {

public static void main(String args[]) {

Map<Integer, String> map = new HashMap<Integer, String>();

map.put(1, "Cricket");

map.put(2, "Hockey");

map.put(3, "Archery");

for (Iterator<Entry<Integer, String>> iterator = map.entrySet().iterator(); iterator.hasNext();) {

Entry<Integer, String> m = iterator.next();

System.out.println(m.getKey() + " " + m.getValue());

}

}

}

SortedSet Interface

Sorted set interface maintains mapping in ascending order. They are used for naturally ordered collection. 

An example of SortedSet Interface:

//Sortedset Interface

package Simplilearn;

import java.util.*;

public class SortedSetInterface {

   public static void main(String[] args) {

      SortedSet set = new TreeSet(); 

      set.add("Bob");

      set.add("Sean");

      set.add("Jennifer");

      Iterator i = set.iterator();

      while (i.hasNext()) {

      Object element = i.next();

      System.out.println(element.toString());

      }

   }

}

SortedMap Interface

A Sorted map interface maintains the mappings of elements in ascending critical order. SortedMap is the Map analog of SortedSet.  

Example:

//Sortedmap Interface

package Simplilearn;

import java.util.*;

public class SortedMapInterface {

   public static void main(String args[]) {

      TreeMap<String, Double> t = new TreeMap<String, Double>();

      t.put("John", new Double(76.5));

      t.put("Molley", new Double(87.3));

      t.put("Aron", new Double(78.2));

      t.put("Daisy", new Double(73.4));

      Set<?> set = t.entrySet();

      Iterator<?> i = set.iterator();

      while(i.hasNext()) {

         @SuppressWarnings("rawtypes")

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

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

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

      }

      System.out.println();

      double percentage = ((Double)t.get("Molley")).doubleValue();

      t.put("Molley", new Double(percentage));

      System.out.println("Zara's new balance: " + t.get("Molley"));

   }

}

After this comes to another critical aspect, an adjacent branch of Java Collections, known as the Java Collection Classes.

Java Collection Classes

HashSet Class

The HashSet class is inherited from the AbstractSet class. HashSet class stores the elements using a Hash table.HashSet allows null elements and does not follow any order to store the elements.

Here’s an example of HashSet:

//HashSet Class

package Simplilearn;

import java.util.HashSet;

public class HashSetClass {

public static void main(String args[]) {

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

hset.add("Suzuki");

hset.add("Kawasaki");

hset.add("Honda");

hset.add("Ducati");

hset.add("Yamaha");

hset.add("Yamaha");

hset.add("Suzuki");

hset.add(null);

hset.add(null);

// Displaying HashSet elements

System.out.println(hset);

}

}

TreeSet Class

TreeSet Class is a NavigableSet implementation based on TreeMap. Here, the elements are ordered using comparators. 

Let us check an example based on TreeSet Class.

//TreeSet

package Simplilearn;

import java.util.TreeSet;

public class TreeSetClass {

     public static void main(String args[]) {

         TreeSet<Integer> treeset = new TreeSet<Integer>();

         treeset.add(8476);

         treeset.add(748);

         treeset.add(88);

         treeset.add(983);

         treeset.add(18);

         treeset.add(0);

         System.out.println(treeset);

    }

 }

ArrayList Class

ArrayList in java is a resizable array that is an implementation of ListInterface that allows null elements. The ArrayList has three different types of Arrays, as shown below.

  • One Dimensional Array
  • Two Dimensional Array
  • Multidimensional Array

One Dimensional Array

One Dimensional Array has one row that arranges the elements in the sequential order of addresses, as shown in the image below.

Java-collection-one-dimensional-array

Here’s an example of One Dimensional Array:

//One-Dimensional Array

package Simplilearn;

public class OneDA {

public static void main(String args[]) {

int[] a = new int[3];

a[0] = 10;

a[1] = 20;

a[2] = 30;

System.out.println("One dimensional array");

System.out.println(a[0]);

System.out.println(a[1]);

System.out.println(a[2]);

}

}

Two Dimensional Array

Two Dimensional Array has rows and columns. It arranges the elements in the form of a matrix, as shown in the image below.

Java-collection-two-dimensional-array

For a better understanding of Two Dimensional Array, let us go through the example.

Example:

//Two-Dimensional Array

package Simplilearn;

public class TwoDA {

public static void main(String[] args) {

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

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

for (int j = 0; j < 2; j++)

System.out.println("arr[" + i + "][" + j + "] = " + arr[i][j]);

}

}

Multidimensional Array

The Multidimensional Array is a combination of multiple two-dimensional arrays; it looks like a 3-D image as shown below

Java-collection-multi-dimensional-array

To understand in a better way, let us check out an example of a Multidimensional Array.

Example:

//Three/Multi-Dimensional Array

package Simplilearn;

public class ThreeDA {

public static void main(String args[]) {

int A[][] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

for (int i = 0; i < 3; i++) {

for (int j = 0; j < 3; j++) {

System.out.print(A[i][j] + " ");

}

System.out.println();

}

}

}

LinkedList Class

LinkedList class is an implementation of a list and deque interfaces. Linked List is similar to an array, but it does not store data in sequential data addresses, but connects the memory blocks in the sequential order and allows null elements.

There are three different types of linked lists.

  • Singly Linked List
  • Doubly Linked List
  • Circular Linked List

Singly Linked List

A Singly Linked List stores elements in different memory locations and then connects them in one direction to represent them sequentially. A typical singly-linked List is shown in the image below.

A Singly linked list offers traversal in one direction only.

Java-collection-singly-linked-list

To understand a singly linked list in a better way, here’s an example:

//Singly-LinkedList

package Simplilearn;

public class SiinglyLinkedList {

Node head;

static class Node {

int data;

Node next;

Node(int d) {

data = d;

next = null;

}

}

public void display() {

Node n = head;

while (n != null) {

System.out.print(n.data + " \n");

n = n.next;

}

}

public static void main(String[] args) {

SiinglyLinkedList list = new SiinglyLinkedList();

list.head = new Node(1);

Node second = new Node(2);

Node third = new Node(3);

Node fourth = new Node(4);

list.head.next = second;

second.next = third;

third.next = fourth;

list.display();

}

}

Doubly Linked List

A Doubly linked list is typically a Singly linked list, but a doubly linked list offers traversal in two directions. Here’s how a typical doubly linked list looks like:

Java-collection-doubly-linked-list

To understand a doubly linked list in a better way, let us check an example.

Example:

//Doubly LinkedList

package Simplilearn;

public class DoublyLinkedList {

class Node {

int data;

Node previous;

Node next;

public Node(int data) {

this.data = data;

}

}

Node head, tail = null;

public void addNode(int data) {

Node newNode = new Node(data);

if (head == null) {

head = tail = newNode;

head.previous = null;

tail.next = null;

} else {

tail.next = newNode;

newNode.previous = tail;

tail = newNode;

tail.next = null;

}

}

public void display() {

Node current = head;

if (head == null) {

System.out.println("List is empty");

return;

}

System.out.println("Nodes of doubly linked list: ");

while (current != null) {

System.out.print(current.data + " ");

current = current.next;

}

}

public static void main(String[] args) {

DoublyLinkedList dList = new DoublyLinkedList();

dList.addNode(1);

dList.addNode(2);

dList.addNode(3);

dList.addNode(4);

dList.addNode(5);

dList.display();

}

}

Circular Linked List

A circular linked list is a typical singly linked list. The only change is that the Circular linked List's end/tail points back to the linked List's head node. The Head and Tail Connection at the end makes the circular linked List to offer circular traversal.

Java-collection-circular-linked-list

To understand a Circular linked list in a better way, let us check an example

Example:

//Circular LinkedList

package Simplilearn;

public class CLL {  

    public class Node{  

        int data;  

        Node next;  

        public Node(int data) {  

            this.data = data;  

        }  

    }  

  

    public Node head = null;  

    public Node tail = null;  

  

    public void add(int data){  

        Node newNode = new Node(data);  

        if(head == null) {  

            head = newNode;  

            tail = newNode;  

            newNode.next = head;  

        }  

        else {  

            tail.next = newNode;  

            tail = newNode;  

            tail.next = head;  

        }  

    }  

  

    public void display() {  

        Node current = head;  

        if(head == null) {  

            System.out.println("List is empty");  

        }  

        else {  

            System.out.println("Nodes of the circular linked list: ");  

             do{  

                System.out.print(" "+ current.data);  

                current = current.next;  

            }while(current != head);  

            System.out.println();  

        }  

    }  

  

    public static void main(String[] args) {  

        CLL c = new CLL();  

        c.add(1);  

        c.add(2);  

        c.add(3);  

        c.add(4);  

        c.add(5);  

        c.add(6);  

        c.add(7);  

        c.add(8);

        c.display();  

    }  

}  

HashMap Class

HashMap is derived from the Map interface. HashMap stores data using the key-value pair method. HashMap does not allow duplicate elements.

Here’s an example based on HashMap:

//HashMap Class

package Simplilearn;

import java.util.HashMap;

public class HashMapClass {

public static void main(String[] args) {

HashMap<String, String> Make = new HashMap<String, String>();

Make.put("Honda", "CBR");

Make.put("Kawasaki", "Ninja");

Make.put("Ducati", "Panigale");

Make.put("Yamaha", "R1");

System.out.println(Make);

}

}

TreeMap Class

The TreeMap is derived from the AbstractMap Class. TreeMap stores elements in the form of key-value pairs. TreeMap does not allow null and duplicate values in the collection.

Let us go through an example based on TreeMap.

Example:

//TreeMap Class

 

package Simplilearn;

 

import java.util.*;

import java.util.Map.Entry;  

public class TreeMapClass{  

 public static void main(String args[]){  

   TreeMap<Integer,String> map=new TreeMap<Integer,String>();    

      map.put(2019901,"Amber");    

      map.put(2019902,"james");    

      map.put(2019903,"Violet");    

      map.put(2019904,"Reynolds");    

        

      for (Iterator<Entry<Integer, String>> iterator = map.entrySet().iterator(); iterator.hasNext();) {

Entry<Integer, String> m = iterator.next();

System.out.println(m.getKey()+" "+m.getValue());

}    

 }  

}

Followed by the Java Collections Classes, we will now enter into the last adjacent branch of Java Collections, the Java Collection Algorithm APIs.

Collection API Algorithms

Java Collection API algorithms provide implementations that are commonly used in searching, sorting and other jobs.

Sorting

The sorting Algorithm is one of the Collections API Algorithms. The sorting Algorithm does the job of ordering the elements in an ascending or descending order based on the modifications written by the user.

Java-collection-java-collection-api-bubblesort.

To understand the sorting Algorithm in a better way here’s an example

Example:

//Bubble Sort

package Simplilearn;

public class BubbleSort {

static void bubbleSort(int[] arr) {

int n = arr.length;

int temp = 0;

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

for (int j = 1; j < (n - i); j++) {

if (arr[j - 1] > arr[j]) {

temp = arr[j - 1];

arr[j - 1] = arr[j];

arr[j] = temp;

}

}

}

}

public static void main(String[] args) {

int arr[] = { 289, 39, 48, 6, 28, 1, 2, 33 };

System.out.println("Array Before Bubble Sort");

for (int j = 0; j < arr.length; j++) {

System.out.print(arr[j] + " ");

}

System.out.println();

bubbleSort(arr);

System.out.println("Array After Bubble Sort");

for (int j = 0; j < arr.length; j++) {

System.out.print(arr[j] + " ");

}

}

}

Shuffling

The shuffling Algorithm is one of the Collections API algorithms. The functionality of the Shuffling Algorithm is to destroy the current arrangements. They are employed on creating randomness in the List.

Java-collection-java-collection-api-shuffling

Let us check out an example to understand it in a better way

Example:

//Shuffle algorithm

package Simplilearn;

import java.util.Arrays;

import java.util.Collections;

import java.util.List;

public class Shuffle {

public static void main(String[] args) {

Integer[] intA = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };

List<Integer> intL = Arrays.asList(intA);

Collections.shuffle(intL);

intL.toArray(intA);

System.out.println(Arrays.toString(intA));

}

}

Searching

A searching algorithm is employed to search an element in the list/array based on the type of searching mechanism used. 

Java-collection-java-collection-api-search

Example:

//Binary Search

package Simplilearn;

public class BinarySearch1 {

public static int binarySearch(int arr[], int first, int last, int key) {

if (last >= first) {

int mid = first + (last - first) / 2;

if (arr[mid] == key) {

return mid;

}

if (arr[mid] > key) {

return binarySearch(arr, first, mid - 1, key);

} else {

return binarySearch(arr, mid + 1, last, key);

}

}

return -1;

}

public static void main(String args[]) {

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

int k = 2;

int last = arr.length - 1;

int result = binarySearch(arr, 0, last, k);

if (result == -1)

System.out.println("Element is not found!");

else

System.out.println("Element is found at index: " + result);

}

}

Composition

The frequency and disjoint algorithms check a few aspects of the composition of one or more Collections.

Java-collection-java-collection-api-composition

The composition has two parts:

  1. Frequency: checks the count of an element repeated
  2. Disjoint: makes sure no element is repeated

Example:

//Composition

 

package Simplilearn;

 

import java.io.*;

import java.util.*;

 

class Book {

 

public String title;

public String author;

 

Book(String title, String author) {

 

this.title = title;

this.author = author;

}

}

 

class Library {

 

// reference to refer to list of books.

private final List<Book> books;

 

Library(List<Book> books) {

this.books = books;

}

 

public List<Book> getTotalBooksInLibrary() {

 

return books;

}

 

}

 

public class Composition {

public static void main(String[] args) {

 

Book b1 = new Book("EffectiveJ Java", "Joshua Bloch");

Book b2 = new Book("Thinking in Java", "Bruce Eckel");

Book b3 = new Book("Java: The Complete Reference", "Herbert Schildt");

 

List<Book> books = new ArrayList<Book>();

books.add(b1);

books.add(b2);

books.add(b3);

 

Library library = new Library(books);

 

List<Book> bks = library.getTotalBooksInLibrary();

for (Book bk : bks) {

 

System.out.println("Title : " + bk.title + " and " + " Author : " + bk.author);

}

}

}

Get a firm foundation in Java, the most commonly used programming language in software development with the Java Certification Training Course.

Benefits of Java Collections

Software/Code Reusability

Java Collections have reduced the coding lines impeccably and, along with that, featured the most reliable way code reusability.

Ease of Designing APIs

The predefined Java Collections algorithm APIs have reduced the time drastically. The absence of these APIs would have resulted in hours of coding for simple sorting operations.

Simpler to Learn and Use New APIs

The use of predefined API has made the learning process more straightforward and way more useful.

Increased Speed in Programming

The simplification introduced by the Java Collections had reduced the effort on programmers. Ease of coding procedures, in turn, resulted in the most effective and efficient programming practices that save time.

The Next Step

So here’s all you need to know about Java Collections. Java Collections are handy during real-time programming. With a good understanding of Java Collections, the next crucial step would be having a fundamental understanding of how to become a Software Developer.

And in case you’re looking for more in-depth knowledge about the Java Programming Language and getting certified as a professional Java Developer, check out our Java training and certification program curated by the most experienced real-time industry experts.

Also, if you have any questions about the "Java Collections" article, mention it in the comment section, and we'll have our experts answer it for you right away.

About the Author

SimplilearnSimplilearn

Simplilearn is one of the world’s leading providers of online training for Digital Marketing, Cloud Computing, Project Management, Data Science, IT, Software Development, and many other emerging technologies.

View More
  • Disclaimer
  • PMP, PMI, PMBOK, CAPM, PgMP, PfMP, ACP, PBA, RMP, SP, and OPM3 are registered marks of the Project Management Institute, Inc.