How do arrays work in Java?

Question

Accepted Answer

An **array** is a fixed-size, ordered collection of elements of the **same type**, stored contiguously in memory. Arrays are foundational, but their fixed size means you often prefer `ArrayList` for dynamic collections. ## Declaring and creating arrays ```java int[] nums = new int[5]; // size 5, default-initialized to 0 int[] nums2 = {1, 2, 3, 4, 5}; // declare + initialize with values String[] names = new String[3]; // objects default to null nums[0] = 10; // set by index (0-based) int x = nums[0]; // get by index nums.length; // 5 — the size (a field, NOT a method!) ``` Arrays have a **fixed size** set at creation — you can't grow or shrink them. Elements default to type-appropriate zeros (`0`, `0.0`, `false`, `null`). ## A common gotcha: length is a field ```java nums.length; // ✅ array — a field (no parentheses) str.length(); // ✅ String — a method (parentheses) list.size(); // ✅ collection — a method ``` Array `length` is a field; String `length()` and collection `size()` are methods — a frequent point of confusion. ## Bounds checking ```java int[] arr = {1, 2, 3}; arr[5]; // ❌ ArrayIndexOutOfBoundsException — Java checks bounds at runtime ``` Java throws an exception for out-of-bounds access (unlike C, which has undefined behavior) — safer, but you must stay within `0` to `length-1`. ## Iterating ```java // enhanced for-each (when you don't need the index) for (int n : nums) { System.out.println(n); } // traditional for (when you need the index) for (int i = 0; i < nums.length; i++) { nums[i] *= 2; } ``` ## Multidimensional arrays ```java int[][] matrix = {{1, 2}, {3, 4}}; // array of arrays matrix[0][1]; // 2 ``` ## Arrays vs ArrayList — when to use which ```text Array → fixed size, slightly faster, can hold primitives directly (int[]) ArrayList → DYNAMIC size (grow/shrink), rich methods (add/remove/contains), but holds objects only (Integer, not int) ``` ```java List list = new ArrayList<>(); list.add(1); // grows dynamically — no fixed size list.remove(0); ``` Use a plain array for fixed-size, performance-sensitive, or primitive data; use `ArrayList` when the size changes or you need convenient operations. ## Why it matters Arrays are a fundamental data structure in Java — fast, memory-efficient, contiguous storage used directly and as the backing for many collections (ArrayList wraps an array). Understanding their fixed-size nature, 0-based indexing, runtime bounds checking, the `length` field (vs method) gotcha, and especially **when to use an array vs ArrayList** (fixed/primitive/fast vs dynamic/convenient) is essential. Arrays appear constantly in algorithms and performance-critical code, while knowing their limitations (no resizing) explains why dynamic collections exist and are usually preferred for general use.