Java Data Types, Pass-by-Value and Autoboxing

How Java stores and passes data is the source of many classic interview questions. This article covers the whole family: primitives, references, boxing, casting, and the arithmetic surprises.

Primitive and reference types

Java has eight primitive types. Everything else is a reference type (a class, interface, array or enum).

A primitive variable holds the value itself (default 0, false or '\u0000' for fields). A reference variable holds a reference to an object on the heap (default null). Because primitives are not objects, Java is not 100% object-oriented.

Java is always pass-by-value

This is asked constantly, and "pass-by-reference for objects" is the wrong answer. Java always copies the value of the argument. For an object, that value is the reference, so the method receives a copy of the reference. Both the caller's variable and the parameter point to the same object.

public class PassByValue {
    static class Point {
        int x;
        Point(int x) { this.x = x; }
    }

    static void reassign(Point p) { p = new Point(99); }   // changes only the local copy of the reference
    static void mutate(Point p)   { p.x = 99; }            // follows the reference and changes the shared object

    public static void main(String[] args) {
        Point point = new Point(1);
        reassign(point);
        System.out.println(point.x);       // 1
        mutate(point);
        System.out.println(point.x);       // 99
    }
}

reassign cannot make the caller's point refer to a different object, which proves the reference itself was copied. mutate can change the object, because both references reach it.

Wrapper classes, autoboxing and unboxing

Each primitive has a wrapper class (Integer, Double, Boolean, Character and so on). Generics and collections work only with objects, so the compiler converts automatically:

• Autoboxing: Integer x = 5; becomes Integer.valueOf(5).
• Unboxing: int y = x; becomes x.intValue().

That convenience has two traps.

public class Boxing {
    public static void main(String[] args) {
        Integer a = 127, b = 127;
        Integer c = 128, d = 128;
        System.out.println(a == b);              // true   (values from -128 to 127 come from a shared cache)
        System.out.println(c == d);              // false  (128 is outside the cache: two different objects)
        System.out.println(c.equals(d));         // true

        Integer missing = null;
        try {
            int value = missing;                 // unboxing calls missing.intValue()
        } catch (NullPointerException e) {
            System.out.println("NullPointerException while unboxing");   // NullPointerException while unboxing
        }
    }
}

1. The Integer cache. Integer.valueOf reuses cached objects for -128 to 127, so == happens to work for small numbers and fails for larger ones. Always compare wrappers with .
2. Unboxing . Unboxing a wrapper throws . This often hides inside arithmetic or map lookups, such as .

Performance: boxing allocates objects, so avoid wrappers in hot loops. Use primitive streams () and primitive arrays for large numeric work.

Casting, overflow and floating point

• Widening ( to ) happens automatically. Narrowing ( to , to ) needs a cast and can lose data silently.
• Integer overflow wraps around without any error. Use and friends when you need an exception.
• and are binary fractions, so is not exactly . Use for money, and always create it from a (), never from a .
• Integer division truncates ( is ), and is the remainder.
• (Java 10) infers a local variable's type from its initializer. It is still statically typed, and it cannot be used for fields or method parameters.

Practise

1. Predict, then run, the program. Then change to modify and see what changes.
2. Find the smallest pair where returns but returns .
3. Write a method that adds two values and throws on overflow.