Java Wrapper Classes — Null Unboxing in Production

package io.thecodeforge.wrapper;

public class WrapperClassBasics {
    public static void main(String[] args) {

        // ── Primitive types ─────────────────────────────────────────
        int playerScore = 9500;          // raw int, lives on the stack
        double itemPrice = 14.99;        // raw double
        boolean isLoggedIn = true;       // raw boolean
        char grade = 'A';                // raw char

        // ── Their Wrapper Class equivalents ─────────────────────────
        Integer playerScoreObj = Integer.valueOf(playerScore);   // int → Integer
        Double itemPriceObj    = Double.valueOf(itemPrice);       // double → Double
        Boolean isLoggedInObj  = Boolean.valueOf(isLoggedIn);     // boolean → Boolean
        Character gradeObj     = Character.valueOf(grade);        // char → Character

        // ── Wrapper classes carry useful constants ───────────────────
        System.out.println("Max int value : " + Integer.MAX_VALUE);   // 2147483647
        System.out.println("Min int value : " + Integer.MIN_VALUE);   // -2147483648
        System.out.println("Max double    : " + Double.MAX_VALUE);    // 1.7976931348623157E308

        // ── Wrapper classes carry useful utility methods ─────────────
        String scoreAsText = "8750";  // imagine reading this from user input
        int parsedScore = Integer.parseInt(scoreAsText); // String → int (critical method!)
        System.out.println("Parsed score  : " + parsedScore);         // 8750

        // ── Convert a number to binary, octal, hex strings ───────────
        System.out.println("Binary of 255 : " + Integer.toBinaryString(255)); // 11111111
        System.out.println("Hex of 255    : " + Integer.toHexString(255));    // ff
    }
}

package io.thecodeforge.wrapper;

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

public class AutoboxingDemo {
    public static void main(String[] args) {

        // ── AUTOBOXING: primitive int → Integer object automatically ──
        int rawTemperature = 37;
        Integer boxedTemperature = rawTemperature; // compiler inserts Integer.valueOf(37)
        System.out.println("Boxed temperature : " + boxedTemperature);

        // ── UNBOXING: Integer object → primitive int automatically ────
        Integer storedValue = Integer.valueOf(100);
        int usableValue = storedValue; // compiler inserts storedValue.intValue()
        int doubled = usableValue * 2; // arithmetic works directly on the unboxed value
        System.out.println("Doubled value     : " + doubled);

        // ── The most common real-world use: Collections ───────────────
        // ArrayList<Integer> CANNOT hold raw ints — it needs Integer objects.
        // Autoboxing means we can still write int literals and Java handles the rest.
        List<Integer> weeklyStepCounts = new ArrayList<>();
        weeklyStepCounts.add(8200);  // 8200 is a raw int — autoboxed to Integer
        weeklyStepCounts.add(10500);
        weeklyStepCounts.add(7300);
        weeklyStepCounts.add(9800);
        weeklyStepCounts.add(11200);

        System.out.println("Step counts : " + weeklyStepCounts);

        // ── Unboxing during arithmetic in a loop ──────────────────────
        int totalSteps = 0;
        for (Integer steps : weeklyStepCounts) {
            totalSteps += steps; // 'steps' is an Integer, unboxed to int for += to work
        }
        System.out.println("Total steps : " + totalSteps);
        System.out.println("Daily avg   : " + (totalSteps / weeklyStepCounts.size()));
    }
}

package io.thecodeforge.wrapper;

public class WrapperComparisonTrap {
    public static void main(String[] args) {

        // ── SAFE RANGE: -128 to 127 (Integer Cache in action) ────────
        Integer cachedA = 100;  // autoboxed — Java returns a cached object
        Integer cachedB = 100;  // autoboxed — Java returns THE SAME cached object

        System.out.println("── Values in cached range (100) ──");
        System.out.println("cachedA == cachedB     : " + (cachedA == cachedB));     // true (same object!)
        System.out.println("cachedA.equals(cachedB): " + cachedA.equals(cachedB));  // true (same value)

        // ── OUTSIDE SAFE RANGE: values beyond 127 ─────────────────────
        Integer bigA = 500;  // autoboxed — Java creates a NEW Integer object
        Integer bigB = 500;  // autoboxed — Java creates ANOTHER NEW Integer object

        System.out.println("\n── Values outside cached range (500) ──");
        System.out.println("bigA == bigB           : " + (bigA == bigB));     // FALSE — different objects!
        System.out.println("bigA.equals(bigB)      : " + bigA.equals(bigB));  // true — same value

        // ── THE GOLDEN RULE ───────────────────────────────────────────
        // Always use .equals() to compare wrapper objects by value.
        // Always use == to compare primitives by value.

        Integer userRank = 500;
        Integer targetRank = 500;

        // WRONG way — will fail unpredictably depending on the value
        if (userRank == targetRank) {
            System.out.println("\nWRONG: This block won't run for 500!");
        }

        // CORRECT way — always reliable
        if (userRank.equals(targetRank)) {
            System.out.println("CORRECT: Ranks match — both are " + userRank);
        }

        // ── Bonus: comparing with null safely ─────────────────────────
        Integer possiblyNullScore = null;
        // possiblyNullScore.equals(500) → NullPointerException!
        // Safe pattern: put the known non-null value on the LEFT
        boolean isFiftyPoints = Integer.valueOf(50).equals(possiblyNullScore); // safe — returns false
        System.out.println("Is 50 points?          : " + isFiftyPoints);      // false, no crash
    }
}

package io.thecodeforge.wrapper;

public class WrapperUtilityMethods {
    public static void main(String[] args) {

        // ── Parsing Strings into primitive numbers ─────────────────────
        String rawAge       = "28";         // comes from user input or config
        String rawBalance   = "1250.75";    // comes from a database or API
        String rawIsActive  = "true";       // comes from a property file

        int    age       = Integer.parseInt(rawAge);           // "28"     → 28
        double balance   = Double.parseDouble(rawBalance);     // "1250.75" → 1250.75
        boolean isActive = Boolean.parseBoolean(rawIsActive);  // "true"   → true

        System.out.println("Age       : " + age);
        System.out.println("Balance   : " + balance);
        System.out.println("Is active : " + isActive);

        // ── Converting numbers back to Strings ─────────────────────────
        int productCode = 4872;
        String codeAsText = Integer.toString(productCode); // int → String
        System.out.println("Product code as text : " + codeAsText);

        // ── Base conversions (very handy for low-level work) ───────────
        int filePermission = 493; // Unix permission 755 in decimal
        System.out.println("Octal   : " + Integer.toOctalString(filePermission));   // 755
        System.out.println("Binary  : " + Integer.toBinaryString(filePermission));  // 111101101
        System.out.println("Hex     : " + Integer.toHexString(filePermission));     // 1ed

        // ── Character utility methods ───────────────────────────────────
        char inputChar = '7';
        System.out.println("'7' is digit   : " + Character.isDigit(inputChar));       // true
        System.out.println("'7' is letter  : " + Character.isLetter(inputChar));      // false

        char letterChar = 'g';
        System.out.println("'g' is upper   : " + Character.isUpperCase(letterChar));  // false
        System.out.println("'g' to upper   : " + Character.toUpperCase(letterChar));  // G

        // ── Comparing two wrapper values with compareTo ────────────────
        Integer scoreA = 850;
        Integer scoreB = 920;
        int result = scoreA.compareTo(scoreB); // negative = scoreA is less than scoreB
        System.out.println("compareTo result : " + result); // negative number (e.g. -1)
        System.out.println(scoreA < scoreB ? "scoreA is lower" : "scoreA is not lower");
    }
}

package io.thecodeforge.wrapper;

import java.util.Optional;

public class NullSafetyDemo {
    public static void main(String[] args) {
        // Simulating a user object with a nullable Integer field
        User user1 = new User("Alice", 30);          // age provided
        User user2 = new User("Bob", null);          // age missing

        // BAD: unboxing null causes NPE at runtime
        // int badAge = user2.getAge();  // Uncomment to crash

        // GOOD: ternary with null check
        int ageBob = (user2.getAge() != null) ? user2.getAge() : -1;
        System.out.println("Bob's age (ternary): " + ageBob);

        // GOOD: Optional pattern
        Optional<Integer> maybeAge = Optional.ofNullable(user2.getAge());
        int safeAge = maybeAge.orElse(-1);
        System.out.println("Bob's age (Optional): " + safeAge);

        // GOOD: using primitive int directly when null is not allowed
        int ageAlice = user1.getAge();  // safe because non-null
        System.out.println("Alice's age : " + ageAlice);
    }
}

class User {
    private String name;
    private Integer age;  // nullable wrapper

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public Integer getAge() { return age; }
}

// io.thecodeforge
public class ValueOfVsNew {
    public static void main(String[] args) {
        // DON'T: allocates new object every time
        Integer bad = new Integer(100);
        
        // DO: returns cached object for -128 to 127
        Integer good = Integer.valueOf(100);
        
        // Same object reference? Yes for cached range
        Integer another = Integer.valueOf(100);
        System.out.println(good == another); // true (cached)
        System.out.println(bad == another);  // false (different objects)
        
        // Outside cache range:
        Integer outside = Integer.valueOf(200);
        Integer outside2 = Integer.valueOf(200);
        System.out.println(outside == outside2); // false (new objects)
    }
}

// io.thecodeforge
import org.apache.commons.lang3.math.NumberUtils;

public class UtilityMethods {
    public static void main(String[] args) {
        // Safe parsing with defaults
        String input = "  42  ";
        int value = NumberUtils.toInt(input.trim(), -1);
        System.out.println("Parsed: " + value); // 42
        
        String badInput = "not-a-number";
        int fallback = NumberUtils.toInt(badInput, 0);
        System.out.println("Fallback: " + fallback); // 0 (no exception)
        
        // Bit operations for network masks or flags
        int flags = 0b10101010;
        System.out.println("Bit count: " + Integer.bitCount(flags));  // 4
        System.out.println("Highest one bit: " + Integer.highestOneBit(flags)); // 128
        
        // Null-safe comparison in streams
        java.util.List<Integer> scores = java.util.Arrays.asList(10, null, 5, 20);
        scores.sort(java.util.Comparator.nullsFirst(Integer::compareTo));
        System.out.println(scores); // [null, 5, 10, 20]
    }
}

// io.thecodeforge
import java.util.stream.IntStream;

public class AutoboxingPerformance {
    public static void main(String[] args) {
        int[] rawData = IntStream.range(0, 10_000_000).toArray();
        
        // BAD: autoboxing inside loop
        long start = System.nanoTime();
        Integer sum = 0;
        for (int val : rawData) {
            sum += val;  // autoboxing on every iteration
        }
        long badTime = System.nanoTime() - start;
        
        // GOOD: primitive arithmetic, box once
        start = System.nanoTime();
        int primitiveSum = 0;
        for (int val : rawData) {
            primitiveSum += val;  // no autoboxing
        }
        Integer goodResult = primitiveSum;  // box once
        long goodTime = System.nanoTime() - start;
        
        System.out.println("Autoboxing version: " + badTime / 1_000_000 + " ms");
        System.out.println("Primitive version: " + goodTime / 1_000_000 + " ms");
        System.out.println("Speedup: " + (badTime / goodTime) + "x");
    }
}