Why Do Generics Exist in Java?

Generics were added to move type checking from run time to compile time. Before them, a collection held Object, so putting the wrong type into it compiled perfectly and only blew up later when something tried to use it.

The classic failure is a raw list. You add a String to it, then read it back as an Integer. The compiler cannot help you, because the list has no idea what is inside it. The ClassCastException arrives at run time, possibly far from the code that put the bad value in.

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

public class Main {
    public static void main(String[] args) {
        // Without generics this compiles, then fails at run time.
        List raw = new ArrayList();
        raw.add("a string");
        try {
            Integer number = (Integer) raw.get(0);
            System.out.println(number);
        } catch (ClassCastException e) {
            System.out.println("raw list -> ClassCastException");
        }

        // With generics the mistake cannot compile at all.
        List<String> typed = new ArrayList<>();
        typed.add("a string");
        String text = typed.get(0);
        System.out.println("typed list -> " + text);
    }
}

The output shows the difference in one screen. The raw list accepts anything and fails when the wrong type is pulled back out. The typed list cannot hold the wrong value at all, and get(0) returns a String the compiler knows is a String.

Three benefits follow. Type safety — the compiler rejects the mistake at build time, where it is cheap to fix. No casts — the compiler inserts the cast for you, which removes both the noise and the runtime cost of checking. And better generics — with a raw list, the compiler treats a for-each loop element as Object and refuses to let you call anything on it; with a parameterised list, the element type is known.

The cost is in the language itself: generics are implemented with type erasure so that new generic code can run against old, non-generic libraries. That is what makes generics source-compatible with the pre-2004 world, and it is also what creates the limitations around overloading and primitive type arguments.

A generic class declares one or more type parameters on the class itself, and every instance of that class carries its own choice of them. Box<T> is a class whose value field is of type T; Box<String> and Box<Integer> are two completely separate types as far as the compiler is concerned.

A generic method declares its type parameters on the method, and the class it lives in does not have to be generic at all. That is the right choice when the type parameter is only relevant to that one operation, and it lets you put a generic method in a non-generic utility class.

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

public class Main {
    public static void main(String[] args) {
        Box<String> stringBox = new Box<>("hello");
        Box<Integer> intBox = new Box<>(42);

        System.out.println("string box : " + stringBox.get());
        System.out.println("int box    : " + intBox.get());

        // A generic method infers its type parameter from the arguments.
        System.out.println("first      : " + first(List.of("x", "y", "z")));
        System.out.println("identity   : " + identity("kept as T"));
        System.out.println("as a list  : " + listOf(1, 2, 3));
    }

    static <T> List<T> listOf(T... items) {
        List<T> result = new ArrayList<>();
        for (T item : items) {
            result.add(item);
        }
        return result;
    }

    static <T> T first(List<T> values) {
        return values.get(0);
    }

    static <T> T identity(T value) {
        return value;
    }
}

class Box<T> {
    private final T value;

    Box(T value) {
        this.value = value;
    }

    T get() {
        return value;
    }
}

The output shows both forms working. The class-level parameter T is fixed per Box instance, so the string box returns a String and the integer box returns an Integer. The method-level parameters are inferred at each call site: first on a List of Strings gives back a String, and the varargs helper builds a List of Integers.

Two mechanics worth knowing. The diamond operator, new Box<>(...), tells the compiler to infer the type arguments from the target, which saves repeating them. And a generic method can be called on an instance of a non-generic class, so you can have a private static helper with a type parameter in any class at all.

The benefits are real and well understood. Type safety moves failures from run time to compile time, so a mistyped value is a build break rather than an incident. The compiler inserts the casts, so there is no runtime checking cost. Generic collections give you a properly typed for-each loop instead of an Object you have to cast. And the type parameter carries through your own APIs, so a method that returns T propagates the type information to its callers.

The costs are subtler and worth being able to state. Generics add compile-time overhead and make the source more verbose, particularly when a method has several type parameters or a nested generic type appears in a signature. Reading a signature like Map<String, List<Map<Integer, String>>> takes a moment, and the type parameter names have to be chosen well to help.

There are also genuine language-level limitations. Because of type erasure you cannot overload on type arguments, you cannot use a primitive as a type argument without boxing, and you cannot ask a generic object at run time what its type parameter was. You also cannot use instanceof to check a type parameter — the check is always illegal because the type is erased — and you cannot create an instance of a type parameter with new.

The practical guidance is to use generics where they buy you type safety at an API boundary, which is almost everywhere, and not to fight the language where it does not fit. If a type parameter is only used once in a signature, often an Object or a wildcard is clearer. And the record keyword gives you a value class with correct equals, hashCode and toString for free, which removes the majority of the boilerplate that used to make generics look heavy.