Java Language Specification — Arrays¶

int[] empty = new int[0];
System.out.println(empty.length);   // 0 — legal, not null
for (int x : empty) {               // zero iterations — no error
    System.out.println(x);
}

int[] ints = {1, 2, 3};
// long[] longs = ints;  // COMPILE ERROR: int[] is not a subtype of long[]
// Object[] objs = ints; // COMPILE ERROR: int[] is not a subtype of Object[]
Object obj = ints;       // OK: int[] IS a subtype of Object

String[] strings = new String[3];
Object[] objects = strings;         // widening reference
objects[0] = "hello";               // OK: String into String[]
try {
    objects[1] = new Integer(42);   // ArrayStoreException: Integer, not String
} catch (ArrayStoreException e) {
    System.out.println(e.getMessage());
}

int[][] triangle = new int[5][];
for (int i = 0; i < triangle.length; i++) {
    triangle[i] = new int[i + 1];  // row 0: length 1, row 1: length 2, etc.
}
System.out.println(triangle[4].length);  // 5

int[][] original = {{1, 2}, {3, 4}};
int[][] cloned = original.clone();     // shallow copy

cloned[0][0] = 99;                     // modifies original[0][0] too!
System.out.println(original[0][0]);    // 99

cloned[1] = new int[]{5, 6};           // does NOT affect original[1]
System.out.println(original[1][0]);    // 3

@SuppressWarnings("unchecked")
<T> T[] createArray(int size) {
    return (T[]) new Object[size];  // unchecked cast — safe if T is not reified
}

// Example 1: Array Fundamentals
// File: ArrayFundamentals.java
import java.util.Arrays;

public class ArrayFundamentals {
    public static void main(String[] args) {
        // 1D primitive array
        int[] numbers = new int[5];           // default: all zeros
        numbers[0] = 10;
        numbers[1] = 20;
        numbers[2] = 30;
        System.out.println("Length: " + numbers.length);   // 5
        System.out.println(Arrays.toString(numbers));       // [10, 20, 30, 0, 0]

        // Array initializer
        String[] fruits = {"apple", "banana", "cherry"};
        System.out.println(fruits[1]);          // banana

        // Enhanced for loop
        int sum = 0;
        for (int n : numbers) {
            sum += n;
        }
        System.out.println("Sum: " + sum);      // 60

        // Sorting
        int[] unsorted = {5, 2, 8, 1, 9, 3};
        Arrays.sort(unsorted);
        System.out.println(Arrays.toString(unsorted));  // [1, 2, 3, 5, 8, 9]

        // Binary search (on sorted array)
        int idx = Arrays.binarySearch(unsorted, 5);
        System.out.println("Index of 5: " + idx);       // 3

        // Filling and copying
        int[] filled = new int[5];
        Arrays.fill(filled, 42);
        System.out.println(Arrays.toString(filled));     // [42, 42, 42, 42, 42]

        int[] copy = Arrays.copyOf(numbers, 3);
        System.out.println(Arrays.toString(copy));       // [10, 20, 30]
    }
}

// Example 2: Multi-Dimensional Arrays
// File: MultiDimensionalArrays.java
import java.util.Arrays;

public class MultiDimensionalArrays {
    public static void main(String[] args) {
        // 2D rectangular array
        int[][] matrix = new int[3][4];
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 4; j++) {
                matrix[i][j] = i * 4 + j;
            }
        }
        System.out.println(Arrays.deepToString(matrix));
        // [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]]

        // 2D jagged array
        int[][] triangle = new int[4][];
        for (int i = 0; i < 4; i++) {
            triangle[i] = new int[i + 1];
            Arrays.fill(triangle[i], i + 1);
        }
        System.out.println(Arrays.deepToString(triangle));
        // [[1], [2, 2], [3, 3, 3], [4, 4, 4, 4]]

        // Inline 2D initializer
        int[][] grid = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        System.out.println("Center: " + grid[1][1]);  // 5

        // Matrix multiplication
        int[][] a = {{1, 2}, {3, 4}};
        int[][] b = {{5, 6}, {7, 8}};
        int[][] result = multiply(a, b);
        System.out.println(Arrays.deepToString(result));
        // [[19, 22], [43, 50]]
    }

    static int[][] multiply(int[][] a, int[][] b) {
        int n = a.length;
        int[][] result = new int[n][n];
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                for (int k = 0; k < n; k++)
                    result[i][j] += a[i][k] * b[k][j];
        return result;
    }
}

// Example 3: Array Covariance and ArrayStoreException
// File: ArrayCovariance.java
public class ArrayCovariance {
    public static void main(String[] args) {
        // Legal widening (covariance)
        String[] strings = {"hello", "world"};
        Object[] objects = strings;           // String[] is-a Object[]

        // Safe write
        objects[0] = "new value";
        System.out.println(strings[0]);       // new value

        // ArrayStoreException: writing wrong type
        try {
            objects[1] = 42;                  // Integer is NOT a String
        } catch (ArrayStoreException e) {
            System.out.println("ArrayStoreException: " + e.getMessage());
        }

        // Safe pattern: instanceof check
        Object[] mixed = new Object[3];
        mixed[0] = "hello";
        mixed[1] = 42;
        mixed[2] = 3.14;

        for (Object obj : mixed) {
            if (obj instanceof String s) {
                System.out.println("String: " + s.toUpperCase());
            } else if (obj instanceof Integer i) {
                System.out.println("Integer: " + (i * 2));
            }
        }
    }
}

// Example 4: Arrays and Streams (Java 8+)
// File: ArrayStreams.java
import java.util.Arrays;
import java.util.stream.IntStream;

public class ArrayStreams {
    public static void main(String[] args) {
        int[] numbers = {5, 3, 8, 1, 9, 2, 7, 4, 6};

        // Stream operations on array
        int sum = Arrays.stream(numbers).sum();
        System.out.println("Sum: " + sum);          // 45

        double avg = Arrays.stream(numbers).average().orElse(0);
        System.out.printf("Average: %.1f%n", avg);  // 5.0

        int max = Arrays.stream(numbers).max().orElse(0);
        System.out.println("Max: " + max);           // 9

        long count = Arrays.stream(numbers).filter(n -> n > 5).count();
        System.out.println("Count > 5: " + count);  // 4

        int[] filtered = Arrays.stream(numbers)
            .filter(n -> n % 2 == 0)
            .sorted()
            .toArray();
        System.out.println("Even sorted: " + Arrays.toString(filtered));
        // [2, 4, 6, 8]

        // Generate array with streams
        int[] squares = IntStream.rangeClosed(1, 10)
            .map(n -> n * n)
            .toArray();
        System.out.println("Squares: " + Arrays.toString(squares));

        // Parallel sort (large arrays benefit from this)
        int[] large = IntStream.range(0, 1_000_000)
            .map(i -> (int)(Math.random() * 1_000_000))
            .toArray();
        Arrays.parallelSort(large);
        System.out.println("Parallel sorted. First: " + large[0] + ", Last: " + large[large.length-1]);

        // mismatch (Java 9+)
        int[] arr1 = {1, 2, 3, 4, 5};
        int[] arr2 = {1, 2, 99, 4, 5};
        int mismatchIdx = Arrays.mismatch(arr1, arr2);
        System.out.println("First mismatch at index: " + mismatchIdx);  // 2
    }
}

// Example 5: Practical Array Algorithms
// File: ArrayAlgorithms.java
import java.util.Arrays;

public class ArrayAlgorithms {

    // Reverse an array in-place
    static void reverse(int[] arr) {
        int left = 0, right = arr.length - 1;
        while (left < right) {
            int tmp = arr[left];
            arr[left++] = arr[right];
            arr[right--] = tmp;
        }
    }

    // Rotate array left by k positions
    static int[] rotateLeft(int[] arr, int k) {
        int n = arr.length;
        if (n == 0) return arr;
        k = k % n;
        int[] result = new int[n];
        System.arraycopy(arr, k, result, 0, n - k);
        System.arraycopy(arr, 0, result, n - k, k);
        return result;
    }

    // Two-sum: find indices with target sum
    static int[] twoSum(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[i] + nums[j] == target) {
                    return new int[]{i, j};
                }
            }
        }
        return new int[]{-1, -1};
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};

        reverse(arr);
        System.out.println(Arrays.toString(arr));   // [5, 4, 3, 2, 1]

        int[] rotated = rotateLeft(new int[]{1, 2, 3, 4, 5}, 2);
        System.out.println(Arrays.toString(rotated)); // [3, 4, 5, 1, 2]

        int[] indices = twoSum(new int[]{2, 7, 11, 15}, 9);
        System.out.println(Arrays.toString(indices)); // [0, 1]

        // 2D array: find maximum element
        int[][] grid = {{3, 1, 4}, {1, 5, 9}, {2, 6, 5}};
        int max = Arrays.stream(grid)
            .flatMapToInt(Arrays::stream)
            .max()
            .orElse(Integer.MIN_VALUE);
        System.out.println("Grid max: " + max);  // 9
    }
}