{"title":"Arrays Class","description":"","content":"Working with arrays by hand gets tedious fast. Printing them readably, sorting them, searching them, comparing them, filling them with a default value, all of it requires loops you'd have to write again and again. Java ships a small utility class, `java.util.Arrays`, that handles these chores for you. This lesson covers the static methods on that class that you'll use in real code.\n\nBefore we use anything from it, the class needs to be imported:\n\n\n```java\nimport java.util.Arrays;\n```\n\n\nPut that line near the top of your file, just below the `package` declaration if there is one. Every example in this lesson assumes this import is in place.\n\n---\n\n# Printing Arrays Readably\n\nPrinting an array directly produces something unhelpful:\n\n\n```java\nimport java.util.Arrays;\n\npublic class PrintRaw {\n public static void main(String[] args) {\n int[] productPrices = {29, 49, 19, 99, 15};\n System.out.println(productPrices);\n }\n}\n```\n\n\nThat's not a bug. `System.out.println` calls `toString` on whatever you hand it, and arrays inherit the default `toString` from `Object`, which returns the type signature plus a hex hash code. `[I` means \"array of int\", and `@7a81197d` is the identity hash. Useful for the JVM, useless for humans.\n\n`Arrays.toString` produces something you can actually read:\n\n\n```java\nimport java.util.Arrays;\n\npublic class PrintReadable {\n public static void main(String[] args) {\n int[] productPrices = {29, 49, 19, 99, 15};\n System.out.println(Arrays.toString(productPrices));\n }\n}\n```\n\n\nIt works the same way for any 1D array, including `String[]` and `double[]`.\n\n\n```java\nimport java.util.Arrays;\n\npublic class PrintMixedArrays {\n public static void main(String[] args) {\n String[] customerEmails = {\"ada@example.com\", \"ben@example.com\", \"cleo@example.com\"};\n double[] productRatings = {4.5, 4.8, 3.9, 4.2};\n\n System.out.println(Arrays.toString(customerEmails));\n System.out.println(Arrays.toString(productRatings));\n }\n}\n```\n\n\nThe catch: `Arrays.toString` only goes one level deep. For a 2D array, you get the same hex-hash mess for each row.\n\n\n```java\nimport java.util.Arrays;\n\npublic class PrintNestedWrong {\n public static void main(String[] args) {\n int[][] stockByWarehouse = {\n {12, 8, 5},\n {20, 15, 7}\n };\n System.out.println(Arrays.toString(stockByWarehouse));\n }\n}\n```\n\n\nThat's because each row is itself an `int[]`, and `Arrays.toString` calls the default `toString` on each row instead of recursing. `Arrays.deepToString` fixes this by walking nested arrays all the way down.\n\n\n```java\nimport java.util.Arrays;\n\npublic class PrintNestedRight {\n public static void main(String[] args) {\n int[][] stockByWarehouse = {\n {12, 8, 5},\n {20, 15, 7}\n };\n System.out.println(Arrays.deepToString(stockByWarehouse));\n }\n}\n```\n\n\nRule of thumb: 1D, use `toString`. Nested, use `deepToString`. `deepToString` works on 1D arrays too, so if you're unsure, `deepToString` is the safer pick.\n\n---\n\n# Sorting\n\nSorting an array by hand is the kind of thing you only want to do once, as a learning exercise. After that, use `Arrays.sort`. It sorts in place, modifying the array you give it, and uses a well-tuned algorithm internally.\n\n\n```java\nimport java.util.Arrays;\n\npublic class SortPrices {\n public static void main(String[] args) {\n int[] productPrices = {49, 19, 99, 29, 15};\n Arrays.sort(productPrices);\n System.out.println(Arrays.toString(productPrices));\n }\n}\n```\n\n\nThe result of `Arrays.sort` is not assigned to anything. It returns `void`. The original array itself is reordered.\n\n`Arrays.sort` works on every primitive array type (`int[]`, `long[]`, `double[]`, `char[]`, etc.) and on `String[]`. For `String[]`, the natural ordering is lexicographic, which sorts by Unicode code point. Uppercase letters come before lowercase, so `\"Zebra\"` sorts before `\"apple\"`.\n\n\n```java\nimport java.util.Arrays;\n\npublic class SortStrings {\n public static void main(String[] args) {\n String[] customerEmails = {\"cleo@example.com\", \"ada@example.com\", \"ben@example.com\"};\n Arrays.sort(customerEmails);\n System.out.println(Arrays.toString(customerEmails));\n }\n}\n```\n\n\nThere's also an overload that sorts a slice of the array, from one index up to (but not including) another:\n\n\n```java\nimport java.util.Arrays;\n\npublic class SortSlice {\n public static void main(String[] args) {\n int[] productPrices = {49, 19, 99, 29, 15, 5};\n Arrays.sort(productPrices, 1, 4);\n System.out.println(Arrays.toString(productPrices));\n }\n}\n```\n\n\nOnly indices `1`, `2`, and `3` got sorted. The values at `0`, `4`, and `5` stayed where they were. The `from` index is inclusive and the `to` index is exclusive, matching the rest of the Java standard library.\n\n`Arrays.sort` runs in O(n log n) for primitive arrays. That's faster than any hand-written nested-loop sort you'd write as a beginner. Don't reinvent it.\n\n### Parallel Sort\n\nThere's a sibling called `Arrays.parallelSort` that splits the work across multiple threads. The signature looks identical:\n\n\n```java\nimport java.util.Arrays;\n\npublic class ParallelSortDemo {\n public static void main(String[] args) {\n int[] productIds = {1043, 207, 5891, 7720, 314, 9001};\n Arrays.parallelSort(productIds);\n System.out.println(Arrays.toString(productIds));\n }\n}\n```\n\n\nThe result is the same. The difference is what happens internally. For large arrays, the parallel version can be noticeably faster on a multi-core machine. For small arrays, the cost of dispatching work to threads outweighs the savings, and plain `Arrays.sort` wins. Default to `Arrays.sort` and only use `parallelSort` when you have a measurable reason, like an array with tens of thousands of elements or more.\n\n---\n\n# Binary Search\n\n`Arrays.binarySearch` finds a value in a sorted array in O(log n) time. Each step looks at the middle of the current search range, compares to the target, and either returns the index or throws away half the range.\n\n\n```mermaid\nflowchart TD\n A[Search 29 in array
15, 19, 29, 49, 99]:::cyan --> B[Check middle index 2
value is 29]:::orange\n B --> C{Equal to target?}:::orange\n C -- yes --> D[Return index 2]:::green\n C -- no, target smaller --> E[Search left half]:::teal\n C -- no, target larger --> F[Search right half]:::teal\n E --> B\n F --> B\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nHere's the basic call:\n\n\n```java\nimport java.util.Arrays;\n\npublic class BinarySearchFound {\n public static void main(String[] args) {\n int[] productPrices = {15, 19, 29, 49, 99};\n int index = Arrays.binarySearch(productPrices, 49);\n System.out.println(\"Index of 49: \" + index);\n }\n}\n```\n\n\nWhen the value isn't there, the return value is a negative number that encodes the insertion point. The exact formula is `-(insertionPoint + 1)`, where `insertionPoint` is the index the value would land at if you inserted it while keeping the array sorted.\n\n\n```java\nimport java.util.Arrays;\n\npublic class BinarySearchMissing {\n public static void main(String[] args) {\n int[] productPrices = {15, 19, 29, 49, 99};\n int result = Arrays.binarySearch(productPrices, 30);\n System.out.println(\"Raw return value: \" + result);\n\n int insertionPoint = -(result + 1);\n System.out.println(\"Insertion point: \" + insertionPoint);\n }\n}\n```\n\n\n`30` would slot in at index `3`, between `29` and `49`. The negative-and-offset-by-one encoding exists so that the method can distinguish \"found at index 0\" (returns `0`) from \"not found, would insert at index 0\" (returns `-1`).\n\nNow the gotcha. Binary search **requires the array to be sorted**. If you call it on unsorted data, the result is undefined. It won't throw an exception, it'll just hand you a wrong answer.\n\n**What's wrong with this code?**\n\n\n```java\nimport java.util.Arrays;\n\npublic class BinarySearchUnsorted {\n public static void main(String[] args) {\n int[] productPrices = {49, 19, 99, 29, 15};\n int index = Arrays.binarySearch(productPrices, 29);\n System.out.println(\"Index of 29: \" + index);\n }\n}\n```\n\n\nThe array isn't sorted. `binarySearch` will halve the range based on comparisons that assume sorted order, and the result is whatever the algorithm happens to land on. It might return `-1`, `2`, or some negative insertion point that doesn't correspond to anything real. The call returns a value, but the value can't be trusted.\n\n**Fix:**\n\n\n```java\nimport java.util.Arrays;\n\npublic class BinarySearchSortedFirst {\n public static void main(String[] args) {\n int[] productPrices = {49, 19, 99, 29, 15};\n Arrays.sort(productPrices);\n int index = Arrays.binarySearch(productPrices, 29);\n System.out.println(\"Sorted: \" + Arrays.toString(productPrices));\n System.out.println(\"Index of 29: \" + index);\n }\n}\n```\n\n\nSort first, then search. If you need to search the same array many times, sort once up front and reuse it. If you only need a single lookup and the array is small, a plain `for` loop is fine and avoids the sort cost.\n\n`Arrays.sort` is O(n log n). `Arrays.binarySearch` is O(log n) but only correct on sorted input. A single linear search over an unsorted array is O(n). If you're going to search once, linear search wins. If you're going to search many times, sort once and binary-search after.\n\n---\n\n# Filling\n\n`Arrays.fill` sets every element of an array to the same value. It's the one-line replacement for a loop that writes `arr[i] = value` for every `i`.\n\n\n```java\nimport java.util.Arrays;\n\npublic class FillStock {\n public static void main(String[] args) {\n int[] stockCounts = new int[5];\n Arrays.fill(stockCounts, 10);\n System.out.println(Arrays.toString(stockCounts));\n }\n}\n```\n\n\nUseful when you want a default starting value other than zero. `int[]` already defaults to `0`, but `Arrays.fill` is convenient for any value you want, and it works the same way for `String[]`, `double[]`, and the rest.\n\nThere's also a range-based overload, mirroring the one on `sort`:\n\n\n```java\nimport java.util.Arrays;\n\npublic class FillRange {\n public static void main(String[] args) {\n int[] productRatings = new int[6];\n Arrays.fill(productRatings, 2, 5, 5);\n System.out.println(Arrays.toString(productRatings));\n }\n}\n```\n\n\nIndices `2`, `3`, and `4` were set to `5`. As with `sort` and `binarySearch`, the `from` index is inclusive and the `to` index is exclusive.\n\n---\n\n# Comparing\n\n`==` does not compare two arrays element by element. `==` on arrays checks whether the two variables point to the same object in memory, not whether they hold the same values.\n\n**What's wrong with this code?**\n\n\n```java\npublic class CompareWithEquals {\n public static void main(String[] args) {\n int[] first = {1, 2, 3};\n int[] second = {1, 2, 3};\n System.out.println(first == second);\n }\n}\n```\n\n\nThe values are identical, but `first` and `second` are two different array objects. `==` returns `false` even though the contents match.\n\n**Fix:**\n\n\n```java\nimport java.util.Arrays;\n\npublic class CompareWithArraysEquals {\n public static void main(String[] args) {\n int[] first = {1, 2, 3};\n int[] second = {1, 2, 3};\n System.out.println(Arrays.equals(first, second));\n }\n}\n```\n\n\n`Arrays.equals` compares lengths first, then walks both arrays in lockstep, comparing each element with `==` (for primitives) or `.equals` (for object references). It returns `true` only if every position matches.\n\nFor nested arrays, the same one-level-deep problem from `toString` shows up. `Arrays.equals` on `int[][]` compares the inner arrays with `==`, which fails for separate inner arrays even when their contents match. Use `Arrays.deepEquals` instead:\n\n\n```java\nimport java.util.Arrays;\n\npublic class DeepEqualsDemo {\n public static void main(String[] args) {\n int[][] warehouseA = {{12, 8}, {5, 3}};\n int[][] warehouseB = {{12, 8}, {5, 3}};\n\n System.out.println(\"equals: \" + Arrays.equals(warehouseA, warehouseB));\n System.out.println(\"deepEquals: \" + Arrays.deepEquals(warehouseA, warehouseB));\n }\n}\n```\n\n\n`equals` walks one level and finds two different inner-array objects. `deepEquals` recurses and finds matching contents.\n\nThere are also `Arrays.hashCode` and `Arrays.deepHashCode` that go alongside these. If you ever override `equals` and `hashCode` on a class that has an array field, use them to make sure equal objects produce equal hash codes. They follow the same 1D-vs-nested split as their `equals` counterparts.\n\n---\n\n# Converting to a List\n\n`Arrays.asList` turns a list of values into a fixed-size `List`. It's handy when you have a few values you want to use with code that expects a `List`.\n\n\n```java\nimport java.util.Arrays;\nimport java.util.List;\n\npublic class AsListBasics {\n public static void main(String[] args) {\n List categories = Arrays.asList(\"books\", \"electronics\", \"clothing\");\n System.out.println(categories);\n System.out.println(\"Size: \" + categories.size());\n }\n}\n```\n\n\nTwo catches. First, the `List` is **fixed-size**. You can read and replace elements, but you can't `add` or `remove`.\n\n**What's wrong with this code?**\n\n\n```java\nimport java.util.Arrays;\nimport java.util.List;\n\npublic class AsListAddBug {\n public static void main(String[] args) {\n List categories = Arrays.asList(\"books\", \"electronics\");\n categories.add(\"clothing\");\n System.out.println(categories);\n }\n}\n```\n\n\nThe list returned by `Arrays.asList` is backed by an internal array, and arrays can't grow. Calling `add` throws `UnsupportedOperationException` at runtime.\n\n**Fix:**\n\nIf you need a growable list, wrap it in a fresh `ArrayList`:\n\n\n```java\nimport java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.List;\n\npublic class AsListAddFix {\n public static void main(String[] args) {\n List categories = new ArrayList<>(Arrays.asList(\"books\", \"electronics\"));\n categories.add(\"clothing\");\n System.out.println(categories);\n }\n}\n```\n\n\nThe `ArrayList` constructor copies the elements into a real, resizable list. Adding works fine after that.\n\nSecond catch: `Arrays.asList` with an `int[]` does not give you a `List` of the elements. It gives you a `List` of size 1, where the single element is the whole array. That's because `int` is a primitive and doesn't fit the generic type system, but `int[]` is an object and does, so the compiler picks the only interpretation that works.\n\n**What's wrong with this code?**\n\n\n```java\nimport java.util.Arrays;\nimport java.util.List;\n\npublic class AsListIntBug {\n public static void main(String[] args) {\n int[] productIds = {101, 102, 103};\n List wrapped = Arrays.asList(productIds);\n System.out.println(\"Size: \" + wrapped.size());\n }\n}\n```\n\n\nThe list has one element, not three. That single element is the `int[]` itself.\n\n**Fix:**\n\nUse `Integer[]` (the boxed type) instead of `int[]`:\n\n\n```java\nimport java.util.Arrays;\nimport java.util.List;\n\npublic class AsListIntegerFix {\n public static void main(String[] args) {\n Integer[] productIds = {101, 102, 103};\n List wrapped = Arrays.asList(productIds);\n System.out.println(\"Size: \" + wrapped.size());\n System.out.println(wrapped);\n }\n}\n```\n\n\nWith `Integer[]`, each element is an object, and the generic machinery lines up. The list has three elements.\n\n`Arrays.asList` does not allocate a fresh array. The returned `List` is a thin wrapper over the array you passed in, so it's O(1) to create and O(1) per element access. Mutating the list (through `set`) also mutates the backing array, and vice versa.\n\n\n```mermaid\nflowchart LR\n A[String array
books, electronics, clothing]:::cyan --> B[Arrays.asList]:::orange\n B --> C[Fixed-size List
backed by the array]:::teal\n C --> D{Need to add
or remove?}:::orange\n D -- yes --> E[Wrap in new ArrayList]:::green\n D -- no --> F[Use as is]:::green\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\n---\n\n# Streaming an Array\n\n`Arrays.stream` turns an array into a `Stream`, which is a separate way of expressing \"do something to every element\". For now, the relevant piece is the shortcut for common aggregates like sum, average, min, and max.\n\n\n```java\nimport java.util.Arrays;\n\npublic class StreamSum {\n public static void main(String[] args) {\n int[] productPrices = {29, 49, 19, 99, 15};\n int total = Arrays.stream(productPrices).sum();\n System.out.println(\"Cart total: $\" + total);\n }\n}\n```\n\n\nA manual `for` loop does the same calculation. Both work. The stream version is shorter; the loop is more explicit and easier to step through with a debugger. Use whichever you find clearer.\n\n---\n\n# Copying Arrays\n\nYou'll also see `Arrays.copyOf` and `Arrays.copyOfRange` floating around code. They return a new array containing some or all of the elements of the original, leaving the original untouched. We give them their own lesson next because the variations (shrinking, growing, slicing) have enough quirks to be worth their own walkthrough.\n\n---\n\n# Quick Reference Cheat Sheet\n\nWhen you're sure which task you have but not which method, this table is the fastest path:\n\n\n| Task | Method | Notes |\n|------|--------|-------|\n| Print a 1D array | `Arrays.toString(arr)` | Avoids the `[I@...` default. |\n| Print a nested array | `Arrays.deepToString(arr)` | Works on 1D too. |\n| Sort in place | `Arrays.sort(arr)` | O(n log n), natural ordering. |\n| Sort a slice | `Arrays.sort(arr, from, to)` | `to` is exclusive. |\n| Sort large arrays in parallel | `Arrays.parallelSort(arr)` | Faster for big arrays only. |\n| Search a sorted array | `Arrays.binarySearch(arr, key)` | O(log n). Sort first. |\n| Fill with one value | `Arrays.fill(arr, value)` | In place. |\n| Fill a slice with one value | `Arrays.fill(arr, from, to, value)` | `to` is exclusive. |\n| Compare two 1D arrays | `Arrays.equals(a, b)` | Element by element. |\n| Compare two nested arrays | `Arrays.deepEquals(a, b)` | Recursive. |\n| Hash a 1D array | `Arrays.hashCode(arr)` | Pairs with `equals`. |\n| Hash a nested array | `Arrays.deepHashCode(arr)` | Pairs with `deepEquals`. |\n| Wrap as a fixed-size `List` | `Arrays.asList(...)` | Use `Integer[]`, not `int[]`. |\n| Sum/min/max/average | `Arrays.stream(arr).sum()`, etc. | Stream-based aggregation. |\n| Copy or resize | `Arrays.copyOf`, `Arrays.copyOfRange` | Returns a new array. |\n\n\n\n```mermaid\nflowchart TD\n A[I need to do something
with an array]:::cyan --> B{What kind of
operation?}:::orange\n B -- print --> C{1D or nested?}:::orange\n C -- 1D --> D[Arrays.toString]:::teal\n C -- nested --> E[Arrays.deepToString]:::teal\n B -- order --> F[Arrays.sort]:::green\n B -- find --> G[Sort first
then Arrays.binarySearch]:::green\n B -- compare --> H{1D or nested?}:::orange\n H -- 1D --> I[Arrays.equals]:::teal\n H -- nested --> J[Arrays.deepEquals]:::teal\n B -- set every value --> K[Arrays.fill]:::green\n B -- aggregate sum/min/max --> L[Arrays.stream]:::red\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n```\n","pageType":"java"}

Arrays Class

Get Premium