What does this code print?

double[] d = new double[2];
boolean[] b = new boolean[2];
String[] s = new String[2];
System.out.println(d[0] + " " + b[1]
                   + " " + s[0]);

Every element of an array created with new gets its type's default value: double → 0.0, boolean → false, object (String) → null (and char → '\u0000'). Unlike local variables, array elements are never uninitialized, so C is wrong; the default for String is null, not "".

What does this code print?

int[] arr = {1, 2, 3};
int[] r = arr;
int[] k = Arrays.copyOf(arr, arr.length);
r[0] = 99;
k[1] = 50;
System.out.println(arr[0] + " " + arr[1]);

r = arr copies only the address: r and arr point to the same object on the heap, so r[0] = 99 changes the array. Arrays.copyOf creates a new object and copies the elements one by one (O(n)); a change to k doesn't show up in arr, so C is wrong.

What happens when this code runs?

int[] a = new int[5];
for (int i = 0; i <= a.length; i++)
    a[i] = i;

The valid indices are 0…length − 1 = 0…4; with <=, the last iteration accesses a[5] (off by one). Java checks every access at run time and throws an exception, which ends the program if uncaught. D is how C behaves, since it doesn't check. The fix is i < a.length.

If the user enters 0 as the size in readArray, what is printed?

double[] arr = readArray(sc);  // size 0
double sum = 0;
for (int i = 0; i < arr.length; i++)
    sum += arr[i];
System.out.println("Average: "
        + sum / arr.length);

new double[0] is a legal, empty array, so the loop never runs. 0.0 / 0 is floating-point division and gives NaN. B would be right if both the sum and the divisor were int. Better to warn the user.

If the Arrays.sort line is removed from the mode method, what does the code below print?

int[] s = {1, 4, 2, 4, 3, 4}; // unsorted
int best = s[0], bestCount = 1, count = 1;
for (int i = 1; i < s.length; i++) {
  if (s[i] == s[i - 1]) count++;
  else count = 1;
  if (count > bestCount) {
    bestCount = count; best = s[i];
  }
}
System.out.println(best);

The algorithm only counts equal neighbors. In this unsorted array no two neighbors are equal, so count stays 1, the record never changes, and the first element, 1, is returned. The real mode is 4 (A), but the 4s aren't adjacent, so it is never found. That is why the array must be sorted first.

When the loops finish, what is u[2][1][0], and how many times has the innermost assignment run?

int[][][] u = new int[3][3][3];
for (int x = 0; x < 3; x++)
  for (int y = 0; y < 3; y++)
    for (int z = 0; z < 3; z++)
      u[x][y][z] = x * 9 + y * 3 + z + 1;

2·9 + 1·3 + 0 + 1 = 22. Each dimension adds a nested loop: 3 × 3 × 3 = 27 assignments. B forgets the "+1", C counts only two loops, and D mixes up the weights (x·3 + y·9).

The loop condition in reverse has been changed as shown. What is {1, 2, 3, 4, 5} after the call?

int start = 0;
int end = arr.length - 1;
while (start < arr.length) { // changed
    int temp = arr[start];
    arr[start] = arr[end];
    arr[end] = temp;
    start++;
    end--;
}

The loop runs 5 times: (0, 4) and (1, 3) turn the array into {5, 4, 3, 2, 1}; (2, 2) swaps an element with itself; (3, 1) and (4, 0) swap the same pairs back, undoing the work. When start reaches 5 (end = −1) the loop ends, so a[−1] is never touched (B). A is what the correct condition (n/2 swaps) gives. D pictures only arr[start] = arr[end], without temp.