Java Arrays

Java Arrays

Every program works with groups of related data — a list of student marks, a set of product prices, a collection of employee names. Java's most fundamental way to store a fixed-size group of same-type values is an array.

An array is a single variable that holds multiple values of the same type, arranged in a numbered sequence. Instead of declaring int mark1, int mark2, int mark3 ... int mark50 for fifty students, you declare int[] marks and store all fifty values in one place. Each value is accessed by its position number — called an index — starting from zero.

What Is an Array?

An array is a fixed-size, ordered collection of elements of the same data type stored in contiguous memory locations. Once created, its size cannot change.

An int array of size 5:

  Index:  [  0  ] [  1  ] [  2  ] [  3  ] [  4  ]
  Value:  [ 85  ] [ 90  ] [ 78  ] [ 95  ] [ 88  ]
             ↑
           marks[0] = 85
           marks[1] = 90
           marks[3] = 95

Key points:
  — Index starts at 0 (not 1)
  — Last valid index = length - 1
  — All elements must be the same type
  — Size is fixed at creation time

Declaring and Creating Arrays

There are three ways to create an array in Java. Understanding all three prevents confusion when reading code written by others.

Output:
Way 1 — fill later    : [85, 90, 78, 95, 88]
Way 2 — initialiser   : [Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday]
Way 3 — new + values  : [499.0, 1299.0, 2499.0, 899.0]

Default values:
int    defaults: [0, 0, 0]
double defaults: [0.0, 0.0, 0.0]
boolean defaults: [false, false, false]
String defaults : [null, null, null]

When you declare new int[5], the JVM allocates five integer slots and fills each with 0. For String[], it fills with null. Knowing default values prevents the common mistake of reading an array element before setting it and wondering why you get 0 or null.

Accessing and Modifying Elements

Array elements are accessed using their index inside square brackets. The index must be a non-negative integer between 0 and array.length - 1.

Output:
First city  : Mumbai
Last city   : Hyderabad
Array length: 5
After update: Bangalore
City at index 3: Chennai

Error: Index 10 out of bounds for length 5
Error: Index -1 out of bounds for length 5

array.length — note: no parentheses — is a field, not a method. It always equals the number of slots the array was created with. The last valid index is always array.length - 1. Any index outside this range throws ArrayIndexOutOfBoundsException at runtime.

Traversing Arrays

Traversal means visiting every element in order. Java gives you three ways to loop through an array.

Output:
Traditional for loop:
  scores[0] = 72
  scores[1] = 88
  scores[2] = 91
  scores[3] = 65
  scores[4] = 78
  scores[5] = 95
  scores[6] = 83

Enhanced for-each:
  Total = 572
  Average = 81.71

While loop (stop at first score above 90):
  Found score > 90 at index 2: 91

The for-each loop is the cleanest and safest traversal — no index management, no off-by-one errors. Use the traditional for loop when you need to know the index — for printing position numbers, skipping elements, or modifying elements at specific positions.

Common Array Operations

Output:
Maximum mark: 95
Minimum mark: 55
Sum: 622 | Average: 77.75
Students passed (>=60): 7
Mark 88 found at index: 3
Sorted  : [55, 61, 72, 78, 83, 88, 90, 95]
Original: [55, 90, 72, 88, 61, 95, 78, 83]
Maximum mark: 95
Minimum mark: 55
Sum: 622 | Average: 77.75
Students passed (>=60): 7
Mark 88 found at index: 3
Sorted  : [55, 61, 72, 78, 83, 88, 90, 95]
Original: [55, 90, 72, 88, 61, 95, 78, 83]
First 4 : [55, 90, 72, 88]
Filled  : [99, 99, 99, 99, 99]

Arrays.sort() modifies the original array in place. If you need to sort without changing the original, copy it first with Arrays.copyOf() — as shown above.

Array vs ArrayList — When to Use Which

Basic Example

Output

Total  : 417
Average: 83.40
Highest: 95

1. ›marks is an array holding five int values — one variable representing the whole group of scores.
2. ›The for-each loop visits every element in order, adding each one to total and updating max whenever a larger value is found.
3. ›average divides the total by marks.length, so the calculation always stays correct even if the array's size changes later.
4. ›This is the pattern behind almost every array-processing program: loop once, accumulate a running answer as you go.

Best Practices

Always use array.length in loop conditions — never a hardcoded number. Writing for (int i = 0; i < 5; i++) breaks the moment the array size changes. for (int i = 0; i < marks.length; i++) always works correctly regardless of how many elements are in the array.

Check the length before accessing the first or last element. marks[0] on an empty array throws ArrayIndexOutOfBoundsException. Before writing max = arr[0], verify arr.length > 0. This single check prevents the most common array crash in beginner code.

Use the for-each loop when you only need values. for (int mark : marks) is shorter, cleaner, and impossible to get the index wrong — because there is no index to manage. Switch to the indexed for loop only when you genuinely need the index — for position tracking, modifying elements, or printing "element number N".

Never hardcode array sizes outside the declaration. The size of an array should live in exactly one place — the declaration or the constant that controls it. Using the magic number 7 scattered through a program that processes a week of data breaks silently when the data changes to include 8 days.

Common Mistakes

Mistake 1 — ArrayIndexOutOfBoundsException From Off-by-One

Mistake 2 — Printing an Array Directly

An array does not override toString(). Printing it directly gives the type code and memory address. Always use Arrays.toString(array) for readable output.

Mistake 3 — Confusing length (field) With length() (method)

Mistake 4 — Trying to Resize an Array

Interview Questions

Q1. What is an array in Java and what are its key characteristics?

An array is a fixed-size, ordered collection of elements of the same data type stored in contiguous memory. Once created, its size cannot change. Elements are accessed by a zero-based integer index — the first element is at index 0, the last at array.length - 1. Arrays can hold primitives (int[], double[]) as well as objects (String[], custom classes). Accessing an index outside the valid range throws ArrayIndexOutOfBoundsException at runtime.

Q2. What is the default value of array elements in Java?

The JVM initialises every array element to its type's default value. For int, short, byte, and long, the default is 0. For double and float, it is 0.0. For boolean, it is false. For char, it is the null character '\u0000'. For any reference type — String, objects — it is null. This automatic initialisation prevents reading garbage memory values but means checking for null before using object array elements is important.

Q3. What is the difference between array length and String length()?

For arrays, length is a final field — no parentheses: arr.length. It holds the number of elements the array was created with. For String, length() is a method — with parentheses: str.length(). It returns the number of characters in the string. Using parentheses on an array (arr.length()) or omitting them on a String (str.length) causes a compile error. This distinction trips up most beginners at least once.

Q4. What is ArrayIndexOutOfBoundsException and what causes it?

ArrayIndexOutOfBoundsException is a runtime exception thrown when code tries to access an array element at an invalid index — either negative or greater than or equal to the array's length. The most common causes are: using <= instead of < in a loop condition (i <= arr.length accesses one index past the end); hardcoding a size that has changed; accessing arr[0] on an empty array; or computing an index incorrectly. The fix is always to verify the index is within 0 to arr.length - 1.

Q5. What is the difference between Array and ArrayList in Java?

An array has a fixed size set at creation — elements cannot be added or removed, only modified. An ArrayList grows and shrinks automatically as elements are added or removed. Arrays can hold both primitives and objects directly. ArrayList can only hold objects — primitives must be wrapped (Integer, Double). Arrays have direct element access via arr[i]; ArrayList uses list.get(i). Arrays are faster and use less memory for fixed-size data. ArrayList is more flexible for collections that grow or shrink.

Q6. How do you copy an array in Java?

Three common ways: Arrays.copyOf(original, newLength) creates a new array with the specified length, copying elements from the original; System.arraycopy(src, srcPos, dest, destPos, length) copies elements between arrays with fine-grained control over positions; and Arrays.copyOfRange(original, from, to) copies a slice. The assignment int[] b = a does NOT copy — it makes b point to the same array as a. Mutating b will change a too.

FAQs

Can an array hold elements of different types?

No — a typed array (int[], String[]) can only hold elements of its declared type. However, Object[] can hold any type of object since every class extends Object. In practice, mixing types in an array is poor design — use a class or record to group related but differently-typed values.

What is the maximum size of an array in Java?

The theoretical maximum is Integer.MAX_VALUE — about 2.1 billion elements. In practice, the limit is the available JVM heap memory. Trying to allocate an array too large for the heap throws OutOfMemoryError. For most programs, arrays with a few thousand to a few million elements are well within limits.

Is the length of an array fixed after creation?

Yes. Once created with new int[5], the array always has exactly 5 slots. You can modify the values in those slots, but you cannot add a 6th slot. If you need more capacity, create a new larger array, copy the elements using System.arraycopy() or Arrays.copyOf(), and discard the old array. ArrayList handles this automatically — it is the right choice when the size varies.

Can you have an array of arrays in Java?

Yes — this is called a two-dimensional array (2D array). int[][] grid = new int[3][4] creates 3 rows of 4 integers each. Each row is itself an array accessible with grid[0], grid[1], etc. Individual elements are accessed with grid[row][col]. Java also supports jagged arrays where each row can have a different length.

Does Arrays.sort() modify the original array?

Yes. Arrays.sort(arr) sorts the elements of arr in place — the original array is modified. If you need the sorted order without changing the original, use int[] copy = Arrays.copyOf(arr, arr.length) first, then sort the copy.

Summary

An array is Java's foundation for working with fixed-size groups of same-type data. Declare it with the type and [], create it with new Type[size] or an initialiser, access elements with zero-based indices, and always loop with arr.length rather than a hardcoded number.

The two habits that prevent the most common array bugs: check arr.length > 0 before reading the first element, and use arr.length - 1 for the last element rather than counting manually. When the size needs to change at runtime — adding or removing items — ArrayList is the right choice over an array.

For interviews, be ready to explain default values, the difference between length field and length() method, why System.out.println(array) gives a useless output, and how to correctly copy an array without accidentally sharing the reference.

What to Read Next