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.

Arrays.asList() — The Fixed-Size List That Looks Like an ArrayList

Arrays.asList() is a bridge between Java arrays and the Collection framework. It wraps an existing array into a List implementation backed by that array — no copying, no resizing. The returned object is a fixed-size list from java.util.Arrays' private inner class ArrayList (not java.util.ArrayList). This means you cannot add() or remove() elements; any attempt throws UnsupportedOperationException at runtime. The list is serializable and implements RandomAccess for O(1) index operations. Changes to the list write through to the original array and vice versa. Use Arrays.asList() when you need a List view of an array for legacy APIs, iteration, or passing to methods that accept Collection. Never use it when you need a dynamically growable list — that's new ArrayList<>(Arrays.asList(...)) or List.of() in Java 9+. In production, this distinction causes silent failures when code assumes add() works, leading to unexpected exceptions in data pipelines or batch processing.

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))
    }
}

Why Arrays Is a Final Utility Class You Can't Extend

You don't instantiate java.util.Arrays. It's a final class with a private constructor. All methods are static. This is deliberate: arrays are low-level primitives in the JVM, not objects you polymorph. The class exists solely to give you safe, optimized operations without reinventing sorting or binary search. Ever seen someone new Arrays() in production? That's a code smell from someone who skipped the docs. Use Arrays.sort() directly. The JVM inlines these calls aggressively. You get performance and readability. Plus, since it's final, you can't override equals() or hashCode() and break the contract. That's saved me from debugging a LOB application where a dev tried to subclass Arrays for logging. Don't. Just don't.

// io.thecodeforge
import java.util.Arrays;

public class ArraysFinalCheck {
    // Attempting to instantiate or subclass Arrays
    // This won't compile — comment out to test
    // public class MyArrays extends Arrays { }

    public static void main(String[] args) {
        // This is how you're meant to use it:
        int[] scores = {88, 72, 95, 61, 84};
        Arrays.sort(scores);
        System.out.println("Sorted scores: " + Arrays.toString(scores));
        /* Output:
           Sorted scores: [61, 72, 84, 88, 95]
        */
    }
}

binarySearch() — The Silent Bug That Eats Production Data

binarySearch() looks simple. You pass a sorted array and a key. It returns the index or a negative insertion point. But here's where juniors burn production: the array must be sorted first. If you search an unsorted array, the result is undefined — it can return wrong indices or negative values you misinterpret. I inherited a ticket where a payment batch system was double-processing invoices. Root cause? Dev called binarySearch on a list that wasn't sorted after a concurrent modification. The returned negative value was taken as 'not found', then the code inserted a duplicate. Always sort before search. Use the overloaded version with fromIndex and toIndex if you're working on subranges. And remember: the comparator version is for custom objects. If your Comparator is inconsistent with equals, expect chaos.

// io.thecodeforge
import java.util.Arrays;

public class BinarySearchSafe {
    public static void main(String[] args) {
        int[] invoiceIds = {304, 102, 589, 221, 456};
        
        // WRONG: search without sort
        // int result = Arrays.binarySearch(invoiceIds, 221);
        
        // RIGHT: sort first
        Arrays.sort(invoiceIds);
        int key = 221;
        int index = Arrays.binarySearch(invoiceIds, key);
        
        if (index >= 0) {
            System.out.println("Found invoice " + key + " at index " + index);
            // Output: Found invoice 221 at index 2
        } else {
            System.out.println("Insert at: " + (-index - 1));
        }
    }
}