Java Arrays Class and Copying Arrays

java.util.Arrays is a utility class packed with static helper methods for working with arrays — sorting them, searching them, comparing them, filling them, and copying them — so you rarely need to write these operations by hand. Because arrays themselves expose almost no built-in methods beyond the length field, Arrays fills that gap for everyday array manipulation.

Copying arrays correctly matters because array variables hold references, not the data itself: writing int[] b = a; does not copy anything, it just gives two names to the same underlying array, so changes through either variable are visible through the other. Arrays.copyOf, Arrays.copyOfRange, and System.arraycopy are the standard, correct ways to actually duplicate array data.

Why it matters

Printing, comparing, sorting and copying arrays all behave differently from what newcomers expect: println prints something like [I@1b6d3586, == compares references, and = does not copy. The java.util.Arrays class provides the correct tool for each, and knowing them saves writing loops that the standard library already does well.

Printing and Comparing Arrays

Printing an array directly with System.out.println (or string concatenation) prints an unhelpful internal reference like "[I@1b6d3586", because arrays don't override toString(). Arrays.toString(array) produces a readable "[1, 2, 3]" for one-dimensional arrays, while Arrays.deepToString(array) is required for nested (multidimensional) arrays. Similarly, == on two arrays compares references, not contents, so Arrays.equals(a, b) (or deepEquals for nested arrays) is the correct way to check whether two arrays hold the same elements.

Sorting and Searching

Arrays.sort(array) sorts the array in place in ascending order using a dual-pivot quicksort for primitives (or a stable mergesort variant for objects). Once an array is sorted, Arrays.binarySearch(array, key) finds a value's index efficiently in logarithmic time — but binarySearch gives undefined results on an unsorted array, so sorting first is mandatory.

Copying Arrays

Three standard tools create genuine, independent copies of array data.

• Arrays.copyOf(array, newLength) — returns a new array of the given length, copying from the start; if newLength is larger, extra slots get default values, and if smaller, the array is truncated.
• Arrays.copyOfRange(array, from, to) — returns a new array containing elements from index "from" (inclusive) to "to" (exclusive).
• System.arraycopy(src, srcPos, dest, destPos, length) — the lowest-level, fastest option; it copies into an already-existing destination array rather than creating a new one, and both Arrays.copyOf and copyOfRange actually use it internally.

Time complexity

Example

import java.util.Arrays;

public class ArraysClassDemo {
    public static void main(String[] args) {
        int[] original = {5, 2, 9, 1, 7};

        int[] copy = Arrays.copyOf(original, original.length);
        Arrays.sort(copy);
        System.out.println("Sorted copy: " + Arrays.toString(copy));
        System.out.println("Original unchanged: " + Arrays.toString(original));

        int index = Arrays.binarySearch(copy, 7);
        System.out.println("Index of 7: " + index);

        int[] partial = Arrays.copyOfRange(original, 1, 4);
        System.out.println("Partial copy: " + Arrays.toString(partial));

        int[] destination = new int[3];
        System.arraycopy(original, 0, destination, 0, 3);
        System.out.println("System.arraycopy result: " + Arrays.toString(destination));
    }
}

Sorted copy: [1, 2, 5, 7, 9]
Original unchanged: [5, 2, 9, 1, 7]
Index of 7: 3
Partial copy: [2, 9, 1]
System.arraycopy result: [5, 2, 9]

Exercise

Produce a sorted copy of an array while leaving the original untouched, then print both.

Expected output: Original: [5, 3, 9, 1] then Sorted: [1, 3, 5, 9]

import java.util.Arrays;

public class SortedCopy {
    public static void main(String[] args) {
        int[] original = {5, 3, 9, 1};

        // TODO: create a real copy of original, then sort only the copy

        System.out.println("Original: " + Arrays.toString(original));
        System.out.println("Sorted: " + Arrays.toString(sorted));
    }
}

import java.util.Arrays;

public class SortedCopy {
    public static void main(String[] args) {
        int[] original = {5, 3, 9, 1};

        int[] sorted = Arrays.copyOf(original, original.length);
        Arrays.sort(sorted);

        System.out.println("Original: " + Arrays.toString(original));
        System.out.println("Sorted: " + Arrays.toString(sorted));
    }
}

Quick quiz

Interview questions