Java Collections Framework
Collections in Java refer to a group of objects that are stored and manipulated as a single unit. It provides a framework for storing, organizing, and managing groups of related data. Collections are a fundamental component of the Java programming language.
They allow programmers to store and manipulate data in a flexible and efficient way. Collections simplify the process of managing large amounts of data and enable the creation of complex data structures.
In this article, we will cover the basics of Java collections, including the Collection framework, the different types of collections, and how to use them. We will also discuss the advantages of using collections and provide examples of how to use them in real-world scenarios.
By the end of this article, you will have a solid understanding of collections in Java. You will be able to use them effectively in your own programs.
Java Collection Framework
Definition of Java Collection Framework
Java Collection Framework is a set of interfaces, classes, and algorithms that provide a way to store and manipulate groups of objects in Java. It is built on top of arrays and provides a more flexible and efficient way of storing and retrieving data.
Advantages of Collection Framework in Java
The Collection Framework provides several advantages, including:
1. Consistency: The Collection Framework provides a consistent way to store and manipulate data, regardless of the type of data being stored.
2. Reusability: The interfaces and classes in the Collection Framework can be used in different programs, making code reusable.
3. Type-safety: The Collection Framework provides type-safety, ensuring that data is stored and retrieved in a type-safe manner.
4. Interoperability: The Collection Framework is interoperable with other Java technologies, making it easy to integrate with other Java-based applications.
Components of Java Collection Framework
The Collection Framework consists of three main components:
1. Interfaces: The Collection Framework provides several interfaces, including List, Set, and Map, which define the behaviour and functionality of the collection classes.
2. Classes: The Collection Framework provides several classes, including ArrayList, HashSet, and HashMap, which implement the collection interfaces and provide different ways of storing and retrieving data.
3. Algorithms: The Collection Framework provides several algorithms, including sorting and searching algorithms, which can be used with the collection classes to perform operations on the data stored in the collections.
Interfaces in Java Collection Framework
List Interface
Definition:
The List interface is a subinterface of the Collection interface, which is a part of the Collection Framework. It is an ordered collection of elements where each element can be accessed using its index. The elements can be added, removed, and accessed by index.
Features:
The List interface has the following features:
1. Ordered collection of elements: The elements in a List are stored in a specific order, which is the order in which they are added to the List.
2. Indexed access: Each element in a List can be accessed using its index, which starts from 0.
3. Duplicate elements: Duplicate items are possible in a list.
4. Null elements: A List can contain null elements.
5. Iteration: The List interface provides methods to iterate through the elements of a List.
Implementations:
The List interface has several implementations, including ArrayList, LinkedList, and Vector. Let’s take a look at an example code that demonstrates the use of List interface using an ArrayList implementation:
import java.util.ArrayList;
import java.util.List;
public class ListExample {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
// Adding elements to the list
list.add("Java");
list.add("Python");
list.add("C++");
list.add("JavaScript");
// Accessing elements by index
System.out.println("Element at index 0: " + list.get(0));
System.out.println("Element at index 1: " + list.get(1));
// Iterating through the list
System.out.println("Iterating through the list:");
for (String element : list) {
System.out.println(element);
}
// Removing an element from the list
list.remove("C++");
System.out.println("List after removing C++: " + list);
// Checking if an element exists in the list
if (list.contains("Java")) {
System.out.println("List contains Java");
}
// Checking the size of the list
System.out.println("Size of the list: " + list.size());
}
}
Output:
Element at index 0: Java
Element at index 1: Python
Iterating through the list:
Java
Python
C++
JavaScript
List after removing C++: [Java, Python, JavaScript]
List contains Java
Size of the list: 3
Set Interface
Definition
The Set Interface in the Collection Framework is a subtype of the Collection interface. It represents a set of elements that cannot contain duplicates. It is an unordered collection of elements and does not maintain the insertion order.
Features
1. The Set Interface has the following features:
2. Does not allow duplicate elements
3. Does not keep the sequence of the items’ insertion
4. Provides methods for basic set operations such as union, intersection, and difference
5. Allows null elements but only once
6. Provides a method to check if a particular element is present in the set
Implementations
The Set Interface has several implementations in the Collection Framework. Some of them are:
1. HashSet: It stores elements in a hash table and does not guarantee the order of elements.
2. LinkedHashSet: It is similar to HashSet but maintains the insertion order of elements.
3. TreeSet: It stores elements in a sorted tree and maintains the order of elements according to their natural ordering or custom comparator. It does not allow null elements.
Example code:
import java.util.*;
public class SetInterfaceExample {
public static void main(String[] args) {
// Creating a HashSet
Set<String> set = new HashSet<>();
// Adding elements to the set
set.add("Apple");
set.add("Banana");
set.add("Orange");
set.add("Grapes");
set.add("Kiwi");
// Adding a duplicate element
set.add("Apple");
// Printing the set
System.out.println("Set elements: " + set);
// Checking if a particular element is present in the set
boolean isPresent = set.contains("Banana");
System.out.println("Is Banana present? " + isPresent);
// Removing an element from the set
boolean isRemoved = set.remove("Grapes");
System.out.println("Is Grapes removed? " + isRemoved);
// Printing the set again
System.out.println("Set elements after removing Grapes: " + set);
}
}
Output:
Set elements: [Apple, Kiwi, Grapes, Orange, Banana]
Is Banana present? true
Are Grapes removed? true
Set elements after removing Grapes: [Apple, Kiwi, Orange, Banana]
Queue Interface:
Definition:
The Queue interface is a part of the Collection framework in Java that implements a Queue data structure. The Queue interface is used to hold elements that need to be processed in a specific order. The order is usually the order in which they were added to the queue. The Queue follows the FIFO (First In First Out) principle. This means that the element added first to the queue is the first one to be removed.
Features:
Some of the important features of the Queue interface are:
1. The elements in a queue are added to the back of the queue and removed from the front of the queue.
2. It does not allow null elements.
3. It offers ways to add, remove, and check the things in the queue.
4. It also provides methods for checking the size of the queue and whether it is empty.
Implementations:
There are several implementations of the Queue interface in Java, some of which are:
1. LinkedList: It is a class that implements both the List and Queue interfaces in Java. It provides a doubly-linked list implementation of the Queue interface.
2. PriorityQueue: PriorityQueue is an implementation of the Queue interface. It provides a priority queue based on the natural ordering of the elements or a Comparator. The Comparator is provided at the time of creation of the PriorityQueue.
ArrayDeque: It is an implementation of the Deque interface that can be used as a queue. It provides a resizable array implementation of the Queue interface.
Example code for using Queue interface with LinkedList implementation:
import java.util.LinkedList;
import java.util.Queue;
public class QueueExample {
public static void main(String[] args) {
Queue<String> queue = new LinkedList<>();
queue.add("element1");
queue.add("element2");
queue.add("element3");
System.out.println("Elements in queue: " + queue);
System.out.println("Removing element from the front of the queue: " + queue.remove());
System.out.println("Elements in queue after removal: " + queue);
System.out.println("Size of queue: " + queue.size());
System.out.println("Is queue empty? " + queue.isEmpty());
}
}
Output:
Elements in queue: [element1, element2, element3]
Removing an element from the front of the queue: element1
Elements in the queue after removal: [element2, element3]
Size of queue: 2
Is the queue empty? false
Map Interface
Definition:
Map interface is a part of the Collection Framework in Java, and it maps keys to values. It holds the data in the form of key-value pairs. The keys in a map are unique, and each key is associated with a specific value.
Features:
The Map interface has the following features:
1. A Map stores data in key-value pairs.
2. The keys in a map are unique.
3. The values in a map can be duplicated.
4. The data is stored in an unordered way.
5. The Map interface provides several methods to access and manipulate the data stored in a map.
Implementations:
The Map interface is implemented by several classes in Java, some of which are:
1. HashMap: It is the most commonly used implementation of the Map interface. It is based on the hash table data structure and provides constant time performance for basic operations like adding, removing, and retrieving elements.
2. TreeMap: It is a sorted implementation of the Map interface that orders the elements based on the natural ordering of the keys or a custom comparator. It has a slower performance than HashMap for basic operations but provides several methods for range searches.
3. LinkedHashMap: It is an implementation of the Map interface that maintains the order in which the elements are inserted into the map. It has a slightly slower performance than HashMap for basic operations but provides predictable iteration order.
4. ConcurrentHashMap: It is a concurrent implementation of the Map interface that provides thread-safe access to the map. It provides high scalability and performance for concurrent access.
Example Code:
import java.util.HashMap;
import java.util.Map;
public class MapExample {
public static void main(String[] args) {
// Creating a map of String keys and Integer values
Map<String, Integer> map = new HashMap<>();
// Adding values to the map
map.put("apple", 10);
map.put("banana", 20);
map.put("orange", 30);
// Printing the size of the map
System.out.println("Map size: " + map.size());
// Retrieving the value of the key "apple"
System.out.println("Value of key 'apple': " + map.get("apple"));
// Checking if the key "banana" is present in the map
System.out.println("Is 'banana' a key in the map? " + map.containsKey("banana"));
// Checking if the value 20 is present in the map
System.out.println("Is 20 a value in the map? " + map.containsValue(20));
// Removing the key "orange" from the map
map.remove("orange");
// Printing the size of the map after removing the key "orange"
System.out.println("Map size after removing 'orange': " + map.size());
}
}
Output:
Map size: 3
Value of key ‘apple’: 10
Is ‘banana’ a key in the map? true
Is 20 a value in the map? true
Map size after removing ‘orange’: 2
Classes in the Collection Framework
ArrayList Class
Definition:
ArrayList is a class in Java that implements the List interface and is based on an array data structure that can dynamically resize to accommodate new elements. It stores the elements in the order they were inserted and allows duplicate elements.
Features:
1. ArrayList can be resized dynamically.
2. Elements can be accessed using their index.
3. Allows duplicates.
4. Allows null elements.
5. Maintains the insertion order.
Methods:
1. The add(E e) method adds a given element to the end of the list.
2. The get(int index) method retrieves the element located at a specified position within the list.
3. The remove(int index) method eliminates the element located at a specified position within the list.
4. The size() method returns the total number of elements present within the list.
5. The clear() method removes all the elements present in the list.
Example code:
import java.util.*;
public class ArrayListExample {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("apple");
list.add("banana");
list.add("orange");
System.out.println("List: " + list);
System.out.println("Element at index 1: " + list.get(1));
list.remove(2);
System.out.println("List after removing element at index 2: " + list);
System.out.println("Size of the list: " + list.size());
list.clear();
System.out.println("List after clearing all elements: " + list);
}
}
Output:
List: [apple, banana, orange]
Element at index 1: banana
List after removing element at index 2: [apple, banana]
Size of the list: 2
List after clearing all elements: []
LinkedList Class
Definition:
LinkedList is a class in Java that implements the List and Deque interfaces. It is based on a linked list data structure. The linked list can dynamically resize to accommodate new elements. It stores the elements in the order they were inserted and allows duplicate elements.
Features:
1. LinkedList can be resized dynamically.
2. Elements can be accessed using their index.
3. Allows duplicates.
4. Allows null elements.
5. Maintains the insertion order.
6. Supports operations at both ends of the list.
Methods:
1. The add(E e) method adds the given element to the end of the LinkedList.
2. The get(int index) method retrieves and returns the element at the specified position in the LinkedList.
3. The remove(int index) method removes the element at the specified position in the LinkedList.
4. The size() method returns the number of elements in the LinkedList.
5. addFirst(E e): adds the specified element to the beginning of the list.
6. addLast(E e): adds the specified element to the end of the list.
7. removeFirst(): eliminates and retrieves the initial element from the list.
8. removeLast(): eliminates and retrieves the last element from the list.
Example code:
import java.util.*;
public class LinkedListExample {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
list.add("apple");
list.add("banana");
list.add("orange");
System.out.println("List: " + list);
System.out.println("Element at index 1: " + list.get(1));
list.remove(2);
System.out.println("List after removing element at index 2: " + list);
System.out.println("Size of the list: " + list.size());
list.addFirst("grape");
list.addLast("pear");
System.out.println("List after adding elements to the beginning and end: " + list);
System.out.println("First element in the list: " + list.removeFirst());
System.out.println("Last element in the list: " + list.removeLast());
}
}
Output:
List: [apple, banana, orange]
Element at index 1: banana
List after removing element at index 2: [apple, banana]
Size of the list: 2
List after adding elements to the beginning and end: [grape, apple, banana, pear]
The first element in the list is grape
The last element on the list is the pear
HashSet Class
Definition
The HashSet class in Java implements the Set interface and stores a collection of unique elements. It is implemented using a hash table data structure and provides constant time performance for basic operations like add, remove, contain, and size.
Features
1. HashSet stores only unique elements, and duplicates are not allowed.
2. It does not maintain any order of elements.
3. HashSet permits null values.
4. It is not thread-safe.
Methods
1. add(E e): Adds an element to the HashSet if it is not already present.
2. remove(Object o): Removes the specified element from the HashSet if it is present.
3. contains(Object o): Returns true if the HashSet contains the specified element.
4. size(): Returns the number of elements in the HashSet.
5. clear(): deletes every element from the HashSet.
Example Implementation:
import java.util.*;
public class SetExample {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
set.add("apple");
set.add("banana");
set.add("orange");
set.add("apple"); // Duplicate element
System.out.println("Set size: " + set.size());
System.out.println("Is 'apple' in the set? " + set.contains("apple"));
set.remove("orange");
System.out.println("Set size after removing 'orange': " + set.size());
}
}
Output:
Set size: 3
Is ‘apple’ in the set? true
Set size after removing ‘orange’: 2
TreeSet Class
Definition
The TreeSet class in Java implements the SortedSet interface and stores a collection of unique elements in ascending order. It uses a tree data structure for implementation and guarantees a guaranteed log(n) time cost for operations like add, delete, and contain.
Features
1. TreeSet stores only unique elements, and duplicates are not allowed.
2. It maintains the elements in ascending order.
3. TreeSet does not permit null values.
4. It is not thread-safe.
Methods
1. add(E e): Insert the specified element into the TreeSet if it’s not already present.
2. remove(Object o): Deletes the specified element from the TreeSet if it exists.
3. contains(Object o): Determines if the TreeSet contains the specified element, returning true if it does.
4. size(): Returns the total number of elements in the TreeSet.
5. clear(): Removes all the elements from the TreeSet.
Example Implementation:
import java.util.*;
public class SetExample {
public static void main(String[] args) {
SortedSet<Integer> set = new TreeSet<>();
set.add(5);
set.add(2);
set.add(9);
System.out.println("Set size: " + set.size());
System.out.println("First element: " + set.first());
System.out.println("Last element: " + set.last());
set.remove(2);
System.out.println("Set size after removing '2': " + set.size());
}
}
Output:
Set size: 3
First element: 2
Last element: 9
Set size after removing ‘2’: 2
HashMap Class
Definition
HashMap is a class in the Collection Framework that is used to store and manipulate data in a key-value pair format. It implements the Map interface and stores data in a hash table.
Features
1. It allows null values and null keys.
2. It is not thread-safe since it is not synchronized.
3. It has constant-time performance for the basic operations (put and get) on average, assuming the hash function.
4. Distribute the elements properly.
Methods
1. put(K key, V value): inserts the key-value pair into the HashMap
2. get(Object key): provides the value connected to the key
3. remove(Object key): removes the key-value pair associated with the key
4. containsKey(Object key): returns true if the key is present in the HashMap, else false
Example Code:
import java.util.HashMap;
public class HashMapExample {
public static void main(String[] args) {
HashMap<String, Integer> map = new HashMap<>();
map.put("apple", 10);
map.put("banana", 20);
map.put("orange", 30);
System.out.println("Value of key 'apple': " + map.get("apple"));
}
}
Output:
Value of key ‘apple’: 10
TreeMap Class
Definition
TreeMap is a class in the Collection Framework that is used to store and manipulate data in a key-value pair format. It implements the SortedMap interface and stores data in a red-black tree.
Features
It stores the data in a sorted manner based on the natural ordering of the keys or a custom Comparator if specified.
It is not thread-safe since it is not synchronized.
Methods
1. put(K key, V value): inserts the key-value pair into the TreeMap
2. get(Object key): provides the value connected to the key
3. remove(Object key): removes the key-value pair associated with the key
4. firstKey(): returns the first (lowest) key in the TreeMap
5. lastKey(): returns the last (highest) key in the TreeMap
Example code:
import java.util.TreeMap;
public class TreeMapExample {
public static void main(String[] args) {
TreeMap<String, Integer> map = new TreeMap<>();
map.put("FirstCode", 10);
map.put("Google", 20);
map.put("Microsoft", 30);
System.out.println("First key: " + map.firstKey());
}
}
Output:
First key: FirstCode
Algorithms in Collection Framework
The Collection Framework in Java provides various algorithms to manipulate and perform operations on collections of objects. These algorithms are designed to work with different types of collections and provide efficient ways to sort, search, and shuffle the elements.
Sorting Algorithms:
Definition:
Sorting algorithms are used to arrange the elements of a collection in a specific order based on some criteria. Java provides several sorting algorithms that can be used to sort elements in various data structures like arrays and lists.
Types:
Some of the sorting algorithms available in Java are:
1. Bubble Sort
2. Insertion Sort
3. Selection Sort
4. Merge Sort
5. Quick Sort
Here is an example of how to sort an ArrayList of integers using the built-in sorting algorithm in Java:
import java.util.ArrayList;
import java.util.Collections;
public class SortingExample {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(5);
list.add(2);
list.add(9);
System.out.println("Before sorting: " + list);
Collections.sort(list);
System.out.println("After sorting: " + list);
}
}
Output:
Before sorting: [5, 2, 9]
After sorting: [2, 5, 9]
Searching Algorithms:
Definition:
Searching algorithms are used to find the position of a particular element in a collection. Java provides several search algorithms that can be used to search for elements in various data structures like arrays and lists.
Types:
Some of the search algorithms available in Java are:
1. Linear Search
2. Binary Search
Here is an example of how to search for an element in an ArrayList of integers using the built-in searching algorithm in Java:
import java.util.ArrayList;
import java.util.Collections;
public class SearchingExample {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(5);
list.add(2);
list.add(9);
int index = Collections.binarySearch(list, 5);
System.out.println("Index of element 5 is: " + index);
}
}
Output:
The index of element 5 is: -3
Shuffling Algorithms:
Definition:
Shuffling algorithms are used to randomly reorder the elements of a collection. Java provides several shuffling algorithms that can be used to shuffle elements in various data structures like arrays and lists.
Types:
Some of the shuffling algorithms available in Java are:
1. Fisher-Yates Shuffle
2. Collections.shuffle()
Here is an example of how to shuffle an ArrayList of integers using the built-in shuffling algorithm in Java:
import java.util.ArrayList;
import java.util.Collections;
public class ShufflingExample {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(5);
list.add(2);
list.add(9);
System.out.println("Before shuffling: " + list);
Collections.shuffle(list);
System.out.println("After shuffling: " + list);
}
}
Output:
Before shuffling: [5, 2, 9]
After shuffling: [9, 2, 5]
Conclusion
In this article, we explored the Java Collections Framework, which is a collection of interfaces and classes that are used to represent groups of objects. We looked at the different types of collections, such as List, Set, Queue, and Map, and their specific implementations. We also discussed the basic features of each collection and their corresponding methods.
Additionally, we explored the different algorithms available in the Java Collections Framework, such as sorting, searching, and shuffling.
The Java Collections Framework is an essential part of Java programming, and it provides many benefits to developers. Using collections makes it easier to work with groups of objects, and it enables developers to write more efficient and readable code.
The framework also provides many built-in algorithms for sorting, searching, and shuffling collections, which reduces the amount of code that needs to be written. Overall, the Java Collections Framework is a powerful tool for Java developers and is critical for creating robust and efficient Java applications.
The Java Collections Framework is continually evolving, and there is always room for improvement. One area of potential growth is the addition of new collections or data structures that can be used to represent groups of objects more efficiently. Another area for development is the optimization of existing algorithms to make them faster and more efficient.
Additionally, the Java Collections Framework can be integrated with other Java technologies to provide more advanced features and functionality. Overall, the future of collections in Java is exciting, and it will continue to play a critical role in the development of Java applications.