Table of Contents

1. Introduction to Generics
2. Generic Class Syntax
3. Type Parameters and Bounds
4. Generic Methods
5. Wildcards
6. Inheritance with Generics
7. Type Erasure
8. Real-World Examples
9. Best Practices

Introduction to Generics

Generics enable types (classes and interfaces) to be parameters when defining classes, interfaces, and methods. This allows for type safety and eliminates the need for casting.

Benefits of Generics

• Type Safety: Compile-time type checking
• Eliminates Casting: No need to cast objects
• Code Reusability: Write once, use with different types
• Better Algorithms: Create generic algorithms that work on collections of different types

Before and After Generics

import java.util.*; public class GenericsIntroduction { // Before Generics (Java 1.4 and earlier) public static void withoutGenerics() { List list = new ArrayList(); // Raw type list.add("Hello"); list.add("World"); list.add(123); // No compile-time error! // Runtime ClassCastException possible String first = (String) list.get(0); // Explicit casting needed // String second = (String) list.get(2); // ClassCastException! } // With Generics (Java 5+) public static void withGenerics() { List<String> list = new ArrayList<>(); // Parameterized type list.add("Hello"); list.add("World"); // list.add(123); // Compile-time error! String first = list.get(0); // No casting needed String second = list.get(1); // Type safety guaranteed } public static void main(String[] args) { withoutGenerics(); withGenerics(); } }

Generic Class Syntax

Basic Generic Class

// Simple generic class with one type parameter public class Box<T> { private T content; public Box() {} // Default constructor public Box(T content) { this.content = content; } // Setter public void setContent(T content) { this.content = content; } // Getter public T getContent() { return content; } // Generic method within generic class public <U> void inspect(U value) { System.out.println("T: " + content.getClass().getName()); System.out.println("U: " + value.getClass().getName()); } @Override public String toString() { return "Box containing: " + content; } } // Using the generic class public class BasicGenericClassDemo { public static void main(String[] args) { // Box for String Box<String> stringBox = new Box<>("Hello Generics"); System.out.println(stringBox); stringBox.inspect(123); // U becomes Integer // Box for Integer Box<Integer> integerBox = new Box<>(42); System.out.println(integerBox); integerBox.inspect("Test"); // U becomes String // Box for custom object Box<Date> dateBox = new Box<>(new Date()); System.out.println(dateBox); } }

Multiple Type Parameters

// Generic class with multiple type parameters public class Pair<K, V> { private K key; private V value; public Pair(K key, V value) { this.key = key; this.value = value; } public K getKey() { return key; } public V getValue() { return value; } public void setKey(K key) { this.key = key; } public void setValue(V value) { this.value = value; } // Static generic method public static <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2) { return p1.getKey().equals(p2.getKey()) && p1.getValue().equals(p2.getValue()); } @Override public String toString() { return "Pair{key=" + key + ", value=" + value + "}"; } } // Using multiple type parameters public class MultipleTypeParamsDemo { public static void main(String[] args) { // String-Integer pair Pair<String, Integer> nameAge = new Pair<>("John", 25); System.out.println(nameAge); // Integer-String pair Pair<Integer, String> idName = new Pair<>(101, "Alice"); System.out.println(idName); // Custom types Pair<String, Date> eventTime = new Pair<>("Meeting", new Date()); System.out.println(eventTime); // Using static generic method Pair<String, Integer> p1 = new Pair<>("A", 1); Pair<String, Integer> p2 = new Pair<>("A", 1); System.out.println("Pairs equal: " + Pair.compare(p1, p2)); } }

Type Parameters and Bounds

Bounded Type Parameters

import java.util.*; // Upper bound - T must be Number or its subclass public class NumberBox<T extends Number> { private T number; public NumberBox(T number) { this.number = number; } public T getNumber() { return number; } // Can safely call Number methods public double getDoubleValue() { return number.doubleValue(); } public int getIntValue() { return number.intValue(); } // Multiple bounds public static <T extends Number & Comparable<T>> T max(T[] array) { if (array == null || array.length == 0) { return null; } T max = array[0]; for (T element : array) { if (element.compareTo(max) > 0) { max = element; } } return max; } } // Interface bound interface Displayable { void display(); } class Product implements Displayable { private String name; public Product(String name) { this.name = name; } @Override public void display() { System.out.println("Product: " + name); } } public class DisplayableBox<T extends Displayable> { private T item; public DisplayableBox(T item) { this.item = item; } public void show() { item.display(); // Can call Displayable methods } } // Bounds demonstration public class BoundsDemo { public static void main(String[] args) { // Valid - Integer extends Number NumberBox<Integer> intBox = new NumberBox<>(42); System.out.println("Double value: " + intBox.getDoubleValue()); // Valid - Double extends Number NumberBox<Double> doubleBox = new NumberBox<>(3.14); System.out.println("Int value: " + doubleBox.getIntValue()); // Invalid - String doesn't extend Number // NumberBox<String> stringBox = new NumberBox<>("Hello"); // Compile error // Using multiple bounds Integer[] numbers = {1, 5, 3, 9, 2}; Integer maxNumber = NumberBox.max(numbers); System.out.println("Max number: " + maxNumber); // Interface bound DisplayableBox<Product> productBox = new DisplayableBox<>(new Product("Laptop")); productBox.show(); } }

Lower Bounds with Wildcards

import java.util.*; public class BoundsWithWildcards { // Upper bounded wildcard - accepts List of any type that is Number or subclass public static double sumOfList(List<? extends Number> list) { double sum = 0.0; for (Number number : list) { sum += number.doubleValue(); } return sum; } // Lower bounded wildcard - accepts List of Integer or supertypes public static void addNumbers(List<? super Integer> list) { for (int i = 1; i <= 5; i++) { list.add(i); } } // Unbounded wildcard - accepts List of any type public static void printList(List<?> list) { for (Object element : list) { System.out.print(element + " "); } System.out.println(); } public static void main(String[] args) { // Upper bound examples List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5); System.out.println("Sum of integers: " + sumOfList(integers)); List<Double> doubles = Arrays.asList(1.1, 2.2, 3.3); System.out.println("Sum of doubles: " + sumOfList(doubles)); // Lower bound examples List<Number> numbers = new ArrayList<>(); addNumbers(numbers); // Number is supertype of Integer System.out.println("Numbers after adding: " + numbers); List<Object> objects = new ArrayList<>(); addNumbers(objects); // Object is supertype of Integer System.out.println("Objects after adding: " + objects); // Unbounded examples List<String> strings = Arrays.asList("A", "B", "C"); printList(strings); printList(integers); } }

Generic Methods

Generic Method Syntax

import java.util.*; public class GenericMethods { // Basic generic method public static <T> T getFirstElement(List<T> list) { if (list == null || list.isEmpty()) { return null; } return list.get(0); } // Generic method with multiple type parameters public static <K, V> void printPair(K key, V value) { System.out.println("Key: " + key + ", Value: " + value); } // Bounded generic method public static <T extends Comparable<T>> T findMax(T[] array) { if (array == null || array.length == 0) { return null; } T max = array[0]; for (T element : array) { if (element.compareTo(max) > 0) { max = element; } } return max; } // Generic method with wildcards public static void processList(List<? extends Number> list) { for (Number number : list) { System.out.println("Processing: " + number); } } // Generic constructor (not common but possible) public static class Container<T> { private T value; // Generic constructor public <U extends T> Container(U value) { this.value = value; } public T getValue() { return value; } } public static void main(String[] args) { // Using generic methods List<String> names = Arrays.asList("Alice", "Bob", "Charlie"); String first = getFirstElement(names); System.out.println("First name: " + first); List<Integer> ages = Arrays.asList(25, 30, 35); Integer firstAge = getFirstElement(ages); System.out.println("First age: " + firstAge); // Multiple type parameters printPair("Name", "John"); printPair(101, "Employee ID"); // Bounded generic method Integer[] numbers = {3, 7, 2, 9, 1}; Integer maxNumber = findMax(numbers); System.out.println("Max number: " + maxNumber); String[] words = {"apple", "banana", "cherry"}; String maxWord = findMax(words); System.out.println("Max word: " + maxWord); // Wildcard method List<Double> doubles = Arrays.asList(1.1, 2.2, 3.3); processList(doubles); } }

Advanced Generic Methods

import java.util.*; public class AdvancedGenericMethods { // Generic method with type inference public static <T> List<T> createList(T... elements) { List<T> list = new ArrayList<>(); for (T element : elements) { list.add(element); } return list; } // Generic method that returns a generic type public static <T> T[] toArray(List<T> list, Class<T> clazz) { @SuppressWarnings("unchecked") T[] array = (T[]) java.lang.reflect.Array.newInstance(clazz, list.size()); return list.toArray(array); } // Recursive generic method public static <T extends Comparable<T>> void bubbleSort(T[] array) { int n = array.length; for (int i = 0; i < n - 1; i++) { for (int j = 0; j < n - i - 1; j++) { if (array[j].compareTo(array[j + 1]) > 0) { // Swap elements T temp = array[j]; array[j] = array[j + 1]; array[j + 1] = temp; } } } } // Generic method with wildcard and bounds public static double sumCollection(Collection<? extends Number> numbers) { return numbers.stream() .mapToDouble(Number::doubleValue) .sum(); } // Generic method that works with any type public static <T> String join(String delimiter, T... elements) { if (elements == null || elements.length == 0) { return ""; } StringBuilder sb = new StringBuilder(); for (int i = 0; i < elements.length; i++) { if (i > 0) { sb.append(delimiter); } sb.append(elements[i]); } return sb.toString(); } public static void main(String[] args) { // Type inference in action List<String> names = createList("Alice", "Bob", "Charlie"); System.out.println("Names: " + names); List<Integer> numbers = createList(1, 2, 3, 4, 5); System.out.println("Numbers: " + numbers); // Convert list to array with proper type String[] nameArray = toArray(names, String.class); System.out.println("Array: " + Arrays.toString(nameArray)); // Bubble sort with generics Integer[] toSort = {5, 2, 8, 1, 9}; bubbleSort(toSort); System.out.println("Sorted: " + Arrays.toString(toSort)); // Sum collection List<Number> mixedNumbers = Arrays.asList(1, 2.5, 3L, 4.7f); double total = sumCollection(mixedNumbers); System.out.println("Total: " + total); // Join any types String result = join(", ", "A", 1, 2.5, true); System.out.println("Joined: " + result); } }

Wildcards

Wildcard Types and Usage

import java.util.*; public class WildcardsDeepDive { // Unbounded wildcard - useful when you don't care about the type public static void printCollection(Collection<?> collection) { for (Object element : collection) { System.out.println(element); } } // Upper bounded wildcard - restricts to specific type hierarchy public static double sumNumbers(List<? extends Number> numbers) { return numbers.stream() .mapToDouble(Number::doubleValue) .sum(); } // Lower bounded wildcard - allows adding specific types public static void addIntegers(List<? super Integer> list) { for (int i = 1; i <= 3; i++) { list.add(i); } } // Wildcard with multiple bounds (not directly supported, but you can use extends with interface) public static void processComparables(List<? extends Comparable<?>> list) { if (!list.isEmpty()) { System.out.println("First element: " + list.get(0)); } } // Complex wildcard scenario public static void copyNumbers(List<? extends Number> source, List<? super Number> destination) { for (Number number : source) { destination.add(number); } } // Wildcard in return type (rare, but possible) public static List<?> createWildcardList() { return Arrays.asList("A", 1, 2.5, true); } public static void main(String[] args) { // Unbounded wildcard examples List<String> strings = Arrays.asList("A", "B", "C"); List<Integer> integers = Arrays.asList(1, 2, 3); printCollection(strings); printCollection(integers); // Upper bounded examples List<Integer> ints = Arrays.asList(1, 2, 3); List<Double> doubles = Arrays.asList(1.1, 2.2, 3.3); System.out.println("Sum ints: " + sumNumbers(ints)); System.out.println("Sum doubles: " + sumNumbers(doubles)); // Lower bounded examples List<Number> numbers = new ArrayList<>(); List<Object> objects = new ArrayList<>(); addIntegers(numbers); addIntegers(objects); System.out.println("Numbers: " + numbers); System.out.println("Objects: " + objects); // Copy between different number types List<Integer> sourceList = Arrays.asList(1, 2, 3); List<Number> destList = new ArrayList<>(); copyNumbers(sourceList, destList); System.out.println("Copied: " + destList); // Wildcard return List<?> wildList = createWildcardList(); printCollection(wildList); } }

Wildcard Guidelines (PECS)

import java.util.*; public class PECSPriciple { /* * PECS: Producer Extends, Consumer Super * - Use <? extends T> for producers (you read from them) * - Use <? super T> for consumers (you write to them) * - Use <?> when you both read and write (but be careful) */ // Producer - uses extends (read-only) public static double sumProducer(List<? extends Number> numbers) { double sum = 0; for (Number num : numbers) { // Reading from producer sum += num.doubleValue(); } return sum; } // Consumer - uses super (write-only) public static void fillConsumer(List<? super Integer> list, int count) { for (int i = 0; i < count; i++) { list.add(i); // Writing to consumer } } // Both producer and consumer - avoid wildcards if possible public static <T> void copy(List<? extends T> source, List<? super T> destination) { for (T item : source) { // Reading from producer destination.add(item); // Writing to consumer } } // Example demonstrating PECS public static class CollectionsUtils { // Producer example - reading elements public static <T> T getFirst(List<? extends T> list) { return list.isEmpty() ? null : list.get(0); } // Consumer example - adding elements public static <T> void addAll(List<? super T> destination, List<? extends T> source) { destination.addAll(source); } // Complex PECS example public static <T> void copyWithFilter(List<? extends T> source, List<? super T> destination, java.util.function.Predicate<? super T> predicate) { for (T element : source) { if (predicate.test(element)) { destination.add(element); } } } } public static void main(String[] args) { // Producer example List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5); double sum = sumProducer(integers); System.out.println("Sum: " + sum); // Consumer example List<Number> numbers = new ArrayList<>(); fillConsumer(numbers, 5); System.out.println("Filled numbers: " + numbers); // Copy with PECS List<Integer> source = Arrays.asList(1, 2, 3, 4, 5); List<Number> destination = new ArrayList<>(); copy(source, destination); System.out.println("Copied: " + destination); // Collections utils examples String first = CollectionsUtils.getFirst(Arrays.asList("A", "B", "C")); System.out.println("First: " + first); List<Object> objects = new ArrayList<>(); CollectionsUtils.addAll(objects, integers); System.out.println("Objects after addAll: " + objects); // Copy with filter List<Integer> evenNumbers = new ArrayList<>(); CollectionsUtils.copyWithFilter(integers, evenNumbers, n -> n % 2 == 0); System.out.println("Even numbers: " + evenNumbers); } }

Inheritance with Generics

Generic Class Inheritance

import java.util.*; // Base generic class public class GenericBase<T> { protected T value; public GenericBase(T value) { this.value = value; } public T getValue() { return value; } public void setValue(T value) { this.value = value; } public void display() { System.out.println("Value: " + value); } } // Option 1: Non-generic subclass with specific type class StringContainer extends GenericBase<String> { public StringContainer(String value) { super(value); } // Additional methods specific to String public int getLength() { return value.length(); } } // Option 2: Generic subclass with same type parameter class EnhancedContainer<T> extends GenericBase<T> { private String description; public EnhancedContainer(T value, String description) { super(value); this.description = description; } public String getDescription() { return description; } @Override public void display() { System.out.println(description + ": " + value); } } // Option 3: Generic subclass with additional type parameters class PairContainer<T, U> extends GenericBase<T> { private U secondValue; public PairContainer(T firstValue, U secondValue) { super(firstValue); this.secondValue = secondValue; } public U getSecondValue() { return secondValue; } public void setSecondValue(U secondValue) { this.secondValue = secondValue; } @Override public void display() { System.out.println("First: " + value + ", Second: " + secondValue); } } // Option 4: Subclass with bounded type parameter class NumberContainer<T extends Number> extends GenericBase<T> { public NumberContainer(T value) { super(value); } public double getDoubleValue() { return value.doubleValue(); } } // Inheritance demonstration public class GenericInheritanceDemo { public static void main(String[] args) { // Non-generic subclass StringContainer stringBox = new StringContainer("Hello"); stringBox.display(); System.out.println("Length: " + stringBox.getLength()); // Generic subclass with same parameter EnhancedContainer<Integer> enhanced = new EnhancedContainer<>(42, "Answer"); enhanced.display(); // Generic subclass with additional parameters PairContainer<String, Integer> pair = new PairContainer<>("Age", 25); pair.display(); // Bounded generic subclass NumberContainer<Double> numberBox = new NumberContainer<>(3.14); numberBox.display(); System.out.println("Double value: " + numberBox.getDoubleValue()); } }

Generic Interface Implementation

import java.util.*; // Generic interface interface Repository<T, ID> { void save(T entity); T findById(ID id); void delete(ID id); List<T> findAll(); } // Generic interface with multiple type parameters interface Mapper<SOURCE, TARGET> { TARGET map(SOURCE source); SOURCE reverseMap(TARGET target); } // Implementing generic interface with specific types class UserRepository implements Repository<User, Long> { private Map<Long, User> database = new HashMap<>(); private long nextId = 1; @Override public void save(User entity) { if (entity.getId() == null) { entity.setId(nextId++); } database.put(entity.getId(), entity); } @Override public User findById(Long id) { return database.get(id); } @Override public void delete(Long id) { database.remove(id); } @Override public List<User> findAll() { return new ArrayList<>(database.values()); } } // Implementing generic interface with generic class class GenericRepository<T, ID> implements Repository<T, ID> { private Map<ID, T> database = new HashMap<>(); @Override public void save(T entity) { // Implementation would need reflection to get ID System.out.println("Saving: " + entity); } @Override public T findById(ID id) { return database.get(id); } @Override public void delete(ID id) { database.remove(id); } @Override public List<T> findAll() { return new ArrayList<>(database.values()); } } // Generic interface implementation with bounds class NumberMapper implements Mapper<Number, String> { @Override public String map(Number source) { return source.toString(); } @Override public Number reverseMap(String target) { try { if (target.contains(".")) { return Double.parseDouble(target); } else { return Long.parseLong(target); } } catch (NumberFormatException e) { return 0; } } } // Supporting class class User { private Long id; private String name; public User(String name) { this.name = name; } public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public String toString() { return "User{id=" + id + ", name='" + name + "'}"; } } // Interface implementation demo public class GenericInterfaceDemo { public static void main(String[] args) { // Specific implementation UserRepository userRepo = new UserRepository(); User user = new User("John Doe"); userRepo.save(user); User found = userRepo.findById(1L); System.out.println("Found user: " + found); // Generic implementation GenericRepository<String, Integer> stringRepo = new GenericRepository<>(); stringRepo.save("Test String"); // Mapper implementation NumberMapper mapper = new NumberMapper(); String mapped = mapper.map(42); System.out.println("Mapped number: " + mapped); Number reversed = mapper.reverseMap("3.14"); System.out.println("Reversed string: " + reversed); } }

Type Erasure

Understanding Type Erasure

import java.util.*; import java.lang.reflect.*; public class TypeErasureDemo { // Generic class that will undergo type erasure public static class ErasureExample<T> { private T value; public ErasureExample(T value) { this.value = value; } public T getValue() { return value; } public void setValue(T value) { this.value = value; } // This method demonstrates bridge methods public void process(List<T> list) { System.out.println("Processing list: " + list); } } // Demonstrating what happens after type erasure public static void demonstrateErasure() { // At compile time, these are different types ErasureExample<String> stringExample = new ErasureExample<>("Hello"); ErasureExample<Integer> integerExample = new ErasureExample<>(42); // But after erasure, both become ErasureExample<Object> System.out.println("String example class: " + stringExample.getClass()); System.out.println("Integer example class: " + integerExample.getClass()); System.out.println("Same class? " + (stringExample.getClass() == integerExample.getClass())); // Reflection shows the raw type Field[] fields = ErasureExample.class.getDeclaredFields(); for (Field field : fields) { System.out.println("Field: " + field.getName() + ", Type: " + field.getType()); } } // Type erasure and method overloading public static class OverloadingIssue { // This won't compile - same erasure // public void process(List<String> list) { } // public void process(List<Integer> list) { } // Workaround: use different method names or parameters public void processStrings(List<String> list) { System.out.println("Processing strings: " + list); } public void processIntegers(List<Integer> list) { System.out.println("Processing integers: " + list); } } // Reifiable types vs non-reifiable types public static void reifiableTypes() { // Reifiable types (type information available at runtime) List<String> strings = new ArrayList<>(); System.out.println("List type: " + strings.getClass()); // Arrays are reifiable String[] stringArray = new String[10]; System.out.println("Array type: " + stringArray.getClass()); // But generic type parameters are erased System.out.println("List generic type: " + strings.getClass().getTypeParameters()); } // Working with type tokens to preserve type information public static class TypeToken<T> { private final Class<T> type; @SuppressWarnings("unchecked") public TypeToken() { this.type = (Class<T>) ((ParameterizedType) getClass() .getGenericSuperclass()).getActualTypeArguments()[0]; } public Class<T> getType() { return type; } } // Using type tokens public static <T> T createInstance(Class<T> clazz) throws Exception { return clazz.getDeclaredConstructor().newInstance(); } public static void main(String[] args) throws Exception { System.out.println("=== Type Erasure Demonstration ==="); demonstrateErasure(); System.out.println("\n=== Reifiable Types ==="); reifiableTypes(); System.out.println("\n=== Type Tokens ==="); TypeToken<String> stringToken = new TypeToken<String>() {}; System.out.println("Type: " + stringToken.getType()); // Create instance using type token String instance = createInstance(String.class); System.out.println("Created instance: " + instance); } }

Overcoming Type Erasure Limitations

import java.util.*; import java.lang.reflect.*; public class OvercomingErasure { // Technique 1: Pass Class<T> as parameter public static class TypeSafeContainer<T> { private T value; private final Class<T> type; public TypeSafeContainer(Class<T> type) { this.type = type; } public TypeSafeContainer(Class<T> type, T value) { this.type = type; this.value = value; } public void setValue(T value) { // Runtime type checking if (value != null && !type.isInstance(value)) { throw new IllegalArgumentException("Invalid type"); } this.value = value; } public T getValue() { return value; } public Class<T> getType() { return type; } // Create array of the specific type @SuppressWarnings("unchecked") public T[] createArray(int size) { return (T[]) Array.newInstance(type, size); } } // Technique 2: Super Type Tokens public abstract class SuperTypeToken<T> { private final Type type; protected SuperTypeToken() { Type superclass = getClass().getGenericSuperclass(); if (superclass instanceof Class) { throw new RuntimeException("Missing type parameter"); } this.type = ((ParameterizedType) superclass).getActualTypeArguments()[0]; } public Type getType() { return type; } } // Technique 3: Type-safe heterogeneous container public static class TypeSafeMap { private Map<Class<?>, Object> map = new HashMap<>(); public <T> void put(Class<T> key, T value) { map.put(key, value); } @SuppressWarnings("unchecked") public <T> T get(Class<T> key) { return (T) map.get(key); } } // Technique 4: Runtime type checking in generic methods public static <T> void checkType(T obj, Class<T> expectedType) { if (obj != null && !expectedType.isInstance(obj)) { throw new ClassCastException("Expected " + expectedType + " but got " + obj.getClass()); } } public static void main(String[] args) { // Technique 1: Using Class<T> TypeSafeContainer<String> stringContainer = new TypeSafeContainer<>(String.class, "Hello"); System.out.println("Container type: " + stringContainer.getType()); System.out.println("Container value: " + stringContainer.getValue()); String[] stringArray = stringContainer.createArray(5); System.out.println("Created array of type: " + stringArray.getClass().getComponentType()); // Technique 3: Type-safe map TypeSafeMap typeMap = new TypeSafeMap(); typeMap.put(String.class, "String value"); typeMap.put(Integer.class, 42); String stringValue = typeMap.get(String.class); Integer intValue = typeMap.get(Integer.class); System.out.println("String value: " + stringValue); System.out.println("Integer value: " + intValue); // Technique 4: Runtime type checking checkType("test", String.class); // checkType(123, String.class); // Throws ClassCastException } }

Real-World Examples

Generic Data Structures

import java.util.*; // Generic Stack implementation public class GenericStack<T> { private List<T> elements; private int top; public GenericStack() { this(10); // Default capacity } public GenericStack(int capacity) { this.elements = new ArrayList<>(capacity); this.top = -1; } public void push(T element) { elements.add(element); top++; } public T pop() { if (isEmpty()) { throw new EmptyStackException(); } T element = elements.get(top); elements.remove(top); top--; return element; } public T peek() { if (isEmpty()) { throw new EmptyStackException(); } return elements.get(top); } public boolean isEmpty() { return top == -1; } public int size() { return top + 1; } public void clear() { elements.clear(); top = -1; } @Override public String toString() { return "Stack: " + elements; } } // Generic Binary Tree implementation public class BinaryTree<T extends Comparable<T>> { private Node<T> root; private static class Node<T> { T data; Node<T> left; Node<T> right; Node(T data) { this.data = data; } } public void insert(T data) { root = insertRec(root, data); } private Node<T> insertRec(Node<T> node, T data) { if (node == null) { return new Node<>(data); } if (data.compareTo(node.data) < 0) { node.left = insertRec(node.left, data); } else if (data.compareTo(node.data) > 0) { node.right = insertRec(node.right, data); } return node; } public boolean contains(T data) { return containsRec(root, data); } private boolean containsRec(Node<T> node, T data) { if (node == null) { return false; } int cmp = data.compareTo(node.data); if (cmp == 0) { return true; } else if (cmp < 0) { return containsRec(node.left, data); } else { return containsRec(node.right, data); } } public List<T> inOrderTraversal() { List<T> result = new ArrayList<>(); inOrderRec(root, result); return result; } private void inOrderRec(Node<T> node, List<T> result) { if (node != null) { inOrderRec(node.left, result); result.add(node.data); inOrderRec(node.right, result); } } } // Generic utility classes public class MathUtils { // Generic method for numerical operations public static <T extends Number & Comparable<T>> T max(T a, T b) { return a.compareTo(b) > 0 ? a : b; } public static <T extends Number> double sum(Collection<T> numbers) { return numbers.stream() .mapToDouble(Number::doubleValue) .sum(); } public static <T extends Number> double average(Collection<T> numbers) { if (numbers.isEmpty()) { return 0.0; } return sum(numbers) / numbers.size(); } } // Real-world usage demonstration public class GenericDataStructuresDemo { public static void main(String[] args) { // Stack demonstration GenericStack<String> stringStack = new GenericStack<>(); stringStack.push("First"); stringStack.push("Second"); stringStack.push("Third"); System.out.println("Stack: " + stringStack); System.out.println("Popped: " + stringStack.pop()); System.out.println("Stack after pop: " + stringStack); // Binary tree demonstration BinaryTree<Integer> tree = new BinaryTree<>(); tree.insert(50); tree.insert(30); tree.insert(70); tree.insert(20); tree.insert(40); tree.insert(60); tree.insert(80); System.out.println("Tree contains 40: " + tree.contains(40)); System.out.println("Tree contains 90: " + tree.contains(90)); System.out.println("In-order traversal: " + tree.inOrderTraversal()); // Math utils demonstration System.out.println("Max of 5 and 10: " + MathUtils.max(5, 10)); System.out.println("Max of 3.14 and 2.71: " + MathUtils.max(3.14, 2.71)); List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); System.out.println("Sum: " + MathUtils.sum(numbers)); System.out.println("Average: " + MathUtils.average(numbers)); } }

Generic Repository Pattern

import java.util.*; import java.util.concurrent.atomic.AtomicLong; // Base entity interface interface Entity<ID> { ID getId(); void setId(ID id); } // Generic repository interface interface GenericRepository<T extends Entity<ID>, ID> { T save(T entity); Optional<T> findById(ID id); List<T> findAll(); void deleteById(ID id); boolean existsById(ID id); long count(); } // In-memory generic repository implementation public class InMemoryRepository<T extends Entity<ID>, ID> implements GenericRepository<T, ID> { private final Map<ID, T> storage = new HashMap<>(); private final AtomicLong sequence = new AtomicLong(1); @Override public T save(T entity) { if (entity.getId() == null) { // Auto-generate ID for Long types if (entity.getId() instanceof Long) { @SuppressWarnings("unchecked") ID newId = (ID) Long.valueOf(sequence.getAndIncrement()); entity.setId(newId); } } storage.put(entity.getId(), entity); return entity; } @Override public Optional<T> findById(ID id) { return Optional.ofNullable(storage.get(id)); } @Override public List<T> findAll() { return new ArrayList<>(storage.values()); } @Override public void deleteById(ID id) { storage.remove(id); } @Override public boolean existsById(ID id) { return storage.containsKey(id); } @Override public long count() { return storage.size(); } // Additional generic methods public List<T> findByPredicate(java.util.function.Predicate<T> predicate) { return storage.values().stream() .filter(predicate) .toList(); } public <R> List<R> map(java.util.function.Function<T, R> mapper) { return storage.values().stream() .map(mapper) .toList(); } } // Concrete entity implementations class User implements Entity<Long> { private Long id; private String username; private String email; public User() {} public User(String username, String email) { this.username = username; this.email = email; } @Override public Long getId() { return id; } @Override public void setId(Long id) { this.id = id; } public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } @Override public String toString() { return String.format("User{id=%d, username='%s', email='%s'}", id, username, email); } } class Product implements Entity<String> { private String sku; // Use SKU as ID private String name; private double price; public Product(String sku, String name, double price) { this.sku = sku; this.name = name; this.price = price; } @Override public String getId() { return sku; } @Override public void setId(String sku) { this.sku = sku; } public String getName() { return name; } public void setName(String name) { this.name = name; } public double getPrice() { return price; } public void setPrice(double price) { this.price = price; } @Override public String toString() { return String.format("Product{sku='%s', name='%s', price=%.2f}", sku, name, price); } } // Repository usage demonstration public class RepositoryPatternDemo { public static void main(String[] args) { // User repository with Long ID InMemoryRepository<User, Long> userRepository = new InMemoryRepository<>(); User user1 = new User("john_doe", "[email protected]"); User user2 = new User("jane_smith", "[email protected]"); userRepository.save(user1); userRepository.save(user2); System.out.println("All users:"); userRepository.findAll().forEach(System.out::println); // Find by ID Optional<User> foundUser = userRepository.findById(1L); foundUser.ifPresent(user -> System.out.println("Found user: " + user)); // Find by predicate List<User> johns = userRepository.findByPredicate( user -> user.getUsername().contains("john")); System.out.println("Users with 'john' in username: " + johns); // Map to usernames List<String> usernames = userRepository.map(User::getUsername); System.out.println("Usernames: " + usernames); // Product repository with String ID InMemoryRepository<Product, String> productRepository = new InMemoryRepository<>(); Product product1 = new Product("SKU001", "Laptop", 999.99); Product product2 = new Product("SKU002", "Mouse", 29.99); productRepository.save(product1); productRepository.save(product2); System.out.println("\nAll products:"); productRepository.findAll().forEach(System.out::println); // Product-specific query List<Product> expensiveProducts = productRepository.findByPredicate( product -> product.getPrice() > 50.0); System.out.println("Expensive products: " + expensiveProducts); } }

Best Practices

Generic Programming Guidelines

import java.util.*; public class GenericBestPractices { // 1. Use descriptive type parameter names public static class Container<ELEMENT> { // Good private ELEMENT value; // ... } public static class Map<KEY, VALUE> { // Good // ... } // Avoid single-letter names unless conventional (T, E, K, V, etc.) // 2. Prefer generic types over raw types public static void preferGenerics() { // Good List<String> strings = new ArrayList<>(); // Bad - raw type @SuppressWarnings("rawtypes") List rawList = new ArrayList(); } // 3. Use bounded wildcards for maximum flexibility public static class FlexibleCollections { // Producer - use extends public static double sumNumbers(Collection<? extends Number> numbers) { return numbers.stream() .mapToDouble(Number::doubleValue) .sum(); } // Consumer - use super public static void addNumbers(Collection<? super Integer> numbers) { numbers.add(1); numbers.add(2); numbers.add(3); } // Neither - use unbounded public static void printAll(Collection<?> collection) { collection.forEach(System.out::println); } } // 4. Avoid using generic types in static contexts public static class StaticContext<T> { // This won't compile - cannot have static field of type T // private static T staticField; // But this is fine - the type parameter is on the method public static <U> U firstElement(List<U> list) { return list.isEmpty() ? null : list.get(0); } } // 5. Use type inference where possible public static void useTypeInference() { // Good - diamond operator List<String> names = new ArrayList<>(); // Good - type inference in methods List<Integer> numbers = Arrays.asList(1, 2, 3); // Good - local variable type inference (Java 10+) var inferredList = new ArrayList<String>(); } // 6. Handle type erasure appropriately public static class ErasureAware<T> { private final Class<T> type; public ErasureAware(Class<T> type) { this.type = type; } @SuppressWarnings("unchecked") public T[] createArray(int size) { return (T[]) java.lang.reflect.Array.newInstance(type, size); } public boolean isInstance(Object obj) { return type.isInstance(obj); } } // 7. Document generic type parameters /** * A generic container that holds a value of specified type. * * @param <T> the type of value held by this container */ public static class DocumentedContainer<T> { private T value; /** * Sets the value held by this container. * * @param value the value to set, must not be null */ public void setValue(T value) { this.value = Objects.requireNonNull(value, "Value cannot be null"); } public T getValue() { return value; } } // 8. Use @SuppressWarnings judiciously @SuppressWarnings("unchecked") public static <T> T[] unsafeCast(Object[] array) { // Only suppress warnings when you're sure it's safe return (T[]) array; } // 9. Consider performance implications public static class PerformanceConsiderations { // Arrays generally have better performance than generic collections // but lack type safety // Use primitive specialized collections when possible public void usePrimitiveCollections() { IntSummaryStatistics stats = Arrays.asList(1, 2, 3, 4, 5) .stream() .mapToInt(Integer::intValue) .summaryStatistics(); System.out.println("Average: " + stats.getAverage()); } } // 10. Test generic code thoroughly public static class GenericTestExamples { public static <T extends Comparable<T>> T max(T a, T b) { return a.compareTo(b) >= 0 ? a : b; } // Test with different types public static void testMax() { assert max(5, 10) == 10; assert max("apple", "banana").equals("banana"); assert max(3.14, 2.71) == 3.14; } } public static void main(String[] args) { // Demonstrate best practices FlexibleCollections.addNumbers(new ArrayList<Number>()); List<Number> numbers = Arrays.asList(1, 2.5, 3L); double sum = FlexibleCollections.sumNumbers(numbers); System.out.println("Sum: " + sum); // Type erasure awareness ErasureAware<String> aware = new ErasureAware<>(String.class); String[] array = aware.createArray(5); System.out.println("Array type: " + array.getClass().getComponentType()); // Performance considerations new PerformanceConsiderations().usePrimitiveCollections(); // Testing GenericTestExamples.testMax(); } }

Common Generic Patterns

import java.util.*; import java.util.function.*; public class CommonGenericPatterns { // Pattern 1: Builder pattern with generics public static class GenericBuilder<T> { private final Supplier<T> instantiator; private List<Consumer<T>> modifiers = new ArrayList<>(); public GenericBuilder(Supplier<T> instantiator) { this.instantiator = instantiator; } public static <T> GenericBuilder<T> of(Supplier<T> instantiator) { return new GenericBuilder<>(instantiator); } public <U> GenericBuilder<T> with(BiConsumer<T, U> consumer, U value) { Consumer<T> c = instance -> consumer.accept(instance, value); modifiers.add(c); return this; } public T build() { T value = instantiator.get(); modifiers.forEach(modifier -> modifier.accept(value)); modifiers.clear(); return value; } } // Pattern 2: Factory pattern with generics public interface Factory<T> { T create(); } public static class GenericFactory { private static final Map<Class<?>, Factory<?>> factories = new HashMap<>(); public static <T> void registerFactory(Class<T> type, Factory<T> factory) { factories.put(type, factory); } @SuppressWarnings("unchecked") public static <T> T create(Class<T> type) { Factory<T> factory = (Factory<T>) factories.get(type); if (factory == null) { throw new IllegalArgumentException("No factory registered for " + type); } return factory.create(); } } // Pattern 3: Strategy pattern with generics public interface ValidationStrategy<T> { boolean isValid(T value); } public static class Validator<T> { private final List<ValidationStrategy<T>> strategies = new ArrayList<>(); public Validator<T> addStrategy(ValidationStrategy<T> strategy) { strategies.add(strategy); return this; } public boolean validate(T value) { return strategies.stream().allMatch(strategy -> strategy.isValid(value)); } } // Pattern 4: Repository pattern (as shown earlier) // Pattern 5: Wrapper/Decorator pattern with generics public static class Decorator<T> { private final T wrapped; private final List<Function<T, T>> decorators = new ArrayList<>(); public Decorator(T wrapped) { this.wrapped = wrapped; } public Decorator<T> with(Function<T, T> decorator) { decorators.add(decorator); return this; } public T decorate() { T result = wrapped; for (Function<T, T> decorator : decorators) { result = decorator.apply(result); } return result; } } // Example usage classes public static class Person { private String name; private int age; public Person() {} public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return String.format("Person{name='%s', age=%d}", name, age); } } public static class Product { private String name; private double price; public Product() {} public String getName() { return name; } public void setName(String name) { this.name = name; } public double getPrice() { return price; } public void setPrice(double price) { this.price = price; } @Override public String toString() { return String.format("Product{name='%s', price=%.2f}", name, price); } } // Pattern demonstration public static void main(String[] args) { // Builder pattern Person person = GenericBuilder.of(Person::new) .with(Person::setName, "John Doe") .with(Person::setAge, 30) .build(); System.out.println("Built person: " + person); // Factory pattern GenericFactory.registerFactory(String.class, () -> "Default String"); GenericFactory.registerFactory(Integer.class, () -> 42); String str = GenericFactory.create(String.class); Integer num = GenericFactory.create(Integer.class); System.out.println("Factory created: " + str + ", " + num); // Strategy pattern Validator<String> emailValidator = new Validator<String>() .addStrategy(s -> s.contains("@")) .addStrategy(s -> s.length() > 5); System.out.println("Valid email? " + emailValidator.validate("[email protected]")); System.out.println("Invalid email? " + emailValidator.validate("test")); // Decorator pattern String original = "hello"; String decorated = new Decorator<>(original) .with(String::toUpperCase) .with(s -> s + "!") .with(s -> "*** " + s + " ***") .decorate(); System.out.println("Decorated: " + decorated); } }

Summary

Key Points:

1. Generics provide type safety and eliminate casting
2. Use bounded type parameters (<T extends Class>) for constraints
3. Follow PECS principle: Producer Extends, Consumer Super
4. Type erasure removes generic type information at runtime
5. Wildcards provide flexibility in method signatures

Common Type Parameter Conventions:

• T - Type
• E - Element (collections)
• K - Key (maps)
• V - Value (maps)
• N - Number
• S, U, V - Additional types

When to Use Generics:

• Creating reusable data structures
• Implementing type-safe collections
• Building flexible APIs
• Writing type-safe algorithms

Generics are a powerful feature that, when used properly, can significantly improve code quality, type safety, and reusability while reducing boilerplate code and runtime errors.