Java Collections Framework – Part 2: HashSet, LinkedHashSet, TreeSet, HashMap, LinkedHashMap, TreeMap

In Part 1, we covered ArrayList, LinkedList, Queue, Stack, and Deque. Now, in Part 2, we’ll explore HashSet, LinkedHashSet, TreeSet, HashMap, LinkedHashMap, and TreeMap, ensuring we cover all their methods with explanations and examples. 1. HashSet in Java A HashSet is an unordered collection that does not allow duplicate elements. It is implemented using a HashMap internally. Declaration and Initialization import java.util.HashSet; import java.util.Set; Set set = new HashSet(); Methods of HashSet Method Description add(E e) Adds an element to the set. remove(Object o) Removes an element if present. contains(Object o) Checks if an element exists. size() Returns the number of elements. clear() Removes all elements. isEmpty() Checks if the set is empty. toArray() Converts the set to an array. retainAll(Collection c) Retains only elements also present in another collection. removeAll(Collection c) Removes all elements present in another collection. Example: import java.util.HashSet; public class HashSetExample { public static void main(String[] args) { HashSet set = new HashSet(); set.add("Apple"); set.add("Banana"); set.add("Cherry"); set.add("Banana"); // Duplicate, ignored System.out.println(set.contains("Apple")); // true set.remove("Banana"); System.out.println(set); // [Apple, Cherry] (unordered) } } 2. LinkedHashSet in Java A LinkedHashSet maintains the insertion order while ensuring uniqueness. Declaration and Initialization import java.util.LinkedHashSet; import java.util.Set; Set linkedHashSet = new LinkedHashSet(); Methods of LinkedHashSet (Same as HashSet, but maintains insertion order) Example: import java.util.LinkedHashSet; public class LinkedHashSetExample { public static void main(String[] args) { LinkedHashSet numbers = new LinkedHashSet(); numbers.add(10); numbers.add(20); numbers.add(30); numbers.add(20); // Duplicate ignored System.out.println(numbers); // [10, 20, 30] (maintains order) } } 3. TreeSet in Java A TreeSet stores elements in sorted order using a Red-Black Tree. Declaration and Initialization import java.util.TreeSet; import java.util.Set; Set treeSet = new TreeSet(); Methods of TreeSet Method Description add(E e) Adds an element while maintaining sorting. remove(Object o) Removes an element if present. contains(Object o) Checks if an element exists. size() Returns the number of elements. clear() Removes all elements. isEmpty() Checks if the set is empty. first() Returns the first (smallest) element. last() Returns the last (largest) element. higher(E e) Returns the smallest element greater than e. lower(E e) Returns the largest element smaller than e. subSet(E from, E to) Returns a subset in range [from, to). Example: import java.util.TreeSet; public class TreeSetExample { public static void main(String[] args) { TreeSet sortedSet = new TreeSet(); sortedSet.add(50); sortedSet.add(10); sortedSet.add(30); System.out.println(sortedSet); // [10, 30, 50] (sorted) System.out.println(sortedSet.first()); // 10 System.out.println(sortedSet.last()); // 50 } } 4. HashMap in Java A HashMap stores key-value pairs in an unordered fashion. Declaration and Initialization import java.util.HashMap; import java.util.Map; Map map = new HashMap(); Methods of HashMap Method Description put(K key, V value) Inserts a key-value pair. get(Object key) Retrieves value for the given key. remove(Object key) Removes a key-value pair. containsKey(Object key) Checks if a key exists. containsValue(Object value) Checks if a value exists. size() Returns the number of elements. isEmpty() Checks if the map is empty. keySet() Returns a set of keys. values() Returns a collection of values. entrySet() Returns a set of key-value pairs. Example: import java.util.HashMap; public class HashMapExample { public static void main(String[] args) { HashMap studentMarks = new HashMap(); studentMarks.put("Alice", 85); studentMarks.put("Bob", 90); studentMarks.put("Charlie", 80); System.out.println(studentMarks.get("Alice")); // 85 studentMarks.remove("Charlie"); System.out.println(studentMarks); // {Alice=85, Bob=90} } } 5. LinkedHashMap in Java A LinkedHashMap maintains insertion order while storing key-value pairs. Declaration and Initialization import java.util.LinkedHashMap; import java.util.Map; Map linkedMap = new LinkedHashMap(); Methods of LinkedHashMap (Same as H

Mar 26, 2025 - 19:16

Java Collections Framework – Part 2: HashSet, LinkedHashSet, TreeSet, HashMap, LinkedHashMap, TreeMap

In Part 1, we covered ArrayList, LinkedList, Queue, Stack, and Deque. Now, in Part 2, we’ll explore HashSet, LinkedHashSet, TreeSet, HashMap, LinkedHashMap, and TreeMap, ensuring we cover all their methods with explanations and examples.

1. HashSet in Java

A HashSet is an unordered collection that does not allow duplicate elements. It is implemented using a HashMap internally.

Declaration and Initialization

import java.util.HashSet;
import java.util.Set;

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

Methods of HashSet

Method	Description
`add(E e)`	Adds an element to the set.
`remove(Object o)`	Removes an element if present.
`contains(Object o)`	Checks if an element exists.
`size()`	Returns the number of elements.
`clear()`	Removes all elements.
`isEmpty()`	Checks if the set is empty.
`toArray()`	Converts the set to an array.
`retainAll(Collection c)`	Retains only elements also present in another collection.
`removeAll(Collection c)`	Removes all elements present in another collection.

Example:

import java.util.HashSet;

public class HashSetExample {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Cherry");
        set.add("Banana"); // Duplicate, ignored

        System.out.println(set.contains("Apple")); // true
        set.remove("Banana");

        System.out.println(set); // [Apple, Cherry] (unordered)
    }
}

2. LinkedHashSet in Java

A LinkedHashSet maintains the insertion order while ensuring uniqueness.

Declaration and Initialization

import java.util.LinkedHashSet;
import java.util.Set;

Set<String> linkedHashSet = new LinkedHashSet<>();

Methods of LinkedHashSet

(Same as HashSet, but maintains insertion order)

Example:

import java.util.LinkedHashSet;

public class LinkedHashSetExample {
    public static void main(String[] args) {
        LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);
        numbers.add(20); // Duplicate ignored

        System.out.println(numbers); // [10, 20, 30] (maintains order)
    }
}

3. TreeSet in Java

A TreeSet stores elements in sorted order using a Red-Black Tree.

Declaration and Initialization

import java.util.TreeSet;
import java.util.Set;

Set<Integer> treeSet = new TreeSet<>();

Methods of TreeSet

Method	Description
`add(E e)`	Adds an element while maintaining sorting.
`remove(Object o)`	Removes an element if present.
`contains(Object o)`	Checks if an element exists.
`size()`	Returns the number of elements.
`clear()`	Removes all elements.
`isEmpty()`	Checks if the set is empty.
`first()`	Returns the first (smallest) element.
`last()`	Returns the last (largest) element.
`higher(E e)`	Returns the smallest element greater than `e`.
`lower(E e)`	Returns the largest element smaller than `e`.
`subSet(E from, E to)`	Returns a subset in range `[from, to)`.

Example:

import java.util.TreeSet;

public class TreeSetExample {
    public static void main(String[] args) {
        TreeSet<Integer> sortedSet = new TreeSet<>();
        sortedSet.add(50);
        sortedSet.add(10);
        sortedSet.add(30);

        System.out.println(sortedSet); // [10, 30, 50] (sorted)
        System.out.println(sortedSet.first()); // 10
        System.out.println(sortedSet.last()); // 50
    }
}

4. HashMap in Java

A HashMap stores key-value pairs in an unordered fashion.

Declaration and Initialization

import java.util.HashMap;
import java.util.Map;

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

Methods of HashMap

Method	Description
`put(K key, V value)`	Inserts a key-value pair.
`get(Object key)`	Retrieves value for the given key.
`remove(Object key)`	Removes a key-value pair.
`containsKey(Object key)`	Checks if a key exists.
`containsValue(Object value)`	Checks if a value exists.
`size()`	Returns the number of elements.
`isEmpty()`	Checks if the map is empty.
`keySet()`	Returns a set of keys.
`values()`	Returns a collection of values.
`entrySet()`	Returns a set of key-value pairs.

Example:

import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        HashMap<String, Integer> studentMarks = new HashMap<>();
        studentMarks.put("Alice", 85);
        studentMarks.put("Bob", 90);
        studentMarks.put("Charlie", 80);

        System.out.println(studentMarks.get("Alice")); // 85
        studentMarks.remove("Charlie");

        System.out.println(studentMarks); // {Alice=85, Bob=90}
    }
}

5. LinkedHashMap in Java

A LinkedHashMap maintains insertion order while storing key-value pairs.

Declaration and Initialization

import java.util.LinkedHashMap;
import java.util.Map;

Map<String, Integer> linkedMap = new LinkedHashMap<>();

Methods of LinkedHashMap

(Same as HashMap, but maintains insertion order)

Example:

import java.util.LinkedHashMap;

public class LinkedHashMapExample {
    public static void main(String[] args) {
        LinkedHashMap<String, Integer> linkedMap = new LinkedHashMap<>();
        linkedMap.put("A", 100);
        linkedMap.put("B", 200);
        linkedMap.put("C", 300);

        System.out.println(linkedMap); // {A=100, B=200, C=300} (order maintained)
    }
}

6. TreeMap in Java

A TreeMap stores key-value pairs in sorted order based on keys.

Declaration and Initialization

import java.util.TreeMap;
import java.util.Map;

Map<Integer, String> treeMap = new TreeMap<>();

Methods of TreeMap

Method	Description
`put(K key, V value)`	Inserts a key-value pair while maintaining sorting.
`get(Object key)`	Retrieves value for the given key.
`remove(Object key)`	Removes a key-value pair.
`containsKey(Object key)`	Checks if a key exists.
`firstKey()`	Returns the first (smallest) key.
`lastKey()`	Returns the last (largest) key.
`higherKey(K key)`	Returns the smallest key greater than `key`.
`lowerKey(K key)`	Returns the largest key smaller than `key`.

Example:

import java.util.TreeMap;

public class TreeMapExample {
    public static void main(String[] args) {
        TreeMap<Integer, String> sortedMap = new TreeMap<>();
        sortedMap.put(3, "Three");
        sortedMap.put(1, "One");
        sortedMap.put(2, "Two");

        System.out.println(sortedMap); // {1=One, 2=Two, 3=Three} (sorted by keys)
    }
}