Java Arrays Utility Class

java.util.Arrays is a final utility class of static methods for working with arrays — Java's most fundamental data structure. Before Arrays, printing an array meant writing a loop, copying a subrange meant manual index arithmetic, and sorting with a custom order meant implementing the entire sort algorithm. Arrays provides all of these as one-liners, and since Java 8 it bridges arrays into the streams world with Arrays.stream() and speeds up large-array sorts with Arrays.parallelSort().

What Is java.util.Arrays?

java.util.Arrays is a final class that cannot be instantiated or subclassed. Every method is static and operates directly on Java array references — it does not wrap arrays in objects or alter their type.

java.util.Arrays
    ← final class, cannot be subclassed
    ← cannot be instantiated (private constructor)
    ← all methods are static
    ← since Java 1.2, extended through Java 21

FUNCTIONAL AREAS:
  ┌─────────────────────────────────────────────────────────────────┐
  │  SORT                                                            │
  │    sort(array)                    full sort, natural/numeric ASC │
  │    sort(array, fromIndex, toIndex)range sort (partial)           │
  │    sort(T[], Comparator)          custom order for object arrays │
  │    sort(T[], from, to, Comparator)range sort with Comparator     │
  │    parallelSort(array)            ForkJoin parallel sort O(n/p)  │
  │    parallelSort(array, from, to)  parallel range sort            │
  ├─────────────────────────────────────────────────────────────────┤
  │  SEARCH                                                          │
  │    binarySearch(array, key)       O(log n) — array must be sorted│
  │    binarySearch(array, from, to, key)  range binary search       │
  │    binarySearch(T[], key, Comparator)  with Comparator           │
  ├─────────────────────────────────────────────────────────────────┤
  │  COPY                                                            │
  │    copyOf(array, newLength)       copy + resize to newLength     │
  │    copyOfRange(array, from, to)   copy subrange [from, to)       │
  ├─────────────────────────────────────────────────────────────────┤
  │  FILL                                                            │
  │    fill(array, value)             set all elements to value      │
  │    fill(array, from, to, value)   set range [from, to) to value  │
  ├─────────────────────────────────────────────────────────────────┤
  │  COMPARE & HASH                                                  │
  │    equals(a1, a2)                 shallow element-by-element     │
  │    deepEquals(a1, a2)             recursive for nested arrays    │
  │    hashCode(array)                hash from element values       │
  │    deepHashCode(array)            recursive hash                 │
  │    compare(a1, a2)                lexicographic comparison       │
  │    compareUnsigned(a1, a2)        unsigned byte/short/int/long   │
  │    mismatch(a1, a2)               index of first difference      │
  ├─────────────────────────────────────────────────────────────────┤
  │  CONVERT                                                         │
  │    toString(array)                "[e1, e2, e3]" human-readable  │
  │    deepToString(array)            recursive for nested arrays    │
  │    asList(T... elements)          fixed-size List backed by array│
  ├─────────────────────────────────────────────────────────────────┤
  │  STREAM (Java 8+)                                                │
  │    stream(array)                  IntStream / LongStream /       │
  │    stream(array, from, to)        DoubleStream / Stream<T>       │
  ├─────────────────────────────────────────────────────────────────┤
  │  PARALLEL OPERATIONS (Java 8+)                                   │
  │    parallelSetAll(array, generator)   fill using index function  │
  │    parallelPrefix(array, operator)    running aggregate in place │
  └─────────────────────────────────────────────────────────────────┘

Basic Overview — Primitive vs Object Arrays

IMPORTANT: Most Arrays methods have OVERLOADS for every primitive type.

  Arrays.sort(int[])        → dual-pivot quicksort, not stable
  Arrays.sort(long[])       → dual-pivot quicksort, not stable
  Arrays.sort(double[])     → dual-pivot quicksort, not stable
  Arrays.sort(byte[])       → dual-pivot quicksort, not stable
  Arrays.sort(char[])       → dual-pivot quicksort, not stable
  Arrays.sort(Object[])     → TimSort, STABLE (preserves equal-element order)
  Arrays.sort(T[], Comparator<T>) → TimSort, STABLE (uses Comparator)

  WHY TWO DIFFERENT ALGORITHMS:
    Primitive arrays use dual-pivot quicksort (Yaroslavskiy, 2009).
    Average O(n log n), faster than mergesort for primitives in practice.
    NOT stable — equal elements may be reordered.
    BUT primitives have no identity — equal int values are indistinguishable,
    so instability does not matter.

    Object arrays use TimSort (a merge-insertion hybrid).
    STABLE — equal elements preserve their original relative order.
    Stability matters for objects: two Employee objects with the same salary
    should not swap positions unexpectedly.

  NULL HANDLING:
    Primitive arrays: nulls impossible (primitives cannot be null)
    Object arrays: sort() does NOT handle nulls in the array —
    NullPointerException if the array contains null elements.
    Use a null-handling Comparator explicitly:
    Arrays.sort(arr, Comparator.nullsLast(Comparator.naturalOrder()))

When to Use Arrays Methods

USE Arrays.sort() WHEN:
  - Sorting a plain Java array (not a List)
  - Primitive arrays: fastest sort available for int[], double[], etc.
  - Object arrays with natural ordering or custom Comparator
  - Partial sort of a subrange: sort(array, fromIndex, toIndex)

USE Arrays.parallelSort() WHEN:
  - Array has ~10,000+ elements (below that, sequential is faster)
  - Multiple CPU cores are available (uses ForkJoinPool.commonPool())
  - The sort is a bottleneck in a performance-sensitive path

USE Arrays.binarySearch() WHEN:
  - The array is already sorted (required precondition)
  - O(log n) lookup needed instead of O(n) linear scan
  - Always sort with Arrays.sort() before calling binarySearch()

USE Arrays.copyOf() / copyOfRange() WHEN:
  - Creating a new array of different length from an existing one
  - Defensive copies of array fields in immutable classes
  - Extracting subarrays without index arithmetic

USE Arrays.fill() WHEN:
  - Initialising an array to a non-zero/non-null default value
  - Resetting an array between uses
  - Filling a subrange with a sentinel value

USE Arrays.equals() / deepEquals() WHEN:
  - Comparing arrays by content (== compares references, not content)
  - equals() for 1D arrays; deepEquals() for multi-dimensional
  - Arrays.hashCode() / deepHashCode() for use in hash-based collections

USE Arrays.asList() WHEN:
  - Converting a fixed set of values into a List for Collection operations
  - Passing array elements to methods that accept List
  - Caution: returns a FIXED-SIZE list — add() and remove() throw

USE Arrays.stream() WHEN:
  - Processing array elements with Stream API: filter, map, reduce
  - Converting a primitive array to a stream without boxing overhead
  - Building pipeline operations on array data without copying to a List

How Arrays Methods Work Internally

Arrays.sort() — DUAL-PIVOT QUICKSORT for primitives:
  Uses two pivot elements instead of one.
  Divides the array into three parts: less-than-left-pivot,
  between-pivots, greater-than-right-pivot.
  Average O(n log n), better constant factors than classic quicksort.
  Worst case O(n²) for adversarial inputs — uncommon with dual-pivot.
  NOT stable — does not matter for primitives (no identity).

Arrays.sort() — TIMSORT for Object arrays:
  Hybrid merge/insertion sort.
  Detects naturally sorted "runs" in the data and merges them.
  Performs in O(n) for already-sorted arrays — O(n log n) worst case.
  STABLE — objects with equal keys preserve their original order.

Arrays.parallelSort():
  Uses ForkJoinPool.commonPool().
  Splits array into chunks, sorts each chunk in parallel, then merges.
  Threshold (~8192 elements) below which it falls back to sequential sort.
  Same stability guarantee as Arrays.sort() for objects.

Arrays.binarySearch():
  Requires sorted array. Returns index if found.
  Returns -(insertionPoint) - 1 if not found.
  Same semantics as Collections.binarySearch().

Arrays.copyOf(T[] original, int newLength):
  Calls System.arraycopy() internally — native, extremely fast.
  If newLength > original.length: extra slots filled with 0/false/null.
  If newLength < original.length: truncated copy.
  Allocates a new array — does not modify original.

Arrays.asList(T... elements):
  Returns a fixed-size List backed by the array — NOT a new ArrayList.
  Changes to the returned list WRITE THROUGH to the original array.
  add() and remove() throw UnsupportedOperationException.
  To get a resizable List: new ArrayList<>(Arrays.asList(array))

Core Operations with Examples

Sorting and Searching

Output:
Before sort : [72, 45, 91, 38, 67, 88, 55, 79]
After sort  : [38, 45, 55, 67, 72, 79, 88, 91]
Partial sort[2,6): [72, 45, 38, 67, 88, 91, 55, 79]

Before sort : [Mumbai, Delhi, Bengaluru, Chennai, Hyderabad, Ahmedabad]
After sort  : [Ahmedabad, Bengaluru, Chennai, Delhi, Hyderabad, Mumbai]
By length+alpha: [Delhi, Mumbai, Chennai, Bengaluru, Ahmedabad, Hyderabad]

binarySearch(40)  : 3
binarySearch(35)  : -4
insertion point   : 3

sort vs parallelSort same result: true
largeArray[0..4] after sort: [1, 4, 10, 12, 14]

Copying, Filling, and Converting

Output:
original  : [1, 2, 3, 4, 5]
extended  : [1, 2, 3, 4, 5, 0, 0, 0]
truncated : [1, 2, 3]

tags      : [java, spring, kafka, redis, docker, kubernetes]
subset[2,5): [kafka, redis, docker]

fill(99.99) : [99.99, 99.99, 99.99, 99.99, 99.99]
fill[2,4)   : [99.99, 99.99, 149.99, 149.99, 99.99]

toString(matrix)     : [[I@7ef88735, [I@6d06d69c, [I@7852e922]
deepToString(matrix) : [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
3D deepToString      : [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]

equals(a1, a2) : true
equals(a1, a3) : false
a1 == a2       : false
equals(m1, m2)     : false
deepEquals(m1, m2) : true

asList()       : [IntelliJ, Maven, Git, Docker]
After set(0)   : [VSCode, Maven, Git, Docker]
asList.add() throws UnsupportedOperationException
Resizable list : [VSCode, Maven, Git, Docker, Jenkins]

Streams and Parallel Operations

Output:
=== Arrays.stream() on int[] ===
sum    : 45
avg    : 5.0
max    : 9
sorted : [1, 2, 3, 4, 5, 6, 7, 8, 9]

=== stream(array, from, to) — subrange ===
sum[2,6) : 180

=== Arrays.stream() on String[] ===
  DOCKER
  KUBERNETES
  SPRING

=== parallelSetAll — fill by index ===
squares : [1, 4, 9, 16, 25, 36, 49, 64]

=== parallelPrefix — running total ===
Daily sales   : [100, 250, 180, 320, 210, 290, 175]
Running total : [100, 350, 530, 850, 1060, 1350, 1525]

=== mismatch ===
mismatch(arr1, arr2) : 2
mismatch(arr1, arr3) : -1

Real-World Example — PhonePe Transaction Analytics Engine

A transaction analytics engine at PhonePe processes daily transaction amounts from all UPI channels. It uses Arrays.parallelSort() for fast sorting of large arrays, Arrays.binarySearch() for O(log n) percentile queries, Arrays.copyOfRange() to extract top-N windows, Arrays.parallelPrefix() for running totals, and Arrays.stream() for statistical aggregation.

Output:
==============================================================
  PhonePe UPI Transaction Analytics — Daily Report
==============================================================
  Total transactions : 10,000
  Total volume       : Rs.16,042,847.35
  Average amount     : Rs.1,604.28

  Min transaction    : Rs.10.01
  Max transaction    : Rs.49,987.54

  Percentiles:
  P25  : Rs.49.97
  P50  : Rs.276.18  (median)
  P75  : Rs.1,782.44
  P90  : Rs.4,293.12
  P99  : Rs.33,841.67

  Top 5 transactions   : [49724.81, 49768.43, 49823.56, 49901.12, 49987.54]
  Bottom 5 transactions: [10.01, 10.04, 10.08, 10.12, 10.14]

  Transactions by band:
  Rs.1   - Rs.100   : 4,987
  Rs.100 - Rs.1000  : 2,492
  Rs.1000- Rs.5000  : 1,724
  Rs.5000+           : 804

  Running total (first 5 sorted transactions):
  [10.01, 20.05, 30.13, 40.25, 50.39]
==============================================================

Performance Considerations

parallelSort() has a threshold. Internally, Arrays.parallelSort() falls back to sequential sort for arrays smaller than 8,192 elements (the exact threshold is implementation-dependent). For most arrays in typical service code (a few hundred to a few thousand elements), Arrays.sort() is faster due to lower task-submission overhead.

Arrays.stream(int[]) returns IntStream, not Stream<Integer>. No boxing occurs. Arrays.stream(int[]).sum() is O(n) with no autoboxing. Converting to Stream<Integer> via .boxed() creates a Stream with Integer objects — significantly more memory and GC pressure for large arrays.

Best Practices

Use Arrays.copyOf() for defensive copies of array fields in immutable classes. this.data = Arrays.copyOf(input, input.length) creates an independent copy that callers cannot modify through their original reference. Without this, storing this.data = input exposes internal state — callers who hold the original reference can mutate it and break the class's invariants.

Use Arrays.deepToString() for any multi-dimensional array. Arrays.toString(twoDArray) prints object references ([[I@7ef88735, ...) because the 1D elements of a 2D array are arrays themselves. Arrays.deepToString(twoDArray) recursively formats nested arrays correctly. The same applies to equals() vs deepEquals() — always use the deep* variants for multi-dimensional arrays.

Convert Arrays.asList() to new ArrayList<>() if elements need to be added or removed. Arrays.asList() returns a fixed-size list backed by the array. add() and remove() throw UnsupportedOperationException. For a fully resizable list: new ArrayList<>(Arrays.asList(array)). For an immutable list from array values, prefer List.of(elements) in Java 9+.

Sort before calling binarySearch() using the same sort order. Arrays.binarySearch(array, key) uses natural ordering. If the array was sorted with a custom Comparator, use Arrays.binarySearch(array, key, sameComparator). A mismatch between sort order and search order produces undefined results — not a compile error.

Common Mistakes

Mistake 1 — Using == or Arrays.equals() on Multi-Dimensional Arrays

Mistake 2 — Calling binarySearch() Before Sorting

Mistake 3 — Assuming asList() Returns a Fully Mutable List

Mistake 4 — Using Arrays.sort() to Sort a Subrange but Forgetting Indices Are Relative to the Array

Output:
[500, 200, 100, 600, 800, 300, 400]

Interview Questions

Q1. What is java.util.Arrays and what are its most commonly used methods?

java.util.Arrays is a final utility class with only static methods for array operations. The most-used methods are: sort() for in-place sorting (dual-pivot quicksort for primitives, TimSort for objects), binarySearch() for O(log n) lookup on sorted arrays, copyOf() and copyOfRange() for resizing and extracting subarrays, fill() for initialising, equals() and deepEquals() for content comparison, toString() and deepToString() for readable output, asList() to create a List view, and stream() to integrate arrays with the Streams API. Since Java 8, parallelSort() enables multi-core sorting for large arrays.

Q2. What is the difference between Arrays.sort() for primitive arrays and object arrays?

Primitive arrays (int[], double[], etc.) use dual-pivot quicksort — an optimised variant that is faster in practice than traditional quicksort, averaging O(n log n) but NOT stable. Stability does not matter for primitives because identical values have no distinguishable identity. Object arrays (String[], Integer[], user-defined class arrays) use TimSort — a hybrid merge-insertion algorithm that is stable (equal elements preserve original order), O(n log n) worst-case, and O(n) for already-sorted input. Stability matters for objects: two employees with the same salary should not swap positions unexpectedly after a sort.

Q3. What is the problem with Arrays.asList() and how do you work around it?

Arrays.asList() returns a fixed-size List backed by the original array. set() works and writes through to the array. But add() and remove() throw UnsupportedOperationException — the backing array has a fixed length that cannot change. Additionally, changes to the original array are reflected in the list. To get a fully independent, resizable list, wrap it: new ArrayList<>(Arrays.asList(array)). This creates a new ArrayList copying all elements, decoupled from the original array with full mutability.

Q4. How does Arrays.binarySearch() behave when the key is not found?

Arrays.binarySearch(array, key) returns -(insertionPoint) - 1 when the key is not present. The insertion point is the index at which the key would need to be inserted to maintain sorted order. For example, if the sorted array is [10, 20, 30, 40] and the key is 25, the result is -(2) - 1 = -3 — 25 would be inserted at index 2. To recover the insertion point from a negative result: int insertAt = -(result) - 1. The array must be sorted in ascending order before calling binarySearch(); calling it on an unsorted array produces undefined results.

Q5. When should you use Arrays.parallelSort() instead of Arrays.sort()?

Arrays.parallelSort() uses ForkJoinPool.commonPool() to sort chunks in parallel, then merge. It is beneficial when the array has approximately 10,000 or more elements and multiple CPU cores are available. Below the threshold (roughly 8,192 elements internally), parallelSort() falls back to sequential sort anyway. The benefit is proportional to both array size and available cores: sorting 1,000,000 elements on 8 cores finishes roughly 5-6x faster than sequential sort. For small arrays in typical web service code, Arrays.sort() is faster due to zero task-submission overhead.

Q6. What is the difference between Arrays.equals() and Arrays.deepEquals()?

Arrays.equals(a1, a2) compares two one-dimensional arrays element by element using == for primitives and .equals() for objects. For a two-dimensional array int[][], the outer elements are int[] references — Arrays.equals() compares those references, not the inner array contents. Two int[][] arrays with identical content return false from Arrays.equals(). Arrays.deepEquals(a1, a2) recursively traverses nested arrays at any depth, comparing all elements. Always use deepEquals() and deepToString() for multi-dimensional arrays.

FAQs

Does Arrays.sort() sort in descending order?

Arrays.sort(primitiveArray) always sorts in ascending order and has no Comparator overload. For descending order on a primitive array, sort ascending and then call Collections.reverse() on an Integer[] (not int[]), or reverse the array manually. For object arrays, use Arrays.sort(objectArray, Comparator.reverseOrder()). For int[] descending specifically: sort the int[], then reverse it with a simple swap loop or convert to Integer[] with a reverse comparator.

What is the difference between Arrays.copyOf() and System.arraycopy()?

System.arraycopy(src, srcPos, dest, destPos, length) copies from an existing source array into an existing destination array — the destination must be pre-allocated. Arrays.copyOf(original, newLength) allocates a new array of newLength, copies elements into it (using System.arraycopy() internally), and returns the new array. copyOf() is more convenient; System.arraycopy() is useful when the destination already exists and performance is critical.

Can Arrays.sort() handle null elements in an Object array?

No. Arrays.sort(Object[] array) calls compareTo() on elements, which throws NullPointerException if any element is null. To sort arrays with potential nulls, provide an explicit Comparator: Arrays.sort(array, Comparator.nullsLast(Comparator.naturalOrder())). This places nulls at the end without throwing.

What does Arrays.mismatch() return?

Arrays.mismatch(a1, a2) returns the index of the first position where the two arrays differ. It returns -1 if the arrays are equal (no mismatch). If one array is a prefix of the other, it returns the length of the shorter array. This is useful for finding exactly where two data arrays diverge — for example, comparing two versions of a byte buffer.

Is Arrays.stream() different from converting an array to a List and streaming?

Yes. Arrays.stream(int[]) returns an IntStream — operations like sum(), average(), min(), max() work directly on primitive values without boxing. Arrays.asList(array).stream() works only on object arrays and returns Stream<T>. For Integer[], both approaches are equivalent, but int[] must use Arrays.stream(int[]) to avoid boxing. For large numeric arrays where performance matters, always use Arrays.stream(primitiveArray) to avoid IntStream → Stream<Integer> boxing overhead.

What is the difference between Arrays.parallelPrefix() and a manual running sum loop?

Arrays.parallelPrefix(array, operator) computes the running aggregate in-place using a parallel divide-and-conquer algorithm — O(n/p × log p) where p is the number of CPU cores. A manual loop is O(n) sequential. For large arrays on multi-core machines, parallelPrefix() is faster. The result is identical: array[i] becomes the aggregate of array[0] through array[i] using the given operator. Common uses: running totals, running products, running maximums, cumulative distribution arrays.

Summary

java.util.Arrays is the static toolbox for Java array operations. Its six functional areas cover sorting (sort(), parallelSort()), searching (binarySearch()), copying (copyOf(), copyOfRange()), filling (fill()), comparing and printing (equals(), deepEquals(), toString(), deepToString()), and stream integration (stream(), parallelSetAll(), parallelPrefix()).

Four rules prevent the most common bugs: always sort before binarySearch() — unsorted input produces undefined results. Use deepEquals() and deepToString() for multi-dimensional arrays — the equals() and toString() counterparts compare inner array references, not content. Wrap Arrays.asList() in new ArrayList<>() before calling add() or remove(). And use Arrays.stream(int[]) for primitive array streams — it returns IntStream with no boxing.

For interviews: explain the dual-pivot quicksort vs TimSort distinction (stable vs not, and why it matters), describe the binarySearch() return value for absent keys, explain the asList() fixed-size trap, and know when parallelSort() is beneficial over sort().

What to Read Next