What are Primitive Types in Patterns?

• Primitive patterns – instanceof and switch now match against primitive types, not just reference types.
• Safe narrowing – if (longVal instanceof int i) succeeds only if the long value fits in an int without data loss.
• Switch on long/double – switch can now match on long, float, and double values, not just int, String, and enum.
• Guards – case int i when i > 0 -> ... combines type matching with conditions on primitive values.
• Unification – completes the pattern matching model so it covers both reference and primitive types uniformly.

What are Primitive Types in Patterns?

Primitive Types in Patterns (JEP 507, preview in Java 24) extends pattern matching so that instanceof and switch can match against primitive types and perform safe, range-checked conversions.

How does safe narrowing work?

When you write if (longVal instanceof int i), the pattern matches only if the long value fits within the int range (-2,147,483,648 to 2,147,483,647). If the value is outside that range, the pattern does not match and the if body is skipped.

package com.bank.service;

public class AmountClassifier {

    public void classify(long amount) {
        if (amount instanceof int smallAmount) {
            System.out.println("Fits in int: " + smallAmount);
        } else {
            System.out.println("Too large for int: " + amount);
        }
    }
}

classify(50000)         → "Fits in int: 50000"
classify(3000000000L)   → "Too large for int: 3000000000"

How does switch on primitives work?

public String classifyAmount(long amount) {
    return switch (amount) {
        case int i when i < 0       -> "Negative: " + i;
        case int i when i <= 100000 -> "Small transaction: " + i;
        case int i                  -> "Medium transaction: " + i;
        case long l                 -> "Large transaction: " + l;
    };
}

How is this different from manual range checking?

// BEFORE: manual range check and cast
public void store(long amount) {
    if (amount >= Integer.MIN_VALUE && amount <= Integer.MAX_VALUE) {
        int intAmount = (int) amount;  // safe cast
        storeAsInt(intAmount);
    } else {
        storeAsLong(amount);
    }
}

// AFTER: primitive pattern (JEP 507)
public void store(long amount) {
    if (amount instanceof int intAmount) {
        storeAsInt(intAmount);  // safe: guaranteed to fit
    } else {
        storeAsLong(amount);
    }
}

What conversions are supported?

| Source | Pattern | Matches when |
|---|---|---|
| long | int i | Value fits in int range |
| double | float f | Value fits in float without precision loss |
| long | byte b | Value fits in byte range (-128 to 127) |
| int | short s | Value fits in short range |

What are common mistakes?

// WRONG: assuming all long values match int pattern
long bigAmount = 5_000_000_000L;
if (bigAmount instanceof int i) {
    // This block is NEVER entered for 5 billion
    System.out.println(i);
}

// Pattern matching is SAFE: no ClassCastException, no overflow

What should a senior engineer know?

• Primitive patterns complete the unification of pattern matching across all Java types.
• Combined with sealed types and record patterns, you can now write exhaustive switches that handle both reference and primitive cases.
• The JIT can optimize primitive pattern matches very efficiently since they reduce to range checks.
• This feature is preview in Java 24; the API may change.

What are common interview follow-up questions?

• Can you use primitive patterns in record deconstruction? (Yes, if a record component is a primitive, the pattern can narrow it.)
• Does this replace manual casting? (For safe narrowing, yes. The pattern only matches when the cast would be lossless.)
• What happens with floating point? (double instanceof float matches only if no precision is lost.)