Java Collection Framework Basics

Posted on May 19, 2025 in Computers

Java provides a Collection Framework that includes interfaces and classes to handle collections of objects efficiently.

Interfaces in Java Collections

• Collection<E> (Root interface)
  • List<E> (Ordered, allows duplicates)
    • ArrayList<E> (Dynamic array)
    • LinkedList<E> (Doubly linked list)
    • Vector<E> (Synchronized, like ArrayList)
    • Stack<E> (LIFO structure)
  • Set<E> (No duplicates)
    • HashSet<E> (Unordered, unique elements)
    • LinkedHashSet<E> (Ordered, unique elements)
    • TreeSet<E> (Sorted, unique elements)
  • Queue<E> (FIFO structure)
    • PriorityQueue<E> (Heap-based, priority order)
    • Deque<E> (Double-ended queue)
      • ArrayDeque<E> (Resizable array-based deque)
  • Map<K,V> (Key-value pairs, no duplicate keys)
    • HashMap<K,V> (Unordered, allows null key)
    • LinkedHashMap<K,V> (Maintains insertion order)
    • TreeMap<K,V> (Sorted by key)
    • Hashtable<K,V> (Synchronized, no null keys)

Commonly Used Methods

List Methods (ArrayList, LinkedList, Vector, Stack)

list.add(element);               // Adds element
list.add(index, element);        // Adds element at index
list.remove(index);              // Removes element at index
list.get(index);                 // Gets element at index
list.set(index, element);        // Replaces element at index
list.indexOf(element);           // Returns index of element
list.contains(element);          // Returns true if element exists
list.size();                     // Returns size of list
list.isEmpty();                  // Returns true if list is empty
list.clear();                    // Clears the list

Set Methods (HashSet, LinkedHashSet, TreeSet)

set.add(element);                // Adds element
set.remove(element);             // Removes element
set.contains(element);           // Checks if element exists
set.size();                      // Returns size of set
set.isEmpty();                   // Checks if set is empty
set.clear();                     // Clears the set

Queue Methods (PriorityQueue, Deque, LinkedList)

queue.add(element);              // Adds element to queue
queue.offer(element);            // Adds element (returns false if full)
queue.remove();                  // Removes head element
queue.poll();                    // Retrieves and removes head, returns null if empty
queue.peek();                    // Retrieves head without removal
queue.element();                 // Retrieves head (throws exception if empty)

Deque Methods (ArrayDeque, LinkedList)

deque.addFirst(element);         // Adds element at beginning
deque.addLast(element);          // Adds element at end
deque.removeFirst();             // Removes first element
deque.removeLast();              // Removes last element
deque.getFirst();                // Retrieves first element
deque.getLast();                 // Retrieves last element

Map Methods (HashMap, LinkedHashMap, TreeMap, Hashtable)

map.put(key, value);             // Adds key-value pair
map.get(key);                    // Retrieves value by key
map.remove(key);                 // Removes key-value pair
map.containsKey(key);            // Checks if key exists
map.containsValue(value);        // Checks if value exists
map.size();                      // Returns size of map
map.isEmpty();                   // Checks if map is empty
map.clear();                     // Clears the map
map.keySet();                    // Returns all keys as a set
map.values();                    // Returns all values as a collection
map.entrySet();                  // Returns all key-value pairs as a set

Iterating Over Collections

Using for-each Loop

for (String item : list)
{
    System.out.println(item);
}

Using Iterator

Iterator<String> itr = list.iterator();
while (itr.hasNext())
{
    System.out.println(itr.next());
}

Using Stream API

list.stream().forEach(System.out::println);

Sorting Collections

Collections.sort(list);          // Sorts list in ascending order
Collections.sort(list, Comparator.reverseOrder()); // Descending order
Collections.sort(list, Comparator.comparing(String::length)); // Custom comparator

Utility Methods (Collections Class)

Collections.max(collection);     // Returns max element
Collections.min(collection);     // Returns min element
Collections.reverse(list);       // Reverses list order
Collections.shuffle(list);       // Randomly shuffles list
Collections.fill(list, value);   // Fills list with value
Collections.frequency(list, item); // Counts occurrences
Collections.binarySearch(list, key); // Searches sorted list