Generics in Java Collections

Generics enable type-safe operations on collections during compilation. A generic class is defined using the syntax:

access_modifier class ClassName<GenericType> { }

The generic type parameter accepts reference types exclusively; primitive types are not permitted. For example:

List<Integer> numberList = new ArrayList<>();

Generic interfaces follow a similar declaration pattern:

access_modifier interface InterfaceName<GenericType> { }

The primary advantage of generics lies in shifting type incompatibility errors from runtime (ClassCastException) to compile-time detection, eliminating the need for explicit type casting. When adding incompatible elements, the compiler will reject the operation immediately.

Wildcard Usage

When the exact generic type is unknown, the wildcard <?> serves as a placeholder. However, this restricts operations to methods defined in the Object class, preventing access to type-specific functionality.

Underlying Data Structures

Collections rely on several fundamental data structures, each with distinct performance characteristics:

• Stack: Last-In-First-Out (LIFO) structure, analogous to a magazine loader.
• Queue: First-In-First-Out (FIFO) structure, similar to a checkout line.
• Array: Offers rapid random access via indices but suffers from slow insertions and deletions due to fixed size constraints.
• Linked List: Excels at insertions and deletions but provides slower element lookup since it lacks direct indexing.

LinkedList implements the linked list structure, while Vector represents a synchronized, array-based collection.

Set Interface and Element Uniqueness

The Set interface guarantees that stored elements remain unique. When invoking the add() method, the following verification process occurs:

1. The hashCode() method calculates the hash value of the element.
2. If no matching hash exists in the collection, the element is stored.
3. If a matching hash is found, equals() compares the content.
4. Elements with identical content are rejected; differing content is stored.

Built-in Java API classes such as String and Integer already override hashCode() and equals(). Custom classes must implement these methods to function correctly within HashSet.

Predictable Iteration Order with LinkedHashSet

When iteration order must reflect insertion order, LinkedHashSet provides the solution:

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

public class OrderedSetExample {
    public static void main(String[] args) {
        Set<String> fruits = new LinkedHashSet<>();
        fruits.add("mango");
        fruits.add("apple");
        fruits.add("banana");
        fruits.add("cherry");
        
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
    }
}

Output demonstrates the preserved insertion sequence:

mango
apple
banana
cherry