Declaring and Creating Arrays (4.3.A)

In Lesson 4.2 you learned that a collection holds many objects together. The array is Java's simplest collection — a fixed-size, ordered list where every element is the same type.

Syntax: Two Ways to Create an Array

Method 1 — Using new: Creates an array of a given size. All elements start at their default value.

int[] scores = new int[5];       // 5 integers, all initialized to 0
String[] names = new String[3];  // 3 Strings, all initialized to null
boolean[] flags = new boolean[4];// 4 booleans, all initialized to false

Method 2 — Initializer list: Declares the array and fills it with specific values in one line. Java infers the size automatically.

int[] scores = {92, 74, 88, 58};          // size 4, values set immediately
String[] days = {"Mon", "Tue", "Wed"};    // size 3
double[] prices = {1.99, 4.50, 12.00};   // size 3

What the Array Looks Like in Memory

Picture a row of labeled boxes. Each box holds one value. Each box has a number (its index) starting at 0:

This is int[] scores = {92, 74, 88, 58}; — 4 elements, indices 0 through 3, length is 4.

Accessing and Updating Elements (4.3.B)

Reading a Value

Use bracket notation with the index to read a specific element:

int[] scores = {92, 74, 88, 58};

System.out.println(scores[0]);  // prints 92
System.out.println(scores[2]);  // prints 88
System.out.println(scores[3]);  // prints 58 (last element)

Writing (Updating) a Value

Use the same bracket notation on the left side of an assignment to change an element:

scores[1] = 80;   // replaces 74 with 80
scores[3] = 95;   // replaces 58 with 95
// array is now {92, 80, 88, 95}

Using array.length

length is a field (not a method — no parentheses) that gives the number of elements:

int[] scores = {92, 74, 88, 58};
System.out.println(scores.length);       // prints 4
System.out.println(scores[scores.length - 1]);  // prints 58 (last element)

Default Values

When you create an array with new without an initializer list, Java fills every slot automatically:

Array Bounds and ArrayIndexOutOfBoundsException

Java checks every array access at runtime. If your index is negative or ≥ array.length, you get an ArrayIndexOutOfBoundsException:

int[] scores = {92, 74, 88, 58};  // valid indices: 0, 1, 2, 3

scores[-1]           // EXCEPTION: negative index
scores[4]            // EXCEPTION: index 4 doesn't exist (length is 4)
scores[scores.length] // EXCEPTION: same problem — length is 4, last valid is 3

int[] scores = {92, 74, 88, 58};
int last = scores[scores.length - 1];  // 4 - 1 = 3 → scores[3] = 58 ✓

Arrays of Objects

Arrays aren't limited to primitives. You can store objects — including instances of classes you write in Unit 3:

// Assume Student class exists from Unit 3
Student[] roster = new Student[3];
roster[0] = new Student("Alice", 92);
roster[1] = new Student("Ben",   74);
roster[2] = new Student("Carlos", 58);

System.out.println(roster[0].getName());  // prints "Alice"

This is exactly the row-to-object mapping from Lesson 4.2 — now in actual Java syntax. Each array slot holds one object, which represents one record in the data set.

Summary

• Arrays hold a fixed number of elements, all the same type. Size cannot change after creation.
• Two creation styles: new int[n] (default values) and {v1, v2, v3} (initializer list).
• Arrays are 0-indexed. First element is arr[0], last is arr[arr.length - 1].
• array.length is a field, not a method — no parentheses.
• Default values: 0 for numbers, false for boolean, null for objects.
• Accessing an invalid index throws ArrayIndexOutOfBoundsException at runtime.

int[] arr = {5, 10, 15};
System.out.println(arr[3]);

int[] arr = {5, 10, 15};
System.out.println(arr[0]);

int[] arr = {5, 10, 15};
System.out.println(arr[arr.length - 1]);

int[] arr = {5, 10, 15};
System.out.println(arr[2]);

int[] arr = {3, 6, 9, 12};
arr[1] = arr[3];
System.out.println(arr[1]);

int[] nums = new int[4];
nums[0] = 5;
nums[2] = nums[0] * 2;
System.out.println(nums[1] + nums[2] + nums[3]);

int temp = arr[0];
arr[0] = arr[arr.length - 1];
arr[arr.length - 1] = temp;

arr[0] = arr[arr.length - 1];
arr[arr.length - 1] = arr[0];

arr[0] = arr[1];
arr[arr.length - 1] = arr[0];

int temp = arr[arr.length];
arr[0] = arr[arr.length - 1];
arr[arr.length] = temp;

Student[] roster = new Student[3];
roster[0] = new Student("Alice", 92);
roster[2] = new Student("Carlos", 74);

int[] x = {2, 4, 6, 8, 10};
x[0] = x[0] + x[4];
x[4] = x[0] - x[4];
x[0] = x[0] - x[4];
System.out.println(x[0] + " " + x[4]);