Arrays & Multidimensional Arrays

int[] numbers = new int[5];  // all elements default to 0
numbers[0] = 10;
numbers[1] = 20;

int[] literal = {1, 2, 3, 4, 5};  // initializer syntax
System.out.println(literal[2]);  // prints 3
System.out.println(literal.length);  // prints 5, note: .length is a field, not a method

Common follow-ups: Why is array.length a field access rather than a method call, unlike String's .length()?;What happens if you access an index outside the array's bounds?

int[][] matrix = new int[3][4];  // 3 rows, each with 4 columns (rectangular)
matrix[1][2] = 99;

int[][] jagged = new int[3][];  // 3 rows, columns not yet specified
jagged[0] = new int[2];
jagged[1] = new int[5];  // different length than row 0 -- legal, since it's an array of arrays
jagged[2] = new int[1];

Common follow-ups: How would you iterate a jagged array safely without an IndexOutOfBoundsException from assuming uniform row length?;What's the memory/performance implication of the array-of-arrays structure versus a true contiguous 2D block?

Object[] arr = new String[3];  // legal due to covariance
arr[0] = "hello";  // fine, actual runtime type is String[]
arr[1] = Integer.valueOf(42);  // compiles fine (Object accepts Integer)... but throws ArrayStoreException at RUNTIME

Common follow-ups: Why did Java's generics designers choose invariance (List<String> is NOT a List<Object>) specifically to avoid this exact array pitfall?;How does the JVM implement the runtime check that throws ArrayStoreException?

int[] nums = {5, 2, 8, 1, 9};
Arrays.sort(nums);  // {1, 2, 5, 8, 9}
int index = Arrays.binarySearch(nums, 8);  // 3

int[] copy = Arrays.copyOf(nums, 3);  // {1, 2, 5}
int[][] matrix1 = {{1,2},{3,4}};
int[][] matrix2 = {{1,2},{3,4}};
System.out.println(Arrays.equals(matrix1, matrix2));      // false -- compares references of inner arrays
System.out.println(Arrays.deepEquals(matrix1, matrix2));  // true -- recursively compares contents

Common follow-ups: Why does Arrays.equals() give a misleading false result for nested arrays, requiring deepEquals() instead?;What are the performance characteristics of Arrays.sort() for primitives versus objects?

int[] source = {1, 2, 3, 4, 5};

// Fastest for a pre-allocated destination
int[] dest = new int[5];
System.arraycopy(source, 0, dest, 0, source.length);

// Convenient, internally uses System.arraycopy
int[] resized = Arrays.copyOf(source, 10);  // pads with zeros

// Merging two arrays efficiently
int[] merged = new int[source.length + dest.length];
System.arraycopy(source, 0, merged, 0, source.length);
System.arraycopy(dest, 0, merged, source.length, dest.length);

Common follow-ups: What are JIT intrinsics, and why do they make System.arraycopy() faster than equivalent hand-written Java code?;When would ArrayList's internal resizing behavior be preferable to manually managing raw array resizing?

Integer[] arr = {1, 2, 3};
List<Integer> fixedView = Arrays.asList(arr);  // backed by arr, fixed-size
// fixedView.add(4);  // throws UnsupportedOperationException!

List<Integer> resizable = new ArrayList<>(Arrays.asList(arr));  // truly independent, resizable copy
resizable.add(4);  // works fine

Integer[] backToArray = resizable.toArray(new Integer[0]);

Common follow-ups: Why does Arrays.asList() exist as a fixed-size view instead of just returning a full ArrayList directly?;What's the difference in behavior between toArray(new T[0]) and the newer toArray(T[]::new) method reference syntax?

public static void rotate90Clockwise(int[][] matrix) {
    int n = matrix.length;
    // Step 1: transpose in place
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int temp = matrix[i][j];
            matrix[i][j] = matrix[j][i];
            matrix[j][i] = temp;
        }
    }
    // Step 2: reverse each row
    for (int[] row : matrix) {
        for (int left = 0, right = row.length - 1; left < right; left++, right--) {
            int temp = row[left];
            row[left] = row[right];
            row[right] = temp;
        }
    }
}

Common follow-ups: What's the time and space complexity of this in-place approach compared to a naive approach allocating a new rotated matrix?;How would this algorithm need to change for a non-square (rectangular) matrix?

int[] arr = {1, 2, 3};
try {
    System.out.println(arr[5]);  // throws ArrayIndexOutOfBoundsException
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Invalid index: " + e.getMessage());
}

Common follow-ups: How does JIT compiler bounds-check elimination work, and under what conditions can it safely skip the runtime check?;What's the performance cost of bounds checking in a very tight, performance-critical loop?

public class SimpleDynamicArray<T> {
    private Object[] data = new Object[10];
    private int size = 0;

    public void add(T element) {
        if (size == data.length) {
            data = Arrays.copyOf(data, data.length * 2);  // double capacity
        }
        data[size++] = element;
    }

    @SuppressWarnings("unchecked")
    public T get(int index) {
        if (index < 0 || index >= size) throw new IndexOutOfBoundsException();
        return (T) data[index];
    }

    public int size() { return size; }
}

Common follow-ups: Why is doubling (rather than, say, adding a fixed increment) the standard growth strategy, and what's the amortized cost analysis proving O(1) add?;What would change about this implementation to support removing elements while maintaining correct amortized performance?

int[][] matrix = {{1,2,3},{4,5,6}};

// for-each: simpler for read-only traversal
for (int[] row : matrix) {
    for (int value : row) {
        System.out.print(value + " ");
    }
}

// indexed: needed when mutating in place or requiring the index
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        matrix[i][j] *= 2;  // requires index-based access to mutate
    }
}

Common follow-ups: Why can't you assign to the for-each loop variable to modify the underlying array element?;What's the subtle bug risk of using the same variable name for both the outer and inner loop's for-each variable?