{"title":"Arrays Basics","description":"","content":"An array is Java's simplest way to hold many values of the same type under one name. Once you have an array, you can store a whole list of product prices, stock counts, or customer emails in a single variable and reach any one of them by position. This lesson covers what an array is, how to create one, how to read and write elements, and the small set of rules that make arrays both efficient and easy to misuse.\n\n---\n\n# Why Arrays Exist\n\nConsider a shopping cart with five items where we want to track each item's price. Without arrays, the only tool we have is a separate variable for each value.\n\n\n```java\npublic class CartWithoutArray {\n public static void main(String[] args) {\n double price1 = 29.99;\n double price2 = 49.50;\n double price3 = 19.00;\n double price4 = 99.99;\n double price5 = 15.25;\n\n double total = price1 + price2 + price3 + price4 + price5;\n System.out.println(\"Cart total: $\" + total);\n }\n}\n```\n\n\nThis works, but it falls apart fast. What if the cart has 50 items? Or 500? You'd need a variable for every one, and any code that touches them has to spell each name out by hand. There's no way to write a loop that says \"go through every price\", because the names `price1`, `price2`, `price3` are unrelated to the computer. They just look related to humans.\n\nAn array fixes this. It groups values of the same type into a single object and gives each value an integer position called an **index**. With an array, the five prices live under one name, and we reach each one by asking for index `0`, `1`, `2`, and so on.\n\n\n```java\npublic class CartWithArray {\n public static void main(String[] args) {\n double[] productPrices = {29.99, 49.50, 19.00, 99.99, 15.25};\n System.out.println(\"First price: $\" + productPrices[0]);\n System.out.println(\"Last price: $\" + productPrices[4]);\n System.out.println(\"Number of items: \" + productPrices.length);\n }\n}\n```\n\n\nThe benefit isn't just shorter code. It's that the values now form a real collection the program can walk through, count, or pass around as one thing. The rest of this lesson breaks down how that works.\n\n---\n\n# Declaring an Array\n\nDeclaring an array variable tells Java the type of values it will hold. Two syntax forms exist.\n\n\n```java\nint[] stockCounts; // preferred, modern Java style\nint stockCounts[]; // legacy C-style syntax\n```\n\n\nBoth compile and behave identically. The first form is the convention in modern Java because it reads as \"an `int` array named `stockCounts`\", which matches how you'd say it out loud. The second form is left over from Java's C heritage and turns up occasionally in older code or in method signatures, but new code should stick with `int[]`.\n\nA declaration on its own does not create the array. It only creates a variable that **could** point to one. Until we assign an actual array to it, the variable holds `null`.\n\n\n```java\npublic class DeclareOnly {\n public static void main(String[] args) {\n int[] stockCounts;\n // System.out.println(stockCounts.length); // Compile error: variable not initialized\n System.out.println(\"Variable declared but no array yet.\");\n }\n}\n```\n\n\nTrying to read `stockCounts.length` before assigning anything to it gives a compile-time error inside a method, because Java requires local variables to be definitely assigned before use. The fix is to assign an array, which the next section covers.\n\n---\n\n# Creating an Array with `new`\n\nTo create an array, use the `new` keyword followed by the type and a size in square brackets.\n\n\n```java\npublic class CreateWithNew {\n public static void main(String[] args) {\n int[] stockCounts = new int[5];\n System.out.println(\"First stock count: \" + stockCounts[0]);\n System.out.println(\"Array length: \" + stockCounts.length);\n }\n}\n```\n\n\n`new int[5]` allocates an array that can hold five `int` values and returns a reference to it. The variable `stockCounts` then points at that array. The size, `5`, fixes the capacity. Once set, the array's length is locked in for its lifetime. You cannot grow it later. If you need a list that resizes itself, Java has `ArrayList` for that, which we cover in Section 15.\n\nYou can split the declaration and the creation across two lines if it helps readability.\n\n\n```java\npublic class SplitDeclaration {\n public static void main(String[] args) {\n double[] productRatings;\n productRatings = new double[3];\n productRatings[0] = 4.5;\n productRatings[1] = 3.0;\n productRatings[2] = 5.0;\n System.out.println(\"First rating: \" + productRatings[0]);\n }\n}\n```\n\n\nThe size doesn't have to be a constant. Any `int` expression works, including a variable or a value read from a method.\n\n\n```java\npublic class DynamicSize {\n public static void main(String[] args) {\n int cartItemCount = 7;\n String[] customerEmails = new String[cartItemCount];\n System.out.println(\"Created an array with room for \" + customerEmails.length + \" emails.\");\n }\n}\n```\n\n\n`new int[n]` allocates memory for `n` slots and zero-initializes every slot. The cost grows with `n`. A `new int[1_000_000_000]` will try to allocate four gigabytes and most likely throw `OutOfMemoryError`. Size your arrays to the data you actually have.\n\n---\n\n# Default Values\n\nWhen you create an array with `new`, Java fills every slot with that type's default value before handing the array back to you. The default depends on the element type.\n\n\n| Element type | Default value |\n| ------------ | ------------- |\n| `byte`, `short`, `int`, `long` | `0` |\n| `float`, `double` | `0.0` |\n| `char` | `'\\u0000'` (the null character) |\n| `boolean` | `false` |\n| Any object type (`String`, custom classes) | `null` |\n\n\nThis matters because reading a slot you never wrote to is legal. It returns the default rather than failing.\n\n\n```java\npublic class DefaultValues {\n public static void main(String[] args) {\n int[] stockCounts = new int[3];\n double[] productPrices = new double[3];\n boolean[] inStockFlags = new boolean[3];\n String[] customerEmails = new String[3];\n\n System.out.println(\"int default: \" + stockCounts[0]);\n System.out.println(\"double default: \" + productPrices[0]);\n System.out.println(\"boolean default: \" + inStockFlags[0]);\n System.out.println(\"String default: \" + customerEmails[0]);\n }\n}\n```\n\n\nThe `String` default is `null`, not the empty string `\"\"`. That distinction matters. A `null` reference points at nothing, so trying to call a method on it throws `NullPointerException`. An empty string is still a real `String` object that just happens to contain zero characters. We'll see what `null` elements look like in practice later in this lesson.\n\n---\n\n# Array Literals\n\nWhen you already know the values an array should hold, the array-literal syntax skips the `new` ceremony entirely. List the values in braces and Java figures out the size and the type from the context.\n\n\n```java\npublic class ArrayLiteral {\n public static void main(String[] args) {\n int[] productPrices = {29, 49, 19, 99, 15};\n System.out.println(\"Item at index 0: $\" + productPrices[0]);\n System.out.println(\"Item at index 3: $\" + productPrices[3]);\n System.out.println(\"Total items: \" + productPrices.length);\n }\n}\n```\n\n\nThe literal `{29, 49, 19, 99, 15}` creates an `int[]` of length `5` and stores the listed values at indices `0` through `4`, in order. It's shorthand for the slightly longer `new int[]{29, 49, 19, 99, 15}` form, which you must use if you're assigning the array somewhere other than the original declaration.\n\n\n```java\npublic class ArrayLiteralLater {\n public static void main(String[] args) {\n int[] productPrices;\n productPrices = new int[]{29, 49, 19, 99, 15};\n System.out.println(\"First price: $\" + productPrices[0]);\n }\n}\n```\n\n\nWithout the `new int[]` prefix, `productPrices = {29, 49, ...};` would not compile, because the brace form is only allowed in the same statement as the declaration.\n\nString arrays work the same way.\n\n\n```java\npublic class CategoryNames {\n public static void main(String[] args) {\n String[] productCategories = {\"Books\", \"Electronics\", \"Clothing\", \"Toys\"};\n System.out.println(\"Second category: \" + productCategories[1]);\n System.out.println(\"Number of categories: \" + productCategories.length);\n }\n}\n```\n\n\n---\n\n# Indexing and the `length` Field\n\nEvery element in an array has an index, starting at `0`. An array of length `N` has valid indices `0` through `N - 1`. Read or write an element using square brackets with the index inside.\n\n\n```java\npublic class IndexingExample {\n public static void main(String[] args) {\n int[] cartQuantities = {2, 1, 3, 5, 1};\n\n // Read\n int firstQuantity = cartQuantities[0];\n int thirdQuantity = cartQuantities[2];\n System.out.println(\"First item quantity: \" + firstQuantity);\n System.out.println(\"Third item quantity: \" + thirdQuantity);\n\n // Write\n cartQuantities[0] = 10;\n System.out.println(\"Updated first quantity: \" + cartQuantities[0]);\n }\n}\n```\n\n\nThe expression `cartQuantities[0]` is read as \"the element of `cartQuantities` at index `0`\". On the right side of an `=`, it reads the value. On the left side, it writes a new value into that slot.\n\nHere's how the array sits in memory after the write. The variable holds a reference to an object on the heap, and the object holds the actual values plus a length.\n\n\n```mermaid\nflowchart LR\n Var[cartQuantities
local variable]:::cyan --> Arr[Array object on heap
length = 5]:::orange\n Arr --> I0[\"index 0
value: 10\"]:::green\n Arr --> I1[\"index 1
value: 1\"]:::teal\n Arr --> I2[\"index 2
value: 3\"]:::teal\n Arr --> I3[\"index 3
value: 5\"]:::teal\n Arr --> I4[\"index 4
value: 1\"]:::teal\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 classDef teal fill:#38d9a9,stroke:#000,color:#000\n```\n\n\nThe variable on the left doesn't contain the five numbers. It contains a single reference (an arrow) that points at the array object. We'll come back to that detail in a moment.\n\nTo find out how many elements an array has, use the `length` field. Two important rules about `length`:\n\n- It is a **field**, not a method. There are no parentheses. `cartQuantities.length` is correct. `cartQuantities.length()` is a compile error.\n- It is **final**. You can read it but you cannot assign to it. The size is fixed when the array is created.\n\n\n```java\npublic class LengthField {\n public static void main(String[] args) {\n int[] orderIds = {101, 102, 103, 104, 105, 106};\n System.out.println(\"Number of orders: \" + orderIds.length);\n System.out.println(\"Last index: \" + (orderIds.length - 1));\n System.out.println(\"Last order ID: \" + orderIds[orderIds.length - 1]);\n }\n}\n```\n\n\nThe pattern `array[array.length - 1]` is the standard way to read the last element. It works for any non-empty array regardless of size.\n\n`arr.length` is O(1). Java stores the length in a header inside the array object, so reading it is a single memory access and never depends on how big the array is.\n\nFor now, knowing how to index by hand and how to ask the array for its length is enough.\n\n---\n\n# Arrays Are Reference Types\n\nAn array variable does not hold the array's data. It holds a **reference** to the array object, which lives on the heap. We touched on reference types in Section 2's [Reference Types](/learn/java/reference-types) lesson, so this is a quick recap focused on what it means for arrays specifically.\n\nTwo consequences matter:\n\n- Assigning one array variable to another does not copy the array. Both variables point at the same object.\n- Passing an array to a method does not copy it either. The method receives the same reference and can change the original.\n\nHere's the assignment case.\n\n\n```java\npublic class ArrayAliasing {\n public static void main(String[] args) {\n int[] originalPrices = {10, 20, 30};\n int[] aliasPrices = originalPrices;\n\n aliasPrices[0] = 999;\n\n System.out.println(\"originalPrices[0] = \" + originalPrices[0]);\n System.out.println(\"aliasPrices[0] = \" + aliasPrices[0]);\n }\n}\n```\n\n\nWriting through `aliasPrices` is visible through `originalPrices`, because both names refer to the exact same array. This isn't a bug, it's the defining behavior of reference types. Section 16 covers how to make a true copy of an array when you need one.\n\n\n```mermaid\nflowchart LR\n A[originalPrices]:::cyan --> Arr[Array object
10, 20, 30]:::orange\n B[aliasPrices]:::cyan --> Arr\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n```\n\n\nTwo variables, one array. That's why a write through either name changes what both names see.\n\n**What's wrong with this code?**\n\n\n```java\npublic class CopyBug {\n public static void main(String[] args) {\n int[] originalCart = {5, 10, 15};\n int[] backup = originalCart;\n originalCart[0] = 0;\n System.out.println(\"Backup first item: \" + backup[0]);\n }\n}\n```\n\n\nThe author wanted `backup` to be an independent copy of `originalCart` so the line `originalCart[0] = 0` would not affect it. But `backup = originalCart` only copies the reference, not the data. After the write, `backup[0]` also reads `0`.\n\n**Fix:**\n\nUse a real copy. We cover the proper tools (`Arrays.copyOf`, `System.arraycopy`, `clone`) in the [Copying Arrays](/learn/java/copying-arrays) lesson later in this section. The point for now is that plain assignment is not a copy.\n\n---\n\n# Fixed Size and Bounds Checking\n\nOnce an array is created, its length cannot change. There's no `add`, no `remove`, no `resize`. You can only overwrite the values already in the slots that exist. If your data outgrows the array, you have to allocate a new, larger one and move the values over (or use `ArrayList`, which manages that growth for you behind the scenes).\n\nWhen you index into an array, Java checks that the index is in range. A negative index or an index `>= length` throws `ArrayIndexOutOfBoundsException` at runtime. This is a safety feature: it means a typo can't silently read or corrupt memory belonging to something else.\n\n**What's wrong with this code?**\n\n\n```java\npublic class OutOfBounds {\n public static void main(String[] args) {\n int[] productPrices = {29, 49, 19};\n System.out.println(productPrices[3]);\n }\n}\n```\n\n\nThe array has length `3`, so valid indices are `0`, `1`, `2`. Index `3` is one past the end. The program throws:\n\n\n```shell\nException in thread \"main\" java.lang.ArrayIndexOutOfBoundsException:\n Index 3 out of bounds for length 3\n```\n\n\n**Fix:**\n\nUse a valid index, or check the length first.\n\n\n```java\npublic class BoundsSafe {\n public static void main(String[] args) {\n int[] productPrices = {29, 49, 19};\n int wantedIndex = 3;\n if (wantedIndex >= 0 && wantedIndex < productPrices.length) {\n System.out.println(productPrices[wantedIndex]);\n } else {\n System.out.println(\"Index \" + wantedIndex + \" is out of range.\");\n }\n }\n}\n```\n\n\nNegative indices have the same problem.\n\n\n```java\npublic class NegativeIndex {\n public static void main(String[] args) {\n int[] productPrices = {29, 49, 19};\n System.out.println(productPrices[-1]); // throws ArrayIndexOutOfBoundsException\n }\n}\n```\n\n\nUnlike some other languages, Java does not interpret `-1` as \"the last element\". Negative indices are just invalid.\n\n\n```mermaid\nflowchart LR\n Start([Read productPrices i]):::cyan --> Check{Is i between
0 and length minus 1?}:::orange\n Check -- yes --> Read[Return the value
at slot i]:::green\n Check -- no --> Throw[Throw
ArrayIndexOutOfBoundsException]:::red\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 classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\nThis bounds check runs on every read and every write. It's why Java arrays are memory-safe even when the index comes from user input or another part of the program.\n\n---\n\n# Arrays of Objects\n\nArrays of object types (like `String[]` or `Customer[]`) work the same way as arrays of primitives, with one twist: each slot holds a reference, and the default value is `null`. Creating a `new String[5]` gives you five slots, all `null`. You have to put actual `String` objects in them before you can do anything useful.\n\n\n```java\npublic class ProductNames {\n public static void main(String[] args) {\n String[] productNames = new String[3];\n System.out.println(\"Before assignment: \" + productNames[0]);\n\n productNames[0] = \"Wireless Mouse\";\n productNames[1] = \"Laptop Stand\";\n productNames[2] = \"USB Cable\";\n\n System.out.println(\"After assignment: \" + productNames[0]);\n System.out.println(\"Second product: \" + productNames[1]);\n }\n}\n```\n\n\nThe risk with object arrays is forgetting that some slots may still be `null`. Calling a method on a `null` element throws `NullPointerException`.\n\n**What's wrong with this code?**\n\n\n```java\npublic class NullElementBug {\n public static void main(String[] args) {\n String[] productNames = new String[3];\n productNames[0] = \"Wireless Mouse\";\n // productNames[1] and productNames[2] are still null\n System.out.println(productNames[1].length()); // NullPointerException\n }\n}\n```\n\n\nOnly `productNames[0]` was assigned a real `String`. Slots `1` and `2` are still `null`. Calling `.length()` on a `null` reference throws `NullPointerException`.\n\n**Fix:**\n\nCheck for `null` before calling a method on an element, or make sure every slot is assigned a real value before using it.\n\n\n```java\npublic class NullElementFix {\n public static void main(String[] args) {\n String[] productNames = new String[3];\n productNames[0] = \"Wireless Mouse\";\n if (productNames[1] != null) {\n System.out.println(productNames[1].length());\n } else {\n System.out.println(\"Slot 1 is empty.\");\n }\n }\n}\n```\n\n\nThe array literal form sidesteps this problem because every slot gets a real value at creation time.\n\n\n```java\npublic class ProductNamesLiteral {\n public static void main(String[] args) {\n String[] productNames = {\"Wireless Mouse\", \"Laptop Stand\", \"USB Cable\"};\n System.out.println(\"Name length: \" + productNames[0].length());\n }\n}\n```\n\n\nWhen the values are known up front, prefer the literal. When building the array piece by piece, remember that empty slots are `null` until you fill them.\n\n---\n\n# Summary\n\n- An array stores a fixed number of values of the same type under one name and reaches each value by an integer index that starts at `0`.\n- Declare an array with `int[] productPrices;`. Create it with `new int[5]` or an array literal `{29, 49, 19}`. A declaration alone doesn't create anything.\n- Default values are `0` for integers, `0.0` for floating-point, `false` for `boolean`, `'\\u0000'` for `char`, and `null` for any object type.\n- Use `arr.length` (a field, no parens) to read the size. The size is fixed for the life of the array. For a resizable list, use `ArrayList` (covered in Section 15).\n- Valid indices run from `0` to `length - 1`. Any other index throws `ArrayIndexOutOfBoundsException` at runtime.\n- Array variables hold a reference, not the data. Assigning one array variable to another makes two names for the same array, so a write through either name is visible through both.\n- For arrays of object types like `String[]`, unset slots are `null`, and calling a method on a `null` element throws `NullPointerException`. Either fill every slot or check for `null` before using one.\n\nThe next lesson takes these basics and shows the loop patterns that turn arrays into a real tool: walking through every element, summing values, finding a maximum, reversing in place, and the rest of the standard array operations.","pageType":"java"}

Arrays Basics

Get Premium