Arrays.asList() — Why add() Silently Fails in Production

Java arrays are low-level. They know their length and hold values. That's about it. Need to sort them? Write your own Quicksort. Need to search? Write a loop. Need to compare two arrays for equality? Loop through every element. The Arrays utility class exists because writing this boilerplate over and over is a waste of your time and a source of subtle bugs.

Arrays is one of the most-used classes in the Java standard library. It's not glamorous — no one brags about knowing Arrays — but every senior developer reaches for it constantly. It contains the stable, battle-tested implementations of algorithms you'd otherwise have to reimplement. Knowing which method does what, and more importantly, what each method does NOT do, separates efficient code from code that crashes at runtime.

By the end you'll know how to sort, search, copy, fill, and compare arrays using the standard library. You'll also know the gotchas: why asList returns an unmodifiable list, why binarySearch returns a negative insertion point, and why deepEquals exists for multi-dimensional arrays.

Sorting Arrays

Arrays.sort() is the workhorse of the utility class. For primitive arrays (int[], double[], char[]), it uses Dual-Pivot Quicksort — an O(n log n) algorithm that's faster than traditional Quicksort on most real-world data. For object arrays (String[], Integer[], custom objects), it uses TimSort, a hybrid of merge sort and insertion sort that's stable (preserves order of equal elements) and performs well on partially-sorted data.

You can sort the entire array or a specific range: Arrays.sort(numbers, fromIndex, toIndex). The toIndex is exclusive, so sort(arr, 1, 4) sorts indices 1, 2, 3 only.

Sorting objects requires the class to implement Comparable (natural order) or you provide a Comparator. The Comparator version is powerful: Arrays.sort(people, Comparator.comparing(Person::getAge).reversed()) sorts by age descending using method references.

For parallel processing of large arrays (>8K elements), Arrays.parallelSort() uses the Fork/Join framework to split the array across CPU cores. It's significantly faster on multi-core systems for arrays > 1M elements.

package io.thecodeforge.java.arrays;

import java.util.Arrays;

public class ArraysSortDemo {
    public static void main(String[] args) {
        int[] numbers = {5, 2, 8, 1, 9, 3};
        Arrays.sort(numbers);
        System.out.println(Arrays.toString(numbers)); // [1, 2, 3, 5, 8, 9]

        // Sort a range (from index 1 to 4, exclusive end)
        int[] partial = {5, 2, 8, 1, 9, 3};
        Arrays.sort(partial, 1, 4);  // sorts indices 1,2,3 only
        System.out.println(Arrays.toString(partial)); // [5, 1, 2, 8, 9, 3]

        // Sort objects — natural order (Comparable)
        String[] words = {"banana", "apple", "cherry", "date"};
        Arrays.sort(words);
        System.out.println(Arrays.toString(words));   // [apple, banana, cherry, date]

        // Sort objects — custom Comparator (by length)
        Arrays.sort(words, (a, b) -> a.length() - b.length());
        System.out.println(Arrays.toString(words));   // [date, apple, banana, cherry]
    }
}

Searching, Copying, and Filling

Arrays.binarySearch() performs an O(log n) search on a sorted array. It returns the index of the element if found, otherwise a negative value: -(insertion point) - 1. This negative value tells you where the element would be inserted to keep the array sorted. The array MUST be sorted before calling binarySearch — otherwise the result is undefined.

Arrays.copyOf() creates a new array copy. It takes the original array and a new length. If the new length is larger than the original, extra elements are filled with default values (0 for int, false for boolean, null for objects). If smaller, the array is truncated.

Arrays.fill() sets all elements (or a range) to a specific value. It's useful for initializing arrays to a known state before use. For large arrays, fill is efficient because it operates on the underlying memory directly.

Arrays.equals() compares two arrays element by element. The arrays must be the same length and all elements must be equal (using .equals() for objects). For multi-dimensional arrays, use deepEquals() which recursively compares nested arrays.

package io.thecodeforge.java.arrays;

import java.util.Arrays;

public class ArraysUtilities {
    public static void main(String[] args) {
        int[] sorted = {1, 3, 5, 7, 9, 11};

        // binarySearch — MUST be sorted first
        System.out.println(Arrays.binarySearch(sorted, 7));  // 3 (index)
        System.out.println(Arrays.binarySearch(sorted, 4));  // negative = not found

        // copyOf — new array, truncates or pads with zeros
        int[] copy = Arrays.copyOf(sorted, 4);
        System.out.println(Arrays.toString(copy));   // [1, 3, 5, 7]

        int[] extended = Arrays.copyOf(sorted, 8);
        System.out.println(Arrays.toString(extended)); // [1, 3, 5, 7, 9, 11, 0, 0]

        // copyOfRange — copy a slice
        int[] slice = Arrays.copyOfRange(sorted, 2, 5);
        System.out.println(Arrays.toString(slice));  // [5, 7, 9]

        // fill — initialise all elements
        int[] grid = new int[5];
        Arrays.fill(grid, -1);
        System.out.println(Arrays.toString(grid));   // [-1, -1, -1, -1, -1]

        // equals and deepEquals
        int[] a = {1, 2, 3};
        int[] b = {1, 2, 3};
        System.out.println(a == b);           // false — different references
        System.out.println(Arrays.equals(a, b)); // true  — element comparison
    }
}

Arrays.stream and Arrays.asList

Arrays.stream() turns an array into a Stream for functional operations. For primitive arrays (int[], double[], long[]), it returns a specialized stream (IntStream, DoubleStream, LongStream) that provides efficient operations like sum(), average(), and boxed(). For object arrays, it returns a regular Stream<T>.

The stream is sequential by default. For parallel processing, use .parallel() on the stream: Arrays.stream(arr).parallel().map(...).toArray().

Arrays.asList() is the most misunderstood method in the class. It returns a fixed-size List view of the array — NOT a mutable ArrayList. Changes to the array are reflected in the list, and vice versa. But you cannot add or remove elements — those operations throw UnsupportedOperationException.

To get a mutable list, wrap it: new ArrayList<>(Arrays.asList(arr)). For Java 9+, List.of(arr) returns an immutable list; wrapping with new ArrayList<>(List.of(arr)) gives a mutable copy.

package io.thecodeforge.java.arrays;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

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

        // Arrays.stream — IntStream for primitives
        int sum = Arrays.stream(numbers).sum();
        System.out.println("Sum: " + sum);  // 55

        double avg = Arrays.stream(numbers).average().orElse(0);
        System.out.println("Avg: " + avg);  // 5.5

        int[] evens = Arrays.stream(numbers)
                           .filter(n -> n % 2 == 0)
                           .toArray();
        System.out.println(Arrays.toString(evens));  // [2, 4, 6, 8, 10]

        // Arrays.asList — fixed-size List view (add/remove throw UnsupportedOperationException)
        String[] arr = {"a", "b", "c"};
        List<String> list = Arrays.asList(arr);
        list.set(0, "x");  // set works — modifies underlying array
        System.out.println(Arrays.toString(arr));  // [x, b, c]
        // list.add("d");  // throws UnsupportedOperationException

        // For a mutable list, wrap: new ArrayList<>(Arrays.asList(arr))
    }
}