Introduced in Java 5, generics eliminate most explicit type casting, improve code reuse, and detect type-related errors during compilation rather than at runtime.
Why Generics?
Before generics, collections stored elements asObject.
List list = new ArrayList();
list.add("Java");
list.add(100);
String language = (String) list.get(0);1. It requires explicit type casting.
2. Type mismatches are detected only at runtime.
Generics solve both issues.
List<String> languages = new ArrayList<>();
languages.add("Java");
String language = languages.get(0);Generic Classes
A class becomes generic by declaring one or more type parameters.class Box<T> {
private T value;
public void set(T value) {
this.value = value;
}
public T get() {
return value;
}
}Box<String> box = new Box<>();
box.set("Java");
String value = box.get();Generic Interfaces
Interfaces may also declare type parameters.interface Repository<T> {
void save(T entity);
T findById(long id);
}class EmployeeRepository
implements Repository<Employee> {
@Override
public void save(Employee employee) {
}
@Override
public Employee findById(long id) {
return null;
}
}Generic Methods
Individual methods can declare their own type parameters.public class Utility {
public static <T> void print(T value) {
System.out.println(value);
}
}Utility.print("Java");
Utility.print(100);
Utility.print(true);Multiple Type Parameters
A generic declaration may define multiple type parameters.class Pair<K, V> {
private K key;
private V value;
public Pair(K key, V value) {
this.key = key;
this.value = value;
}
}Pair<Integer, String> pair =
new Pair<>(1, "John");Type Inference
The compiler can infer generic types.List<String> names = new ArrayList<>();Bounded Type Parameters
A type parameter may restrict acceptable types.class Calculator<T extends Number> {
public double square(T value) {
return value.doubleValue()
* value.doubleValue();
}
}Number are permitted.
Calculator<Integer> calculator =
new Calculator<>();Calculator<String> calculator =
new Calculator<>();Multiple Bounds
A generic type may define multiple bounds.class Processor<
T extends Number & Comparable<T>> {
}Wildcards
Wildcards provide flexibility when working with generic types. Java supports three wildcard forms.- Unbounded Wildcards
- Upper-Bounded Wildcards
- Lower-Bounded Wildcards
Unbounded Wildcards
The ? wildcard represents an unknown type.public void print(List<?> list) {
for (Object value : list) {
System.out.println(value);
}
}print(List.of(1, 2, 3));
print(List.of("Java"));null.
Upper-Bounded Wildcards
Upper bounds restrict types to a superclass.public double sum(List<? extends Number> numbers) {
double total = 0;
for (Number number : numbers) {
total += number.doubleValue();
}
return total;
}List<Integer>
List<Double>
List<Float>Lower-Bounded Wildcards
Lower bounds specify a superclass.public void addNumbers(
List<? super Integer> numbers) {
numbers.add(10);
numbers.add(20);
}List<Integer>
List<Number>
List<Object>PECS Principle
The most important wildcard guideline is PECS.- Producer Extends
- Consumer Super
- If a collection produces data, use
? extends T.- If a collection consumes data, use
? super T.
void read(List<? extends Number> list)
void write(List<? super Integer> list)Generic Arrays
Java does not allow direct creation of generic arrays. The following is illegal.T[] array = new T[10];new List<String>[10];Type Erasure
Java implements generics using Type Erasure. Generic type information exists only during compilation. The compiler replaces type parameters with their bounds.class Box<T> {
T value;
}class Box {
Object value;
}Restrictions of Generics
Generic type parameters cannot use primitive types.List<int> numbers;List<Integer> numbers;class MyException<T> extends Exception {
}class Box<T> {
static T value;
}Raw Types
A generic class without specifying type arguments becomes a raw type.List list = new ArrayList();Generic Constructors
Constructors may declare their own type parameters.class Box<T> {
<U> Box(U value) {
System.out.println(value);
}
}Generic Records
Records also support generics.public record Pair<K, V>(K key, V value) {
}Generic Functional Interfaces
Functional interfaces commonly use generics.Predicate<String>
Function<Integer, String>
Supplier<Employee>
Consumer<String>Collections and Generics
The Collections Framework makes extensive use of generics.List<String>
Set<Employee>
Map<Integer, Employee>
Queue<Order>Generic Utility Methods
The Java Collections Framework provides many generic methods.Collections.sort(list);
Collections.max(list);
Collections.min(list);
Collections.binarySearch(list, value);Best Practices
Use generics instead of raw types whenever possible.Prefer generic interfaces over concrete implementations, use meaningful type parameter names, avoid unnecessary wildcards, follow the PECS principle, and leverage type inference with the diamond operator.
Understanding type erasure and wildcard bounds is essential for designing flexible, reusable APIs.
Final Notes
Generics bring compile-time type safety, eliminate unnecessary casting, and enable reusable classes, interfaces, and methods.Mastering bounded type parameters, wildcard usage, the PECS principle, type inference, raw types, and type erasure is fundamental for understanding the Java Collections Framework and designing robust, type-safe APIs.
