{"title":"Copying Arrays","description":"","content":"Arrays in Java are reference types, which means a variable holds a pointer to the array, not the array's contents. Writing `int[] b = a;` doesn't give you two arrays. It gives you two names for the same one. This lesson covers every practical way to duplicate an array's contents, when each technique applies, and the trap that appears when arrays contain other arrays or objects.\n\n---\n\n# Why Reference Aliasing Matters\n\nThe bug that motivates every copy method in the standard library: two variables, one array.\n\n**What's wrong with this code?**\n\n\n```java\nimport java.util.Arrays;\n\npublic class CartAlias {\n public static void main(String[] args) {\n int[] cartItems = {3, 1, 2, 4};\n int[] backupCart = cartItems;\n\n backupCart[0] = 999;\n\n System.out.println(\"backupCart: \" + Arrays.toString(backupCart));\n System.out.println(\"cartItems: \" + Arrays.toString(cartItems));\n }\n}\n```\n\n\nThe variable named `backupCart` is not a backup at all. The assignment `int[] backupCart = cartItems;` copies the reference, not the data. Both names point at the same array on the heap, so writing through one is visible through the other.\n\n\n```mermaid\nflowchart LR\n A[cartItems
stack variable]:::cyan --> H[Array on heap
3, 1, 2, 4]:::orange\n B[backupCart
stack variable]:::cyan --> H\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n```\n\n\nTwo arrows, one box. That is the shape of an array variable assignment. To get an independent copy, allocate a new array and copy the elements into it. The rest of this lesson covers the ways to do that.\n\nReference assignment is O(1). Real copying is O(n) because every element has to be written into the new array. The two operations look identical in source but have very different shapes.\n\n---\n\n# Copying with a Manual Loop\n\nThe most direct way to copy an array is to allocate a new one of the same length and walk every index. This is what the standard library does internally.\n\n\n```java\nimport java.util.Arrays;\n\npublic class ManualCopy {\n public static void main(String[] args) {\n int[] productPrices = {19, 49, 29, 99, 15};\n int[] copy = new int[productPrices.length];\n\n for (int i = 0; i < productPrices.length; i++) {\n copy[i] = productPrices[i];\n }\n\n copy[0] = 0;\n System.out.println(\"original: \" + Arrays.toString(productPrices));\n System.out.println(\"copy: \" + Arrays.toString(copy));\n }\n}\n```\n\n\n`new int[productPrices.length]` allocates a brand new array, with its own slot in memory. The loop copies each element by value. Once the loop is done, writing to `copy[0]` is independent of `productPrices`, which is the whole point.\n\nYou should almost never write this loop in application code. The standard library has faster, shorter, and safer alternatives. Understanding what they do means understanding this loop first.\n\n---\n\n# Arrays.copyOf\n\n`Arrays.copyOf(arr, newLength)` allocates a new array of the size you ask for and copies elements over. If the new length is the same as the old one, it's a plain copy. If it's smaller, the result is truncated. If it's larger, the extra slots get the type's default value.\n\n\n```java\nimport java.util.Arrays;\n\npublic class CopyOfBasic {\n public static void main(String[] args) {\n int[] productPrices = {19, 49, 29, 99, 15};\n\n int[] same = Arrays.copyOf(productPrices, productPrices.length);\n int[] shorter = Arrays.copyOf(productPrices, 3);\n int[] longer = Arrays.copyOf(productPrices, 7);\n\n System.out.println(\"same: \" + Arrays.toString(same));\n System.out.println(\"shorter: \" + Arrays.toString(shorter));\n System.out.println(\"longer: \" + Arrays.toString(longer));\n }\n}\n```\n\n\nThe padding rule depends on the element type. For `int`, the default is `0`. For `double`, it's `0.0`. For `boolean`, `false`. For reference types like `String` or any object array, it's `null`.\n\n\n```java\nimport java.util.Arrays;\n\npublic class CopyOfPadding {\n public static void main(String[] args) {\n String[] customerEmails = {\"a@shop.com\", \"b@shop.com\"};\n String[] resized = Arrays.copyOf(customerEmails, 4);\n\n System.out.println(Arrays.toString(resized));\n }\n}\n```\n\n\nThis is also the standard way to grow an array. You can't change an array's length after creation, so growing means allocating a new one and copying over the elements. `Arrays.copyOf` does that in one line.\n\n`Arrays.copyOf` allocates a new array and copies in O(n). Internally it calls `System.arraycopy`, which is a JVM intrinsic, so it is typically faster than a hand-written loop.\n\n---\n\n# Arrays.copyOfRange\n\nTo copy a slice of an array, use `Arrays.copyOfRange(arr, from, to)`. The range is half-open: `from` is included, `to` is not. This matches how almost every range-based API in Java behaves.\n\n\n```java\nimport java.util.Arrays;\n\npublic class CopyOfRangeBasic {\n public static void main(String[] args) {\n int[] recentOrders = {101, 102, 103, 104, 105, 106};\n\n int[] firstThree = Arrays.copyOfRange(recentOrders, 0, 3);\n int[] middle = Arrays.copyOfRange(recentOrders, 2, 5);\n\n System.out.println(\"firstThree: \" + Arrays.toString(firstThree));\n System.out.println(\"middle: \" + Arrays.toString(middle));\n }\n}\n```\n\n\n`copyOfRange(recentOrders, 0, 3)` returns indices `0`, `1`, `2`, which is three elements. Reading the range as \"from this index, up to but not including that index\" is the simplest way to keep it straight.\n\nLike `copyOf`, the `to` index is allowed to go past the end of the source array. The extra slots get filled with the default value.\n\n\n```java\nimport java.util.Arrays;\n\npublic class CopyOfRangePadding {\n public static void main(String[] args) {\n int[] stockCounts = {12, 8, 4};\n\n int[] padded = Arrays.copyOfRange(stockCounts, 1, 5);\n\n System.out.println(Arrays.toString(padded));\n }\n}\n```\n\n\nStarting at index `1` of `stockCounts` and going up to (but not including) `5` would normally read four elements. The source only has two elements from index `1` onward (`8` and `4`), so the rest of the result is padded with the default `int` value of `0`.\n\nThe one rule you can't break: `from` must be in `[0, arr.length]` and `from <= to`. If `from` is negative or larger than the array length, you get `ArrayIndexOutOfBoundsException`. If `from > to`, you get `IllegalArgumentException`.\n\n---\n\n# System.arraycopy\n\n`System.arraycopy(src, srcPos, dest, destPos, length)` is the low-level primitive that every other copy method in Java is built on. It does not allocate. You give it a source array, a destination array (which you allocate yourself), and the positions and length to copy.\n\n\n```java\nimport java.util.Arrays;\n\npublic class ArraycopyBasic {\n public static void main(String[] args) {\n int[] productPrices = {19, 49, 29, 99, 15};\n int[] copy = new int[productPrices.length];\n\n System.arraycopy(productPrices, 0, copy, 0, productPrices.length);\n\n copy[0] = 0;\n System.out.println(\"original: \" + Arrays.toString(productPrices));\n System.out.println(\"copy: \" + Arrays.toString(copy));\n }\n}\n```\n\n\nThe five arguments read as: copy from `productPrices` starting at index `0` into `copy` starting at index `0`, total of `productPrices.length` elements.\n\nYou can also copy into the middle of an existing array, which is useful when you're assembling one array from pieces of others.\n\n\n```java\nimport java.util.Arrays;\n\npublic class ArraycopyIntoMiddle {\n public static void main(String[] args) {\n int[] firstPage = {1, 2, 3};\n int[] secondPage = {4, 5, 6};\n int[] combined = new int[6];\n\n System.arraycopy(firstPage, 0, combined, 0, 3);\n System.arraycopy(secondPage, 0, combined, 3, 3);\n\n System.out.println(Arrays.toString(combined));\n }\n}\n```\n\n\nA notable property of `System.arraycopy` is that the source and destination can be the **same** array. This sounds like it would corrupt the data if the ranges overlap, but Java handles it correctly. The method behaves as if it read every source element into a temporary buffer before writing any destination element.\n\n\n```java\nimport java.util.Arrays;\n\npublic class ArraycopyOverlap {\n public static void main(String[] args) {\n int[] cartItems = {10, 20, 30, 40, 50};\n\n // Shift indices 0..2 to positions 2..4 inside the same array.\n System.arraycopy(cartItems, 0, cartItems, 2, 3);\n\n System.out.println(Arrays.toString(cartItems));\n }\n}\n```\n\n\nThe first two elements stay where they are. The values originally at indices `0`, `1`, `2` (which were `10`, `20`, `30`) get written to indices `2`, `3`, `4`. Even though the source and destination overlap at index `2`, the original value `30` was already read before index `2` got overwritten, so the result is correct. This makes `System.arraycopy` suitable for shifting elements inside an array, which comes up when you insert into or remove from the middle of a list.\n\n`System.arraycopy` is a JVM intrinsic. On modern JVMs it lowers to a tight memory move and is typically faster than copying by hand, especially for large arrays.\n\n---\n\n# The Array .clone() Shortcut\n\nEvery array in Java has a built-in `clone()` method that returns a shallow copy of the same length and element type. It is the shortest syntax for a full copy when resizing is not needed.\n\n\n```java\nimport java.util.Arrays;\n\npublic class ArrayClone {\n public static void main(String[] args) {\n int[] stockCounts = {12, 8, 4, 17, 3};\n int[] snapshot = stockCounts.clone();\n\n snapshot[0] = 0;\n System.out.println(\"original: \" + Arrays.toString(stockCounts));\n System.out.println(\"snapshot: \" + Arrays.toString(snapshot));\n }\n}\n```\n\n\nTwo things make `clone()` convenient. There is no length argument, and the returned array already has the correct element type, so no cast is needed. It is the smallest amount of code for a full-length copy.\n\nThe one thing `clone()` cannot do is resize. For a longer or shorter array, use `Arrays.copyOf` instead.\n\nThere is a broader story to `clone()` for general Java objects, involving the `Cloneable` interface, protected method overrides, and shallow vs deep semantics. For arrays specifically, `clone()` is safe, always works, and always returns a fresh array of the same length.\n\n---\n\n# Shallow vs Deep Copies\n\nEvery copy technique covered so far is **shallow**. That word means one thing: when you copy an array, you copy whatever the slots hold. For an `int[]`, the slots hold actual integer values, so a shallow copy is also effectively deep. For an array of objects or an array of arrays, the slots hold references. Copying the array gives you new slots holding the same references.\n\nConsider a small `Product` class with a price field.\n\n\n```java\nimport java.util.Arrays;\n\nclass Product {\n String name;\n int price;\n\n Product(String name, int price) {\n this.name = name;\n this.price = price;\n }\n\n public String toString() {\n return name + \"($\" + price + \")\";\n }\n}\n\npublic class ShallowObjectCopy {\n public static void main(String[] args) {\n Product[] catalog = {\n new Product(\"Mouse\", 25),\n new Product(\"Keyboard\", 75)\n };\n\n Product[] copy = catalog.clone();\n\n // Mutate the object through the copy.\n copy[0].price = 999;\n\n System.out.println(\"catalog: \" + Arrays.toString(catalog));\n System.out.println(\"copy: \" + Arrays.toString(copy));\n }\n}\n```\n\n\nMutating `copy[0].price` changed `catalog[0].price` too. The `clone()` call copied the array's slots, which are references to `Product` objects. Both arrays end up with references to the same two `Product` instances. Modifying a field of one of those instances is visible through either array.\n\n\n```mermaid\nflowchart LR\n C[catalog]:::cyan --> C0[slot 0]:::orange\n C --> C1[slot 1]:::orange\n K[copy]:::cyan --> K0[slot 0]:::orange\n K --> K1[slot 1]:::orange\n\n C0 --> P0[Product Mouse
price 999]:::green\n K0 --> P0\n C1 --> P1[Product Keyboard
price 75]:::green\n K1 --> P1\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nTwo arrays, four slots, two `Product` objects. The arrays are independent (you could `copy[0] = null` without affecting `catalog`), but the objects they point at are shared.\n\nFor an independent set of products, you have to copy each `Product` too. This is a **deep copy**.\n\n\n```java\nimport java.util.Arrays;\n\nclass Product {\n String name;\n int price;\n\n Product(String name, int price) {\n this.name = name;\n this.price = price;\n }\n\n Product copy() {\n return new Product(this.name, this.price);\n }\n\n public String toString() {\n return name + \"($\" + price + \")\";\n }\n}\n\npublic class DeepObjectCopy {\n public static void main(String[] args) {\n Product[] catalog = {\n new Product(\"Mouse\", 25),\n new Product(\"Keyboard\", 75)\n };\n\n Product[] deep = new Product[catalog.length];\n for (int i = 0; i < catalog.length; i++) {\n deep[i] = catalog[i].copy();\n }\n\n deep[0].price = 999;\n\n System.out.println(\"catalog: \" + Arrays.toString(catalog));\n System.out.println(\"deep: \" + Arrays.toString(deep));\n }\n}\n```\n\n\nNow `catalog` is untouched. Each slot in `deep` points at a fresh `Product` built from the original's data. Mutating the new objects has no effect on the originals.\n\nThe rule is simple. Shallow copy means you duplicated the **container**, not its contents. If the contents are values (primitives), that's enough. If the contents are references, you only duplicated the references.\n\n---\n\n# Deep-Copying a 2D Array\n\nA 2D array in Java is an array of arrays. The outer array's slots hold references to inner arrays. This means `Arrays.copyOf` of a 2D array has the same shallow trap as the object example.\n\n**What's wrong with this code?**\n\n\n```java\nimport java.util.Arrays;\n\npublic class ShallowGridCopy {\n public static void main(String[] args) {\n int[][] grid = {\n {1, 2, 3},\n {4, 5, 6},\n {7, 8, 9}\n };\n\n int[][] copy = Arrays.copyOf(grid, grid.length);\n\n copy[0][0] = 999;\n\n System.out.println(\"grid[0][0]: \" + grid[0][0]);\n System.out.println(\"copy[0][0]: \" + copy[0][0]);\n }\n}\n```\n\n\n`Arrays.copyOf(grid, grid.length)` copied the outer array. The outer slots hold references to the inner rows. Both `grid` and `copy` ended up with slots pointing at the same three inner arrays, so writing to `copy[0][0]` is the same as writing to `grid[0][0]`.\n\n\n```mermaid\nflowchart LR\n G[grid]:::cyan --> GO[outer array
3 slots]:::orange\n C[copy]:::cyan --> CO[outer array
3 slots]:::orange\n\n GO --> R0[row 0
999, 2, 3]:::green\n GO --> R1[row 1
4, 5, 6]:::green\n GO --> R2[row 2
7, 8, 9]:::green\n\n CO --> R0\n CO --> R1\n CO --> R2\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nTwo outer arrays, three shared rows. A real deep copy of a 2D array means duplicating both the outer array and each inner row.\n\n**Fix:**\n\n\n```java\nimport java.util.Arrays;\n\npublic class DeepGridCopy {\n public static void main(String[] args) {\n int[][] grid = {\n {1, 2, 3},\n {4, 5, 6},\n {7, 8, 9}\n };\n\n int[][] deep = new int[grid.length][];\n for (int i = 0; i < grid.length; i++) {\n deep[i] = grid[i].clone();\n }\n\n deep[0][0] = 999;\n\n System.out.println(\"grid[0][0]: \" + grid[0][0]);\n System.out.println(\"deep[0][0]: \" + deep[0][0]);\n }\n}\n```\n\n\nAllocate the outer array with the correct length, then clone each row into it. Now `deep` has its own outer array and its own three inner rows. Writing to `deep[0][0]` doesn't touch `grid`.\n\nThe picture for the fixed version has two outer arrays and six inner rows, three per side, with no sharing.\n\n\n```mermaid\nflowchart LR\n G[grid]:::cyan --> GR0[row
1, 2, 3]:::green\n G --> GR1[row
4, 5, 6]:::green\n G --> GR2[row
7, 8, 9]:::green\n\n D[deep]:::cyan --> DR0[row
999, 2, 3]:::orange\n D --> DR1[row
4, 5, 6]:::orange\n D --> DR2[row
7, 8, 9]:::orange\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n```\n\n\nA deep copy of an `m x n` 2D array is O(m * n). You allocate the outer array plus `m` new inner arrays and copy `m * n` elements. This is the cost of independence.\n\n---\n\n# Method Cheat Sheet\n\nThe full set of options side by side. Pick based on what you need: a full copy, a range, an in-place shift, or a deep copy of structured data.\n\n\n| Method | What it does | When to use | Returns new array? | Supports range / resize? | Deep? |\n|--------|--------------|-------------|--------------------|--------------------------|-------|\n| Manual `for` loop | You allocate, you copy element by element | Learning purposes, custom transforms during copy | Yes (you allocate it) | Yes (write your own indices) | No (unless you copy elements deeply too) |\n| `Arrays.copyOf(arr, n)` | Allocates a new array of length `n`, copies, pads with defaults if longer | Resizing, full copies when length might change | Yes | Resize only | No |\n| `Arrays.copyOfRange(arr, from, to)` | Allocates a new array, copies the half-open range `[from, to)`, pads if `to` exceeds source | Slicing a subrange | Yes | Range, with padding | No |\n| `System.arraycopy(src, srcPos, dest, destPos, len)` | Copies `len` elements from `src` into `dest`. No allocation | Copy into an existing array, shift in place | No (caller provides the destination) | Range on both ends | No |\n| `arr.clone()` | Returns a new array of the same length and type | Quick full-length copies, no resize needed | Yes | No | No |\n| Loop + per-row `clone()` (2D) | Outer array allocated by you, each row cloned in a loop | Deep-copying a 2D array | Yes | Custom | Yes (for 2D `int[][]`) |\n| Loop + per-element copy (objects) | New array, plus a copy of each object | Deep-copying an array of mutable objects | Yes | Custom | Yes (if your per-element copy is deep) |\n\n\nThe one-line rule for picking: if the array contains primitives, every shallow copy is also a real copy, so `clone()` or `Arrays.copyOf` is fine. If the array contains references (objects or other arrays), and the elements will be mutated through one copy, a loop is needed that copies the elements themselves, not just the outer container.","pageType":"java"}

Copying Arrays

Get Premium