HuntExams Academy logo
JavaBeginner#generics

Can you use primitive types with generics?

Answer

No. Java generics work only with reference types, so List<int> or Map<int, String> is a compile error. You must use the wrapper classes: List<Integer>, Map<Integer, String>. Why: generics are implemented with type erasure. The type argument is checked at compile time, then erased to Object (or the upper bound) in the bytecode, with casts inserted. Since int is not an Object and cannot live in an Object slot, primitives simply cannot be expressed as type arguments. How the language works around it: - Autoboxing and unboxing let you write list.add(5) and int x = list.get(0); the compiler inserts Integer.valueOf(5) and intValue(). - Wrapper caching: Integer.valueOf caches -128..127, which is exactly why comparing two Integer 127 values with == is true but 128 is false. Compare wrappers with equals(), never ==. - Unboxing a null throws NullPointerException: Integer i = map.get("missing"); int x = i; blows up. - Performance: boxing allocates objects, so a List<Integer> with a million values costs far more memory and GC pressure than an int[]. In hot code use arrays, IntStream / LongStream / DoubleStream, OptionalInt, or primitive-collection libraries such as Eclipse Collections, fastutil or HPPC. - Arrays are objects, so List<int[]> is perfectly legal. Expected follow-ups: "Why type erasure?" \u2014 backward compatibility with pre-generics code. "Will this change?" \u2014 Project Valhalla aims to allow List<int> through value types and specialised generics, but it is not in a released Java version yet.

Example

// Compile errors
// List<int> nums = new ArrayList<>();       // error: unexpected type
// Map<int, String> m = new HashMap<>();     // error

List<Integer> nums = new ArrayList<>();
nums.add(5);                  // autoboxing -> Integer.valueOf(5)
int first = nums.get(0);      // unboxing   -> intValue()

// Wrapper cache trap
Integer a = 127, b = 127;     // both from the cache
Integer c = 128, d = 128;     // two new objects
System.out.println(a == b);        // true
System.out.println(c == d);        // false
System.out.println(c.equals(d));  // true  <-- always compare like this

// Unboxing NPE
Map<String, Integer> scores = new HashMap<>();
// int s = scores.get("absent");  // NullPointerException

// Box-free numeric work
int sum = IntStream.rangeClosed(1, 1_000_000).sum();
int[] raw = new int[1_000_000];        // no boxing at all
List<int[]> rows = new ArrayList<>();  // legal: an array IS an object

Detailed explanation

No. Java generics accept only reference types as type arguments, so List<int> and Map<int, String> do not compile. Use wrapper classes instead: List<Integer> or Map<Integer, String>. The same rule applies to other primitives: double becomes Double, boolean becomes Boolean, and so on. This restriction concerns type arguments, not the contents of a generic class: a generic class can still declare an ordinary int field. Also, List<int[]> is legal because an array is a reference type, even when its elements are primitives.

Java implements generics primarily through type erasure. The compiler checks type arguments and then translates type variables to their upper bounds, usually Object, inserting casts where necessary when values are retrieved. For example, retrieving an element from List<Integer> involves a runtime reference value that the compiler treats as Integer. A primitive int is not an Object and cannot directly substitute for that reference representation. Erasure also helped introduce generics while preserving compatibility with existing Java libraries and compiled code. In interviews, distinguish compile-time type checking from the erased representation used at runtime.

Autoboxing makes wrappers convenient but does not make primitive type arguments legal. With List<Integer> nums = new ArrayList<>(), nums.add(5) boxes the value through Integer.valueOf(5). Conversely, int first = nums.get(0) unboxes the retrieved Integer through intValue(). Unboxing null throws NullPointerException, which commonly happens when a Map<String, Integer> lookup finds no entry. Wrapper equality is another trap: == compares object identity, whereas equals() compares values for matching wrapper types. Integer.valueOf guarantees caching from -128 through 127; implementations may cache additional values, so == for boxed 128 values is not guaranteed to be false.

Boxing can add object allocation, reference storage, and garbage-collection overhead, although caching and JVM optimisations can avoid some allocations. For large numeric workloads, consider int[] or primitive-specialised APIs such as IntStream and OptionalInt; specialised collection libraries are another option. Interviewers generally expect the reference-type rule first, followed by a small boxing example and awareness of null, equality, and performance pitfalls.

Key points to remember

  • Primitive type arguments such as List<int> are illegal; use List<Integer>.
  • Erasure replaces type variables with Object or their upper bound.
  • Autoboxing and unboxing bridge primitives and wrappers, not generic type arguments.
  • Unboxing null throws NullPointerException; use equals() for wrapper value comparisons.
  • List<int[]> is legal, and primitive arrays avoid per-element boxing.

Common mistakes candidates make

  • Assuming autoboxing makes List<int> valid syntax.
  • Using == for wrapper values or claiming boxed 128 values must always have different identities.
  • Ignoring null when unboxing a map lookup or assuming boxing always creates a new object.

Likely follow-up questions

Why does Java use type erasure?

Erasure allowed generics to be introduced while maintaining compatibility with existing libraries and compiled code. It provides compile-time type checking without creating a separate runtime class for every parameterised type.

Why is List<int[]> allowed when List<int> is not?

An int[] is an object and therefore a reference type, so it is a valid generic type argument. Each list element references an entire primitive array, rather than directly storing a primitive int.

Could Java support primitive type arguments in the future?

Project Valhalla is exploring value objects and generics specialisation, with the broader goal of reducing the gap between primitive and reference-based programming. Do not present List<int> as currently supported Java syntax or promise a particular release timeline.

Interview tip: Start with “No, use wrapper types,” demonstrate List<Integer> with boxing and unboxing, and then mention erasure and one practical pitfall.

Related Interview Questions

1
JavaAdvanced#generics

What is type erasure in Java generics?

Open
2
JavaIntermediate#collections

How do you sort a List of custom objects by multiple fields?

Open
3
JavaBeginner#generics

What is the diamond operator in generics?

Open
More Java interview questions →