Generics in Java provide compile-time type checking, allowing collection classes to enforce homogeneous element types and eliminating the need for explicit casting and potential ClassCastException risks at runtime.

Declaring Parameterized Collections

The diamond operator (<>) enibles you to specify the element type when instantiating collection interfaces:

List<String> usernames = new ArrayList<>();
Set<Integer> priorityLevels = new HashSet<>();
Map<String, LocalDate> projectDeadlines = new HashMap<>();

Generic Methods

Collection utilities leverage type parameters for type-safe operations. Consider sorting a typed list:

List<Double> measurements = new ArrayList<>(List.of(3.14, 2.71, 1.41));
measurements.sort(Comparator.naturalOrder());

Wildcard Types

Wildcards provide flexibility when designing APIs that work with unknown or bounded types:

• Unbounded: Collection<?> accepts any instantiation (read-only effective)
• Upper bounded: List<? extends Number> accepts Integer, Double, etc.
• Lower bounded: List<? super Integer> accepts List<Integer>, List<Number>, or List<Object>

Complex Generic Structures

You can nest generic parameters to model complex relationships:

Map<String, List<UUID>> departmentEmployees = new HashMap<>();
departmentEmployees.put("engineering", Arrays.asList(UUID.randomUUID(), UUID.randomUUID()));

Runtime Type Erasure

Generic type parameters exist only at compile time. The JVM erases them to their bound or Object, maintaining backward compatibility with pre-generics code:

List<String> tags = new ArrayList<>();
tags.add("urgent");

// At runtime, the type parameter is unavailable
Class<?> actualClass = tags.getClass();
System.out.println(actualClass == ArrayList.class); // true
// The following line won't compile: System.out.println(actualClass == ArrayList<String>.class);

This erasure means you cannot create arrays of generic types or use instanceof with type parameters.