Home / Language / Enhanced for with var
Language beginner

Enhanced for with var

Use var in for-each loops to reduce generic type noise.

Code Comparison
✕ Java 8 
List<Map.Entry<String, Integer>> list = ...;
for (Map.Entry<String, Integer> entry
        : list) {
    process(entry);
}
✓ Java 10+ 
var list = getEntries();
for (var entry : list) {
    process(entry);
}
Why the modern way wins
👁

Less noise

Complex generic types in loops obscure the logic.

��

Same safety

Type inference is compile-time — no runtime penalty.

🔄

Refactor-friendly

Change the collection type and the loop var adjusts automatically.

Old Approach
Explicit Loop Type
Modern Approach
var in for-each
Since JDK
10
Difficulty
beginner
JDK Support
Enhanced for with var
Available

Widely available since JDK 10 (March 2018)

How it works

When iterating over collections with complex generic types, var in the loop variable reduces clutter while the compiler still knows and enforces the exact type.

Related patterns

Language advanced

Primitive types in patterns

Java 8
String classify(int code) {
    if (code >= 200 && code < 300)
        return "success";
    else if (code >= 400 && code < 500)
        return "client error";
    else
        return "other";
}
Java 25
String classify(int code) {
    return switch (code) {
        case int c when c >= 200
            && c < 300 -> "success";
        case int c when c >= 400
            && c < 500 -> "client error";
        default -> "other";
    };
}
Hover to see modern ➜
JDK 25+ →
Language intermediate

Exhaustive switch without default

Java 8
// Must add default even though
// all cases are covered
double area(Shape s) {
    if (s instanceof Circle c)
        return Math.PI * c.r() * c.r();
    else if (s instanceof Rect r)
        return r.w() * r.h();
    else throw new IAE();
}
Java 21+
// sealed Shape permits Circle, Rect
double area(Shape s) {
    return switch (s) {
        case Circle c ->
            Math.PI * c.r() * c.r();
        case Rect r ->
            r.w() * r.h();
    }; // no default needed!
}
Hover to see modern ➜
JDK 21+ →
Language beginner

Unnamed variables with _

Java 8
try {
    parse(input);
} catch (Exception ignored) {
    log("parse failed");
}
map.forEach((key, value) -> {
    process(value); // key unused
});
Java 22+
try {
    parse(input);
} catch (Exception _) {
    log("parse failed");
}
map.forEach((_, value) -> {
    process(value);
});
Hover to see modern ➜
JDK 22+ →
Share 𝕏 🦋 in ⬡