Methods & arrays: interview questions & scenarios

Model answer

Always pass-by-value. On each call the JVM pushes a new frame and copies each argument into a fresh parameter slot. For a primitive the copy is the number. For an object, the variable's value is a reference, so the copy is a copy of the reference: both caller and callee point at the same heap object. The callee can mutate that object, but reassigning the parameter only re-points its own copy. That's why you can't write a swap(a, b) in Java that swaps the caller's two variables. See Methods and why Java is always pass-by-value.

Model answer

static void change(StringBuilder sb) {
    sb.append(" world");
    sb = new StringBuilder("bye");
    sb.append("!");
}

StringBuilder sb = new StringBuilder("hello");
change(sb);
System.out.println(sb);

It prints hello world. The first line mutates the shared object through the copied reference, so the caller sees it. The second line re-points only the callee's copy; "bye!" is built on a new object that becomes garbage on return.

Model answer

static void inc(Integer n)   { n++; }
static void inc(int[] box)   { box[0]++; }

Integer a = 5;
int[] b = {5};
inc(a);
inc(b);
System.out.println(a + " " + b[0]);

It prints 5 6. n++ on an Integer unboxes, adds one, boxes a new Integer and reassigns the local parameter: the caller's a still points at the old 5. The array is a shared heap object, so box[0]++ writes into the same array the caller holds.

Model answer

static void m(long x)    { System.out.print("long "); }
static void m(Integer x) { System.out.print("Integer "); }
static void m(int... x)  { System.out.print("varargs "); }

byte b = 1;
m(b);                    // long
m(5);                    // long
m(Integer.valueOf(5));   // Integer
m();                     // varargs

It prints long long Integer varargs. Overload resolution runs in three phases (JLS §15.12.2): phase 1 allows only identity and widening, phase 2 adds boxing and unboxing, phase 3 adds varargs. byte and int both widen to long in phase 1, so m(Integer) is never considered. Integer.valueOf(5) is an identity match for m(Integer) in phase 1 (reaching long would need unboxing). m() only fits varargs. See Overloading and varargs.

Model answer

No. The signature is the method name plus parameter types (JLS §8.4.2). Return type, parameter names and the throws clause don't count, so int f() and String f() in one class is "already defined". The reason: a call like f(); that ignores the result gives the compiler nothing to choose with.

Model answer

final class Point {
    final int x, y;
    Point(int x, int y) { this.x = x; this.y = y; }
    public boolean equals(Point o) { return o != null && x == o.x && y == o.y; }
    @Override public int hashCode() { return 31 * x + y; }
}

Set<Point> set = new HashSet<>();
set.add(new Point(1, 2));
set.contains(new Point(1, 2));   // false

equals(Point) overloads Object.equals(Object), it doesn't override it. HashSet calls equals(Object) through an Object-typed reference, so overload resolution picks the inherited identity check. The hash codes match, the bucket is right, and identity equality still says no. Fix: declare equals(Object o) and put @Override on it, which turns this mistake into a compile error.

Model answer

static int count(Object... items) { return items == null ? -1 : items.length; }

count();                          // 0
count((Object) null);             // 1
count(1, "two", null);            // 3
count(new Object[]{"a", "b"});    // 2
count((Object) new Object[]{"a"}); // 1

Varargs compiles to an array parameter, and the call site builds the array. No arguments means an empty array, never null. A single argument that is already an Object[] is passed as the array itself; casting it to Object forces it to be wrapped as one element. A bare count(null) compiles with a warning and passes a null array, returning -1.

Model answer

Heap pollution (JLS §4.12.2) is when a variable of a parameterized type refers to an object that isn't of that type. Generic varargs cause it because T... can't create a real T[] after erasure, so the compiler creates an Object[] and warns. If the method stores into that array or lets it escape, a caller can get a ClassCastException far from the cause:

static <T> T[] toArray(T... items) { return items; }
static <T> T[] pickTwo(T a, T b, T c) { return toArray(a, b); }
String[] s = pickTwo("x", "y", "z");   // ClassCastException: Object[] to String[]

@SafeVarargs is the author's promise that the method only reads the elements. It's allowed on constructors, static and final methods, and since Java 9 on private methods: places that can't be overridden to break the promise.

Model answer

Object[] objs = new String[2];
objs[0] = "ok";
objs[1] = 42;

It compiles, because arrays are covariant: a String[] is an Object[]. At runtime the aastore instruction checks every reference store against the array's actual element type, so objs[1] = 42 throws ArrayStoreException: java.lang.Integer.

Model answer

int[] ids = {1, 2, 3};
Arrays.asList(ids).contains(2);            // false
List<String> tags = Arrays.asList("a", "b");
tags.add("c");                             // UnsupportedOperationException

asList(T... a) can't take primitives as T, so with an int[] the whole array becomes the single element: you get a List<int[]> of size 1. Second, asList returns a fixed-size view backed by the array: set writes through, but add and remove throw. Fixes: IntStream.of(ids).boxed().toList() for primitives, and new ArrayList<>(Arrays.asList(...)) when you need to grow.

Model answer

Each recursive call pushes a frame, and a thread's stack is fixed (1 MB by default on 64-bit Linux, set with -Xss). Nested input like a 50,000-level JSON array drives a recursive parser past it. Options, in my order of preference:

1. Cap nesting depth and reject input past it (say 1,000 levels). This also blocks a denial-of-service vector.
2. Rewrite as iteration with an explicit ArrayDeque as the stack, so depth is limited by heap, not thread stack.
3. Run the work on a dedicated thread with a bigger stack: new Thread(null, task, "parser", 64L << 20).
4. Raise -Xss globally only as a last resort: it applies to every thread.

Catching StackOverflowError and continuing is unsafe, because it can fire mid-update inside any method.

Model answer

static int[][] deepCopy(int[][] src) {
    if (src == null) return null;
    int[][] out = new int[src.length][];
    for (int i = 0; i < src.length; i++) {
        out[i] = src[i] == null ? null : src[i].clone();
    }
    return out;
}

src.clone() alone is shallow: the new outer array holds the same row references, so a write to copy[0][0] shows up in the original. Allocating the outer array with new int[n][] and cloning each row copies everything, preserves each row's length and handles null rows. For an Object[][] you'd still share the element objects; that's as deep as an array copy goes.