Operators & control flow: interview questions & scenarios

Model answer

int count = 0;
for (int k = 0; k < 100; k++) {
    count = count++;
}
System.out.println(count);

It prints 0. Each count = count++ compiles to iload (push the old value, 0), iinc (the local becomes 1), istore (pop the saved 0 back into count). The increment happens, then gets overwritten, a hundred times in a row. The fix is count++; on its own or count += 1;.

Model answer

System.out.println(1 + 2 + "3" + 4 + 5);   // 3345
System.out.println('a' + 'b' + "c");       // 195c
System.out.println("" + 'a' + 'b');        // ab

+ is left-associative. In the first line, 1 + 2 is integer addition (3), then 3 + "3" becomes the string "33", and every later + appends. In the second, 'a' + 'b' is char + char, which promotes to int: 97 + 98 = 195, then "c" is appended. In the third, the leading "" makes the very first + a string concatenation.

Model answer

System.out.println(true ? Integer.valueOf(1) : Double.valueOf(2));

It prints 1.0. When both branches of ?: are convertible to numeric types, JLS 15.25 makes the whole expression a numeric conditional: both operands are unboxed and promoted to their common type, double. The result type is decided at compile time from both branches, regardless of which one runs.

Model answer

On booleans, both compute logical AND. && short-circuits: if the left side is false, the right side isn't evaluated. & always evaluates both. That matters for guards and side effects:

int n = 0;
boolean r1 = (n++ > 0) && (n++ > 0);   // n is 1, r1 false: right side skipped
int m = 0;
boolean r2 = (m++ > 0) & (m++ > 0);    // m is 2, r2 false: both sides ran

On integers, & is a bitwise AND (6 & 3 is 2) and && doesn't compile. The same applies to || and |.

Model answer

System.out.println(-16 >> 2);     // -4
System.out.println(-16 >>> 28);   // 15
System.out.println(1 << 33);      // 2
System.out.println(1L << 33);     // 8589934592

>> is an arithmetic shift: it copies the sign bit, so it behaves like division by 4 rounded toward negative infinity. >>> fills with zeros: -16 is 0xFFFFFFF0, and shifting right by 28 leaves 0xF. For int, only the low 5 bits of the distance count, so 1 << 33 is 1 << 1. For long, it's the low 6 bits, so 1L << 33 is what you'd expect.

Model answer

short s = 10;
s = s + 5;    // does NOT compile: int cannot be converted to short
s += 5;       // compiles

s + 5 promotes to int, and assigning an int expression to a short needs an explicit cast. Compound assignment is defined by JLS 15.26.2 as s = (short) (s + 5), with s evaluated once, so the cast is built in.

Model answer

switch (day) {
    case "MON": System.out.print("M");
    default:    System.out.print("D");
    case "TUE": System.out.print("T");
    case "WED": System.out.print("W"); break;
}

"TUE" prints TW, "FRI" prints DTW and "MON" prints MDTW. A classic switch jumps to the matching label and then falls through every later label until a break. default is only the target when nothing matches; its position doesn't make it run last, and it falls through like any other label.

Model answer

The JVM only has two switch instructions, and both work on int keys. tableswitch holds a jump table for a dense range (O(1) index); lookupswitch holds sorted key/offset pairs for sparse keys (the JVM may binary search them). javac picks between them with a space/time cost heuristic.

For a String, javac generates two switches: first a lookupswitch on s.hashCode(), with an equals() call inside each hash bucket to rule out collisions and pick a case index; then a second switch on that index which runs your code. Enums switch on ordinal(), via a synthetic $SwitchMap$ array when the enum is declared in another class.

Model answer

sealed interface Payment permits Card, Upi, Cash {}
record Card(String last4, long amountCents) implements Payment {}
record Upi(String vpa, long amountCents) implements Payment {}
record Cash(long amountCents) implements Payment {}

static long feeCents(Payment p) {
    return switch (p) {
        case Card c when c.amountCents() > 100_000 -> c.amountCents() / 100;  // 1%
        case Card c -> 30;
        case Upi u -> 0;
        case Cash(long amount) -> amount > 0 ? 0 : -1;
    };
}

The compiler now checks three things. Exhaustiveness: Payment is sealed, so covering Card, Upi and Cash is complete and no default is needed. Dominance: an unguarded case Card c above the guarded one would be a compile error. No fall-through: each arrow arm runs alone.

Model answer

List<String> list = new ArrayList<>(List.of("a", "b", "c"));
for (String s : list) {
    if (s.equals("b")) list.remove(s);
}
System.out.println(list);

It prints [a, c] with no exception. The for-each is an Iterator loop. After removing "b", the size is 2 and the iterator's cursor is already 2, so hasNext() (cursor != size) returns false and the loop ends before next() can check modCount. "c" is never visited. Remove "a" instead and you get ConcurrentModificationException on the next next().

Model answer

A plain break only leaves the inner loop. Use a labeled break, or extract a method and return:

static int[] find(int[][] grid, int target) {
    for (int r = 0; r < grid.length; r++) {
        for (int c = 0; c < grid[r].length; c++) {
            if (grid[r][c] == target) return new int[] {r, c};
        }
    }
    return null;
}

With a label in place: search: for (...) { for (...) { if (match) break search; } }. My default is the method with return: it's named, testable and reads top to bottom. I use a label when extraction would drag several mutable locals along.

Model answer

for (int i = 0; i <= Integer.MAX_VALUE; i++) { }   // 1: never ends
for (byte b = 0; b < 200; b++) { }                 // 2: never ends
for (float f = 0; f != 1.0f; f += 0.1f) { }        // 3: never ends
while (false) { System.out.println("x"); }         // 4: compile error
int n = 0;
for (int x = 0; x < 5; x++); { n++; }              // 5: ends, n is 1

1. i overflows from MAX_VALUE to MIN_VALUE, which is still <= MAX_VALUE.
2. b < 200 promotes b to int; a byte maxes at 127 and wraps to -128.
3. 0.1f isn't exactly representable; after ten steps f is 1.0000001, so it skips past 1.0f.
4. JLS 14.22 makes the body unreachable, which is a compile error. if (false) is allowed on purpose.
5. The stray ; is the loop body. The block runs once afterwards.