Java Autoboxing and Unboxing Explained — How, Why, and When It Bites You

public class AutoboxingBasics {

    public static void main(String[] args) {

        // --- AUTOBOXING ---
        // The compiler rewrites this line as: Integer boxedScore = Integer.valueOf(42);
        // You write a primitive literal, Java wraps it into an Integer object.
        Integer boxedScore = 42;

        // --- UNBOXING ---
        // The compiler rewrites this as: int rawScore = boxedScore.intValue();
        // You use an Integer where a primitive is needed, Java unwraps it.
        int rawScore = boxedScore;

        // --- AUTOBOXING IN A COLLECTION ---
        // ArrayList only holds objects, not primitives.
        // Each add() call autoboxes the int literal into an Integer object.
        java.util.List<Integer> playerScores = new java.util.ArrayList<>();
        playerScores.add(100);  // compiler inserts: Integer.valueOf(100)
        playerScores.add(250);  // compiler inserts: Integer.valueOf(250)
        playerScores.add(75);   // compiler inserts: Integer.valueOf(75)

        // --- UNBOXING IN ARITHMETIC ---
        // get() returns an Integer object, but + operator needs primitives.
        // The compiler inserts .intValue() calls on both operands automatically.
        int totalScore = playerScores.get(0) + playerScores.get(1);

        System.out.println("Boxed score (Integer object): " + boxedScore);
        System.out.println("Unboxed score (int primitive): " + rawScore);
        System.out.println("Total of first two scores: " + totalScore);

        // --- WHAT THE COMPILER ACTUALLY GENERATES ---
        // You can verify this by compiling and running: javap -c AutoboxingBasics.class
        // You'll see invokevirtual calls to Integer.valueOf and Integer.intValue
        System.out.println("\nAll scores in list: " + playerScores);
    }
}

public class IntegerCacheDemo {

    public static void main(String[] args) {

        // --- VALUES WITHIN THE CACHE RANGE: -128 to 127 ---
        // Integer.valueOf(100) returns the SAME cached object both times.
        // So == compares the same memory address and returns true.
        Integer firstSmallNumber = 100;   // autoboxed via Integer.valueOf(100)
        Integer secondSmallNumber = 100;  // returns the SAME cached object

        System.out.println("=== Within cache range (100) ===");
        System.out.println("firstSmallNumber == secondSmallNumber : "
                + (firstSmallNumber == secondSmallNumber));   // true — SAME object
        System.out.println("firstSmallNumber.equals(secondSmallNumber): "
                + firstSmallNumber.equals(secondSmallNumber)); // true — same value

        // --- VALUES OUTSIDE THE CACHE RANGE ---
        // Integer.valueOf(200) creates a NEW object every time.
        // So == compares DIFFERENT memory addresses and returns false.
        Integer firstLargeNumber = 200;   // new Integer object created
        Integer secondLargeNumber = 200;  // ANOTHER new Integer object created

        System.out.println("\n=== Outside cache range (200) ===");
        System.out.println("firstLargeNumber == secondLargeNumber : "
                + (firstLargeNumber == secondLargeNumber));   // false — DIFFERENT objects!
        System.out.println("firstLargeNumber.equals(secondLargeNumber): "
                + firstLargeNumber.equals(secondLargeNumber)); // true — same value

        // --- THE SAFE APPROACH: always use .equals() for wrapper comparisons ---
        Integer playerLevel = 250;
        Integer targetLevel = 250;

        // WRONG way — will fail silently for values outside the cache
        if (playerLevel == targetLevel) {
            System.out.println("\n[WRONG CHECK] Levels match (== used — unreliable!)");
        } else {
            System.out.println("\n[WRONG CHECK] Levels do NOT match (== used — lied to us!)");
        }

        // RIGHT way — always use .equals() to compare wrapper object values
        if (playerLevel.equals(targetLevel)) {
            System.out.println("[CORRECT CHECK] Levels match (.equals() used — reliable)");
        }
    }
}

public class AutoboxingPerformance {

    private static final int TRANSACTION_COUNT = 1_000_000;

    public static void main(String[] args) {

        // --- SLOW VERSION: wrapper type used as accumulator ---
        // Every += operation does THREE things:
        //   1. Unbox: totalRevenueSlow.longValue()
        //   2. Add:   result = longValue + nextAmount
        //   3. Rebox: totalRevenueSlow = Long.valueOf(result)
        // This creates 1,000,000 temporary Long objects on the heap.
        Long totalRevenueSlow = 0L;
        long startSlow = System.nanoTime();

        for (int transactionIndex = 0; transactionIndex < TRANSACTION_COUNT; transactionIndex++) {
            totalRevenueSlow += 1L; // hidden autobox/unbox on EVERY iteration
        }

        long durationSlowMs = (System.nanoTime() - startSlow) / 1_000_000;

        // --- FAST VERSION: primitive used as accumulator ---
        // No objects created. Pure stack arithmetic. GC never involved.
        long totalRevenueFast = 0L;
        long startFast = System.nanoTime();

        for (int transactionIndex = 0; transactionIndex < TRANSACTION_COUNT; transactionIndex++) {
            totalRevenueFast += 1L; // simple primitive addition — no boxing
        }

        long durationFastMs = (System.nanoTime() - startFast) / 1_000_000;

        // --- RESULTS ---
        System.out.println("=== Performance Comparison ===");
        System.out.println("Transactions processed: " + TRANSACTION_COUNT);
        System.out.println("Slow (Long accumulator):  " + durationSlowMs + " ms");
        System.out.println("Fast (long accumulator):  " + durationFastMs + " ms");
        System.out.println("Both totals match: " + totalRevenueSlow.equals(totalRevenueFast));
        System.out.println();
        System.out.println("Tip: The difference grows as TRANSACTION_COUNT grows.");
        System.out.println("In a financial system processing millions of records,");
        System.out.println("this single type choice has real consequences.");
    }
}

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

public class NullUnboxingDemo {

    // Simulates a database lookup — returns null when the player doesn't exist
    static Integer getPlayerHighScore(String playerName) {
        Map<String, Integer> scoreDatabase = new HashMap<>();
        scoreDatabase.put("alice", 4500);
        scoreDatabase.put("bob", 3200);
        // Note: "charlie" is not in the database — lookup returns null
        return scoreDatabase.get(playerName);
    }

    public static void main(String[] args) {

        // --- THE HIDDEN NPE TRAP ---
        // getPlayerHighScore returns Integer (nullable).
        // Assigning to int triggers unboxing: null.intValue() — NPE!
        try {
            int charlieScore = getPlayerHighScore("charlie"); // null gets unboxed here
            System.out.println("Charlie's score: " + charlieScore);
        } catch (NullPointerException npe) {
            System.out.println("[CAUGHT] NPE from unboxing null Integer!");
            System.out.println("The line looked safe but null.intValue() was called.");
        }

        // --- FIX 1: null check before unboxing ---
        Integer charlieRawScore = getPlayerHighScore("charlie");
        if (charlieRawScore != null) {
            int safeScore = charlieRawScore; // safe to unbox — we know it's not null
            System.out.println("\n[FIX 1] Charlie's score: " + safeScore);
        } else {
            System.out.println("\n[FIX 1] Charlie has no recorded score yet.");
        }

        // --- FIX 2: provide a default value using Objects.requireNonNullElse ---
        Integer aliceRawScore = getPlayerHighScore("alice");
        int aliceScore = Objects.requireNonNullElse(aliceRawScore, 0); // 0 if null
        System.out.println("[FIX 2] Alice's score (default 0 if absent): " + aliceScore);

        int unknownPlayerScore = Objects.requireNonNullElse(
                getPlayerHighScore("dave"), 0);
        System.out.println("[FIX 2] Dave's score (default 0 if absent): " + unknownPlayerScore);
    }
}