Java Programming Generics In Collections Complete Guide

Step 1: Understanding the Basics of Generics

Generics allow you to define classes, methods, and interfaces that operate on objects of various types while providing compile-time type safety using type parameters.

Step 2: Using Generics with ArrayList

Let's start by creating an ArrayList of integers without using generics and then see how it can be improved by using generics.

Without Generics (Raw Type)

import java.util.ArrayList;
import java.util.List;

public class RawTypeExample {
    public static void main(String[] args) {
        List list = new ArrayList();
        
        // Adding elements
        list.add(1);          // Autoboxing int to Integer
        list.add("Two");      // Added String unintentionally
        
        // Retrieving elements
        int number1 = (Integer) list.get(0); // Works fine
        
        // This will cause ClassCastException because list.get(1) returns a String
        try {
            int number2 = (Integer) list.get(1);
        } catch (ClassCastException e) {
            System.out.println("Caught ClassCastException at index 1: " + e.getMessage());
        }
    }
}

Output:

Caught ClassCastException at index 1: java.lang.String cannot be cast to java.lang.Integer

With Generics

Now, we'll use a generic ArrayList<Integer> to ensure only Integer objects can be added.

import java.util.ArrayList;
import java.util.List;

public class GenericArrayListExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        
        // Adding elements
        list.add(1);         // Autoboxing int to Integer, works fine
        // list.add("Two");   // Compile-time error: incompatible types
        
        // Retrieving elements
        int number1 = list.get(0); // Works fine, no explicit casting needed
        
        // This line would still give a compile-time error if uncommented
        // int number2 = (Integer) list.get(1);
        
        System.out.println("Number at index 0: " + number1);
    }
}

Output:

Number at index 0: 1

Step 3: Using Generics with HashMap

Next, let's create a HashMap that maps String keys to Integer values.

Without Generics

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

public class RawHashMapExample {
    public static void main(String[] args) {
        Map map = new HashMap();
        
        // Adding entries
        map.put("Key1", 1);
        map.put("Key2", 2);
        // map.put(3, "Value3"); // Added incorrect key-value pair
        
        // Retrieving entries
        int value1 = (Integer) map.get("Key1"); // Works fine
        int value2 = (Integer) map.get("Key2"); // Works fine
        
        // This will cause ClassCastException because map.get("incorrect") returns null
        try {
            int value3 = (Integer) map.get("incorrect");
            System.out.println("Incorrect key value: " + value3);
        } catch (NullPointerException e) {
            System.out.println("Caught NullPointerException: " + e.getMessage());
        }
        
        // This will also cause ClassCastException because incorrect key type
        try {
            int value4 = (Integer) map.get(5);
            System.out.println("Incorrect key type value: " + value4);
        } catch (NullPointerException e) {
            System.out.println("Caught NullPointerException: " + e.getMessage());
        }
    }
}

Output:

Caught NullPointerException: null
Caught NullPointerException: null

With Generics

Using HashMap<String, Integer> ensures that only String keys and Integer values are allowed.

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

public class GenericHashMapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        
        // Adding entries
        map.put("Key1", 1);
        map.put("Key2", 2);
        // map.put(3, "Value3"); // Compile-time error: incompatible types
        
        // Retrieving entries
        int value1 = map.get("Key1"); // Works fine, no explicit casting needed
        int value2 = map.get("Key2"); // Works fine, no explicit casting needed
        
        // If key doesn't exist, get method returns null
        Integer value3 = map.get("incorrect"); 
        if (value3 != null) {
            System.out.println("Incorrect key value: " + value3);
        } else {
            System.out.println("Value for 'incorrect' key is null.");
        }
        
        // Adding an incorrect key type will cause a compile-time error
        // int value4 = (Integer) map.get(5);
    }
}

Output:

Value for 'incorrect' key is null.

Step 4: Using Generics with Custom Classes

Let's create a custom class and use it in a generic collection.

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

import java.util.ArrayList;
import java.util.List;

public class CustomClassGenericsExample {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();

        // Adding Person objects
        people.add(new Person("Alice", 30));
        people.add(new Person("Bob", 25));

        // Iterating over the list
        for (Person person : people) {
            System.out.println(person);
        }
    }
}

Output:

Person{name='Alice', age=30}
Person{name='Bob', age=25}

Step 5: Using Wildcards in Generic Collections

Wildcards allow for flexible method signatures by relaxing type constraints. The most commonly used wildcards are ?, ? extends T, and ? super T.

Unbounded Wildcard

This is represented by <?> and matches any type.

import java.util.ArrayList;
import java.util.List;

public class UnboundedWildcardExample {
    public static void printList(List<?> list) {
        for (Object obj : list) {
            System.out.print(obj + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        List<Integer> integerList = new ArrayList<>();
        integerList.add(1);
        integerList.add(2);

        List<String> stringList = new ArrayList<>();
        stringList.add("Hello");
        stringList.add("World");

        printList(integerList); // Output: 1 2
        printList(stringList);  // Output: Hello World
    }
}

Output:

1 2 
Hello World 

Upper Bounded Wildcard

This is represented by <? extends T> and matches any type that is T or a subclass of T.

class Animal {
    public void eat() {
        System.out.println("Animal eats");
    }
}

class Dog extends Animal {
    public void bark() {
        System.out.println("Dog barks");
    }
}

import java.util.ArrayList;
import java.util.List;

public class UpperBoundedWildcardExample {
    public static void printAnimals(List<? extends Animal> animals) {
        for (Animal animal : animals) {
            animal.eat(); // Method on superclass is safe to call
        }
    }

    public static void main(String[] args) {
        List<Dog> dogs = new ArrayList<>();
        dogs.add(new Dog());

        printAnimals(dogs); // Output: Animal eats
    }
}

Output:

Animal eats 

Lower Bounded Wildcard

This is represented by <? super T> and matches any type that is T or a superclass of T.

import java.util.ArrayList;
import java.util.List;

public class LowerBoundedWildcardExample {
    public static void addNumbers(List<? super Integer> numbers) {
        numbers.add(1);
        numbers.add(2);
    }

    public static void main(String[] args) {
        List<Number> numbers = new ArrayList<>();
        addNumbers(numbers);

        for (Number num : numbers) {
            System.out.print(num + " ");
        }
        System.out.println();

        List<Object> objects = new ArrayList<>();
        addNumbers(objects);

        for (Object obj : objects) {
            System.out.print(obj + " ");
        }
        System.out.println();
    }
}

Output: