Data types & variables: interview questions & scenarios

Model answer

Integer a = 127, b = 127, c = 128, d = 128;
System.out.println(a == b);       // true
System.out.println(c == d);       // false
System.out.println(c.equals(d));  // true

Autoboxing compiles to Integer.valueOf(int), which returns cached instances for -128 to 127. So a and b are the same object and == (a reference comparison) is true. 128 is outside the cache, so c and d are two different objects: == is false, while equals() compares values and is true.

Model answer

It prints false; 0.1 + 0.2 is 0.30000000000000004. double is IEEE 754 binary floating point, and 0.1, 0.2 and 0.3 have no exact binary representation, so each is stored as the nearest representable value and the rounding errors don't cancel.

Compare with a tolerance, Math.abs(a - b) < 1e-9, scaled to your data. For money or anything that must be exact in decimal, use long minor units (cents, paise) or BigDecimal with an explicit RoundingMode.

Model answer

Java never does arithmetic in byte, short or char. Binary numeric promotion (JLS §5.6) turns both operands of + into at least int, so b + 1 is an int, and assigning an int to a byte is a narrowing conversion that needs an explicit cast.

A compound assignment E1 op= E2 is defined as E1 = (T) ((E1) op (E2)), where T is the type of E1. The cast is built in, so b += 1 compiles. b++ also includes the cast.

Model answer

long micros = 24 * 60 * 60 * 1000 * 1000;
System.out.println(micros);   // 500654080

Every literal is an int, so the whole expression is evaluated in int. The true value, 86,400,000,000, overflows on the last multiplication and wraps; only the wrapped result is widened to long. The variable's type doesn't affect how the right-hand side is computed.

Fix it by making the first operand a long: 24L * 60 * 60 * 1000 * 1000 gives 86400000000. Even better for time, Duration.ofDays(1).toNanos() / 1000 or TimeUnit.DAYS.toMicros(1).

Model answer

Set<Short> set = new HashSet<>();
for (short i = 0; i < 100; i++) {
    set.add(i);
    set.remove(i - 1);
}
System.out.println(set.size());   // 100

It prints 100, not 1. i - 1 is an int expression (promotion), so it boxes to an Integer. remove(Object) then looks for an Integer in a set of Shorts, and Short.equals(Integer) is always false, so nothing is ever removed. It compiles because Set.remove takes Object, not E.

The fix is set.remove((short) (i - 1)).

Model answer

It depends on where the variable is declared, not on its type:

• Local variables and parameters (primitive or reference) live in the method's stack frame, in the local variable array. long and double take two slots.
• Fields live inside their object, on the heap. A primitive int field is 4 bytes inside that object.
• Array elements are always on the heap, because arrays are objects.
• Static fields are on the heap too in HotSpot, in the class's Class mirror.

The JIT can change the picture: with escape analysis, an object that never escapes a method may be scalar-replaced, so its fields end up in registers and the object is never allocated.

Model answer

System.out.println('a' + 'b' + "c");   // 195c
System.out.println("c" + 'a' + 'b');   // cab
System.out.println((char) ('a' + 1));  // b
System.out.println('a' + 1);           // 98

+ is left-associative. In the first line, 'a' + 'b' is evaluated first: two chars promote to int, giving 97 + 98 = 195, and then "c" turns it into a string. In the second, the left operand is already a String, so every + is concatenation. A char is a 16-bit unsigned number, so 'a' + 1 is the int 98 until you cast it back.

Model answer

(int) 3.99         // 3
(int) -3.99        // -3
(int) Double.NaN   // 0
(int) 1e20         // 2147483647
(byte) 200         // -56

Floating point to integer truncates toward zero (not floor), maps NaN to 0 and clamps out-of-range values to Integer.MAX_VALUE or MIN_VALUE. Integer to smaller integer does something different: it keeps the low bits and discards the rest, with no clamping. 200 is 1100 1000; as a signed byte, that's -56.

Model answer

counts is a Map<String, Integer>. When the key is missing, get returns null, and assigning it to an int unboxes it by calling intValue() on null. Since Java 14, the message says so: Cannot invoke "java.lang.Integer.intValue()" because the return value of "java.util.Map.get(Object)" is null.

Fixes: counts.getOrDefault(userId, 0), counts.merge(userId, 1, Integer::sum) for counters, or keep the value as Integer and handle null explicitly when "absent" means something.

Model answer

class Stats {
    int total;
    Integer boxed;
    boolean ready;

    void show() {
        int local;
        int[] arr = new int[2];
        System.out.println(total + " " + boxed + " " + ready + " " + arr[0]);
        System.out.println(local);   // does not compile
    }
}

System.out.println(local) fails: variable local might not have been initialized. Without it, the method prints 0 null false 0. Fields and array elements are zeroed by the JVM when the object or array is created. Local variables have no default; the compiler's definite assignment analysis (JLS chapter 16) rejects any read that isn't preceded by a write on every path.

Model answer

MAX_RETRIES is a compile-time constant: final, primitive (or String) and initialised with a constant expression. javac doesn't compile Limits.MAX_RETRIES in the dependent service as a field read; it copies the value 3 into that service's bytecode (iconst_3). Swapping the library jar doesn't change the dependent's class files, so it keeps using 3 until it's recompiled.

Fixes: recompile dependents whenever a constant changes; or, for values that might change, don't make them compile-time constants. Expose a method (static int maxRetries()), read them from configuration, or initialise from a non-constant expression.

Model answer

ArrayList<Object>. The diamond normally infers its type argument from the target type on the left, but with var there is no target, so inference falls back to Object. You can now add a String and an Integer to the same list without a warning.

var (Java 10) is not dynamic typing. The compiler infers the variable's static type from the initialiser once, at compile time, and the bytecode is identical to writing the type yourself. var x = 1; x = "one"; is a compile error. It's only allowed for local variables with an initialiser (including for loops and try-with-resources): not for fields, parameters, return types, null, array initialisers or lambdas.