Java-specific arrays

Arrays.copyOf(a, newLength) returns a new array of the given length: it pads with zeros (or null, false) when longer and truncates when shorter. copyOfRange(a, from, to) copies a slice, with to exclusive and allowed to exceed the length. Both are O(newLength).

Use them to grow a buffer or take a prefix or slice.

1int[] a = {1, 2, 3, 4, 5};
2int[] longer = Arrays.copyOf(a, 7);          // {1, 2, 3, 4, 5, 0, 0}
3int[] prefix = Arrays.copyOf(a, 3);          // {1, 2, 3}
4int[] slice = Arrays.copyOfRange(a, 1, 4);   // {2, 3, 4}

Arrays.fill(a, value) sets every element; Arrays.fill(a, from, to, value) sets a range with to exclusive. Common uses: initialise a distance array to a large value, or reset a counter array between test cases. For arrays of arrays, fill each row separately.

Do not fill a 2D array with one shared row: all rows would be the same object.

1int[] dist = new int[6];
2Arrays.fill(dist, Integer.MAX_VALUE / 2);        // large, but adding two of them cannot overflow
3int[][] grid = new int[3][4];
4for (int[] row : grid) Arrays.fill(row, -1);      // each row separately

System.arraycopy(src, srcPos, dest, destPos, length) is a native block copy. It works correctly when source and destination are the same array with overlapping ranges, which makes it the tool for shifting elements in insert and delete. It throws if a range is out of bounds.

It is typically faster than a hand-written copy loop.

1int[] a = {1, 2, 3, 4, 5, 0};
2System.arraycopy(a, 2, a, 3, 3);      // shift a[2..4] right by one (overlap is safe)
3a[2] = 99;                             // {1, 2, 99, 3, 4, 5}

a.equals(b) on an array compares references, so two arrays with the same contents are not equal. Arrays.equals(a, b) compares length and elements. For nested arrays use Arrays.deepEquals. Arrays.hashCode pairs with Arrays.equals for use as a hash key, though a List or record is usually safer.

Printing an array directly shows its identity, not its values.

1int[] a = {1, 2, 3}, b = {1, 2, 3};
2boolean ref = a.equals(b);               // false: different objects
3boolean val = Arrays.equals(a, b);       // true
4String text = Arrays.toString(a);        // "[1, 2, 3]"
5int cmp = Arrays.compare(a, new int[]{1, 2, 4});   // negative: a is smaller

Arrays of arrays need the deep variants: Arrays.deepToString, Arrays.deepEquals and Arrays.deepHashCode. clone() on a 2D array copies only the row references (a shallow copy); build a deep copy row by row.

Step through the shallow and deep copy cases in the animation.

1int[][] g = {{1, 2}, {3, 4}};
2System.out.println(Arrays.deepToString(g));       // [[1, 2], [3, 4]]
3int[][] deep = new int[g.length][];
4for (int i = 0; i < g.length; i++) deep[i] = g[i].clone();
5boolean same = Arrays.deepEquals(g, deep);        // true: equal contents, independent rows

1int[] a = { 10, 20, 30, 40 };               // options 0 and 1 use this 1D array
2int[] b = a;                                // option 0: copies the reference only
3int[] b = a.clone();                        // option 1: copies the elements
4int[][] a2 = { { 10, 20 }, { 30, 40 } };    // options 2 and 3 use this 2D array
5int[][] b2 = a2.clone();                    // option 2: new outer array, SAME row objects
6int[][] b2 = Arrays.stream(a2).map(int[]::clone).toArray(int[][]::new);   // option 3: rows copied too
7b[idx] = v;                                 // (b2[0][idx] = v for options 2 and 3)
8System.out.println(Arrays.toString(a));     // does a see the change?

ArrayList keeps an Object[] buffer. An empty list starts with no buffer; the first add allocates 10 slots, and when the buffer is full it grows by about 50%: newCapacity = old + (old >> 1), giving 10, 15, 22, 33, ... Each growth copies the existing references, so n adds cost O(n) in total and every add is amortised O(1). ensureCapacity and the ArrayList(int) constructor avoid the intermediate copies; trimToSize releases the spare room.

Choose the ArrayList preset in the animation to see this growth sequence.

1List<Integer> xs = new ArrayList<>();
2for (int i = 0; i < 100; i++) xs.add(i);     // resizes at sizes 10, 15, 22, 33, 49, 73
3List<Integer> ys = new ArrayList<>(100);     // one allocation, no resizes during the loop
4for (int i = 0; i < 100; i++) ys.add(i);

1void add(int x) {
2    if (size == data.length) {                        // buffer is full
3        data = Arrays.copyOf(data, newCapacity());     // allocate bigger, copy size elements
4    }
5    data[size++] = x;
6}
7int removeLast() {
8    int x = data[--size];
9    if (size <= data.length / 4) data = Arrays.copyOf(data, Math.max(1, data.length / 2));   // optional shrink
10    return x;
11}