Arrays & Arrays Utility

Declaration & Allocation

int[] a;                    // declare
a = new int[5];             // allocate (zero-initialised)
int[] b = new int[5];       // declare + allocate
int[] c = {10, 20, 30};     // literal
int[] d = new int[]{10, 20, 30};   // explicit form (needed in returns/args)
String[] words = new String[3];     // [null, null, null]

> Reference-type arrays default to null. Numeric arrays default to 0 (or 0.0). boolean[] defaults to false.

Length

int len = a.length;     // FIELD — no parentheses!

String uses length() (method), arrays use length (field). Easy to swap by mistake.

Indexing

Zero-based. Out-of-range access throws ArrayIndexOutOfBoundsException at runtime:

int[] a = {10, 20, 30};
a[3];   // throws ArrayIndexOutOfBoundsException
a[-1];  // also throws

Iteration Patterns

int[] a = {10, 20, 30};
// Index access
for (int i = 0; i < a.length; i++) System.out.println(a[i]);
// Foreach (clearest)
for (int x : a) System.out.println(x);
// Index + value (manual)
for (int i = 0; i < a.length; i++) {
    System.out.printf("%d -> %d%n", i, a[i]);
}

2D Arrays — Array of Arrays

Java has no true 2D arrays — they're arrays of arrays, which means rows can be different lengths (jagged):

int[][] mat = new int[3][4];        // 3×4 rectangular
mat[0][0] = 1;
int rows = mat.length;
int cols = mat[0].length;
int[][] jagged = {
    {1, 2},
    {3, 4, 5},
    {6}
};
for (int[] row : jagged) {
    for (int v : row) System.out.print(v + " ");
    System.out.println();
}

Copying

int[] a = {1, 2, 3, 4, 5};
// Shallow copy (whole array, same length)
int[] b = a.clone();
// Resize
int[] bigger = Arrays.copyOf(a, 10);             // pads with 0s
int[] slice  = Arrays.copyOfRange(a, 1, 4);      // [2,3,4]
// Manual / partial copy
int[] dst = new int[5];
System.arraycopy(a, 0, dst, 0, a.length);

> clone() is shallow. For String[][] you'd need to clone each row separately to deep-copy.

java.util.Arrays — The Toolbox

import java.util.Arrays;
int[] a = {3, 1, 4, 1, 5, 9, 2, 6};
Arrays.sort(a);                          // in-place, dual-pivot quicksort, O(n log n)
Arrays.sort(a, 2, 5);                    // sort range [2..5)
int  idx = Arrays.binarySearch(a, 4);    // O(log n) — array MUST be sorted
Arrays.fill(a, 0);                        // fill all with 0
Arrays.fill(a, 2, 5, -1);                 // fill range with -1
System.out.println(Arrays.toString(a));   // "[3, 1, 4, 1, 5]"
System.out.println(Arrays.equals(a, b));  // element-wise equality
// 2D
int[][] m = { {1,2}, {3,4} };
System.out.println(Arrays.deepToString(m));   // "[[1, 2], [3, 4]]"
System.out.println(Arrays.deepEquals(m, n));

Sorting Objects

Integer[] nums = {3, 1, 4, 1, 5};
Arrays.sort(nums);                                    // natural order
Arrays.sort(nums, Comparator.reverseOrder());         // descending
Arrays.sort(strs, Comparator.comparingInt(String::length));   // by length

> Note: Arrays.sort on int[] (primitive) → quicksort. On Integer[] (object) → stable mergesort. Different guarantees.

Array → Stream → List

import java.util.Arrays;
import java.util.List;
int[] a = {1, 2, 3};
int sum = Arrays.stream(a).sum();
int max = Arrays.stream(a).max().getAsInt();
int[] doubled = Arrays.stream(a).map(x -> x * 2).toArray();
String[] names = {"Asha", "Bishan"};
List<String> list = Arrays.asList(names);              // FIXED-SIZE view!
List<String> mutable = new ArrayList<>(Arrays.asList(names));   // resizable copy

> ⚠️ Arrays.asList returns a fixed-size, backing-array-shared list. add/remove throw UnsupportedOperationException. Wrap in new ArrayList<>(...) if you need a real list.

Array vs ArrayList

Use arrays when size is known + speed matters. Use ArrayList for dynamic data — covered in Collections.

Common Patterns

Reverse in place

static void reverse(int[] a) {
    int i = 0, j = a.length - 1;
    while (i < j) {
        int t = a[i]; a[i] = a[j]; a[j] = t;
        i++; j--;
    }
}

Frequency count

int[] freq = new int[26];
for (char c : "hello".toCharArray()) freq[c - 'a']++;

Two-pointer sum

static int[] twoSumSorted(int[] a, int target) {
    int i = 0, j = a.length - 1;
    while (i < j) {
        int s = a[i] + a[j];
        if (s == target) return new int[]{i, j};
        if (s < target) i++; else j--;
    }
    return new int[]{-1, -1};
}

Common Mistakes

You can now wield Java's fixed-size containers. Next: classes — your own types.