Java Collections Framework

The Java Collection Framework provides a structured way to manage groups of objects using a
variety of data structures. Key components include interfaces like Collection, List, Set, Queue, and
Map, and classes like ArrayList, LinkedList, HashSet, HashMap, and others. These structures allow
for efficient data manipulation, storage, and retrieval based on specific needs such as ordered,
unordered, or sorted data.

Collection Interfaces

• Collection: This is the root interface for most collection classes.

• List: An ordered collection that allows duplicate elements. Common implementations include
ArrayList, LinkedList, Vector, and Stack.

o ArrayList: A resizable array implementation, providing fast random access but slower
insertions and deletions in the middle.

o LinkedList: A doubly-linked list, suitable for frequent insertions and deletions but
slower for random access.

o Vector: A synchronized, thread-safe version of ArrayList.

o Stack: A last-in, first-out (LIFO) stack of objects.

• Set: A collection that does not allow duplicate elements.

o HashSet: Does not maintain order and allows null elements.

o LinkedHashSet: Maintains insertion order.

o TreeSet: Stores elements in a sorted order.

• Queue: A collection used to hold multiple elements prior to processing.

• Map: A collection that maps keys to values, with no duplicate keys allowed.

o HashMap: Based on a hash table, allowing one null key and multiple null values.

o LinkedHashMap: Maintains insertion order.

o TreeMap: Sorted according to the natural order of its keys.

Basic Operations

The Java Collection Framework provides several basic operations that can be performed on lists, sets,
and maps. These include:

• Adding Elements:

o add(element): Adds an element to the collection.

o add(index, element): Adds an element at a specific position in a list.

• Removing Elements:
 o remove(element): Removes the specified element from the collection.

o remove(index): Removes the element at a specific position in a list.

o clear(): Removes all elements from the collection.

• Accessing Elements:

o get(index): Returns the element at the specified position in a list.

o contains(element): Checks if the collection contains the specified element.

o size(): Returns the number of elements in the collection.

• Iterating over Elements:

o For loop: Can iterate through a list using a basic for loop, using the index.

o Enhanced for loop: Iterates through all elements in any collection.

o Iterator: Provides a way to traverse elements and allows for element removal during
iteration.

Bulk Operations

Bulk operations act on multiple elements at once and include:

• addAll(): Adds all elements from one collection to another.

• removeAll(): Removes all elements in the current collection that are present in the specified
collection.

• retainAll(): Retains only the elements in the current collection that are also in the specified
collection.

• containsAll(): Checks if the current collection contains all elements from the specified
collection.

• toArray(): Converts the collection into an array.

• equals(): Checks if two collections are equal.

Iteration

Iteration is accessing each element of a collection one by one. Different ways to iterate include:

• Basic for loop: Mainly for lists, using an index.

• Enhanced for loop: Simple way to iterate over collections and arrays.

• Iterator: Traverses a collection sequentially and allows safe element removal.

• ListIterator: Extends Iterator for lists, allowing bidirectional traversal.

• forEach(): Introduced in Java 8, uses a lambda expression to iterate.

• Iterating over a Map: Uses entrySet(), keySet(), or values() to iterate over key-value pairs,
keys, or values, respectively.

Lists
Lists are ordered collections that allow duplicate elements.

• Characteristics: Ordered, allows duplicates, positional access.

• Implementations: ArrayList, LinkedList, and Vector.

• Basic Operations:

o Adding: add(E element) adds to the end, add(int index, E element) adds at a specific
index.

o Accessing: get(int index) retrieves an element at a specific index.

o Updating: set(int index, E element) replaces an element at a specific index.

o Removing: remove(int index) removes at an index, remove(Object o) removes the

o Checking Size: size() returns the number of elements in the list.

o Checking for Element: contains(Object o) returns true if the list contains the
element.

• Iteration: Using for loop, enhanced for loop, iterator, and forEach.

• Sorting: Use Collections.sort() to sort a list.

ArrayList vs LinkedList

The primary difference between ArrayList and LinkedList is their underlying data structure and
performance characteristics.

• ArrayList:

o Uses a dynamic array.

o Requires contiguous memory.

o Fast random access, slower insertions/deletions in the middle.

o Simple implementation.

o Faster iteration.

• LinkedList:

o Uses a doubly linked list.

o Nodes can be scattered in memory.

o Fast insertions/deletions, slower access.

o More complex implementation.

o Slower iteration.

• Thread Safety: Both are not thread-safe; use Collections.synchronizedList() or

Sets
Sets are collections that do not allow duplicate elements.

• Characteristics: Uniqueness, unordered, dynamic size.

• Implementations: HashSet, LinkedHashSet, and TreeSet.

• Basic Operations:

o Adding: add(E e) adds an element.

o Removing: remove(Object o) removes a specified element.

o Checking for Elements: contains(Object o) returns true if set contains the specified
element.

o Getting the Size: size() returns the number of elements.

• Iteration: Using enhanced for loop, iterator, and forEach.

• Set Operations: union, intersection, difference using addAll(), retainAll(), and removeAll()
respectively.

Maps

Maps are collections of key-value pairs. Each key is associated with one value, and duplicate keys are
not allowed.

• Characteristics: Key-value pairs, unique keys, dynamic size.

• Implementations: HashMap, LinkedHashMap, TreeMap, and Hashtable.

• Basic Operations:

o Adding: put(K key, V value) adds a key-value pair, updating the value if the key exists.

o Accessing: get(Object key) retrieves the value associated with the key.

o Removing: remove(Object key) removes the key-value pair associated with the key.

o Checking for Key/Value: containsKey(Object key) checks for key existence,

o Getting the Size: size() returns number of key-value pairs.

o Iteration: Uses entrySet(), keySet(), or values().

• Map Operations: merging, replacing values, and bulk operations.

HashMap vs LinkedHashMap vs TreeMap

The main differences lie in their underlying data structures, element order, and performance.

• HashMap:

o Uses a hash table.

o No guaranteed order.

o O(1) average time complexity for insertion, access, and removal.

o Best for fast access when order does not matter.

• LinkedHashMap:

o Extends HashMap, maintains insertion order.

o O(1) average time complexity for insertion, access, and removal.

o Allows one null key and multiple null values.

o Useful when order of iteration matters.

• TreeMap:

o Uses a red-black tree, storing keys in a sorted order.

o O(log n) time complexity for insertion, access, and removal.

o Does not allow null keys, allows multiple null values.

o Ideal for scenarios where sorted order is needed.

• Synchronization: None of these maps are synchronized. For thread safety, you can use
Collections.synchronizedMap() or ConcurrentHashMap.

Generics in Java

Generics allow you to write code that can operate on objects of various types while providing
compile-time type safety, reducing runtime errors and eliminating the need for casting.

• Why Use Generics?

o Type Safety: Avoids ClassCastException.

o Code Reusability: Write more general and reusable code.

o Elimination of Casts: Reduces the need for casting.

• Generic Class Example

o A generic class uses a type parameter such as <T>.

• Generic Method Example

o A generic method can handle any data type.

• Bounded Types: You can restrict the types used as arguments in a generic class or method
with the extends keyword.

• Generic Types:

o Generic Classes: Defined with <T> after the class name.

o Generic Methods: Defined with <T> before the return type.

o Bounded Type Parameters: Restrict the types used in generics.

▪ Unbounded Wildcard: <?> represents any type.

▪ Upper Bounded Wildcard: <? extends T> represents any subtype of T.

▪ Lower Bounded Wildcard: <? super T> represents any supertype of T.

• Parameterized Types: Using generics where a type is passed as a parameter.

o Parameterized types enhance type safety, improve code reusability and readability.

o Can be used in classes, methods, and collections.

o Can be bounded using extends keyword.

• Wildcards: Increase code flexibility and maintain type safety.

o Unbounded Wildcard: Use <?> when the exact type is unknown or irrelevant.

o Upper Bounded Wildcard: Use <? extends T> when reading from a structure.

o Lower Bounded Wildcard: Use <? super T> when adding elements to a structure.

Lambda Expressions

Lambda expressions are anonymous functions that enable more concise code, especially with
functional interfaces and the Java Streams API.

• What is a Lambda Expression?

o An anonymous function treated as a single method interface instance.

o Consists of parameters, arrow token (->), and body.

• Why Use Lambda Expressions?

o Conciseness: Reduces boilerplate code.

o Readability: Makes code more expressive.

o Functional Programming: Supports map, filter, and reduce.

o Enhanced APIs: Simplifies the use of Java Streams.

• Functional Interfaces: An interface with exactly one abstract method.

• Lambda Type Inference: The compiler can automatically deduce the types of parameters or
return values in a lambda expression based on the functional interface.

• Lambda Parameters:

o No Parameters: Empty parentheses ().

o Single Parameter: Parentheses optional parameter or (parameter).

o Multiple Parameters: Enclosed in parentheses (parameter1, parameter2).

o Explicit Types: Types can be explicitly declared (int a, int b).

o Single Expression Body: Implicitly returns the result of a single expression.

o Block Body: Multiple statements enclosed in curly braces, with a return statement if
needed.

o Returning Values: Implicit return for single expression; explicit return for block
bodies.

• Lambdas as Objects: Lambdas are treated as instances of functional interfaces and can be
assigned to variables, passed as arguments, or returned from methods.

This overview covers the major aspects of the Java Collection Framework, including data structures,
operations, generics, and lambda expressions, as described in the sources.