0.10.1. Introduction to Fixed-Size 1D Arrays¶

An array is a sequence of values; the values stored within the array are called its elements. An array can store elements of any single type—such as int, double, boolean, String, or custom objects like Pixel or Card. However, all elements within a given array must share the same type, known as the array’s element type.

To use an array, you declare a reference variable of an array type and then instantiate the array object using the new operator. In Java, array types are denoted by placing square brackets ([]) after the element type:

int[] counts = new int[4];
double[] values = new double[size];

Notice that Java has no special “array” keyword. Instead, appending [] to any type turns it into an array type. In the example above:

1. int[] counts declares a variable named counts whose type is “array of integers”.

2. new int[4] instantiates a brand new array object in memory with exactly 4 integer slots.

3. The assignment operator (=) stores the reference to that array in counts.

When allocating an array, the size expression inside the brackets must evaluate to a non-negative integer. If you attempt to allocate an array with a negative size (e.g., new int[-3]), Java will throw a NegativeArraySizeException. Allocating an array of size zero is permitted and produces an “empty array” (often used to represent the absence of data without using null).

0.10.2. Array Bounds, Indexing, and Default Values¶

Each individual storage slot in an array is identified by a numeric position called its index (or subscript). Java arrays use zero-based indexing, exactly like positions in a List or characters in a String:

• The first element is located at index 0 (the “zeroth” element).

• The second element is at index 1.

• The final element is located at index array.length - 1.

To read or write an individual element, specify the array name followed by the index enclosed in square brackets:

int[] counts = new int[4];

When an array is allocated with new, Java automatically initializes every element to a predictable default value based on the element type:

• Numeric types (int, long, short, byte): initialized to 0

• Floating-point types (double, float): initialized to 0.0

• Boolean types (boolean): initialized to false

• Reference types (String, objects): initialized to null

The following memory diagram illustrates the state of counts immediately after instantiation:

The variable counts holds a reference (indicated by the arrow) to the array object in memory. Inside the array, the bold numbers represent the initial element values (all 0), while the numbers above indicate the valid index positions (0 through 3).

Every array has a special, built-in constant field named length that stores the number of elements in the array:

System.out.println("The array has " + counts.length + " slots."); // prints 4

You can use the index operator [] anywhere a regular variable is permitted—in expressions, assignments, or method arguments:

counts[0] = 7;
counts[1] = counts[0] * 2; // counts[1] becomes 14
counts[2]++;               // counts[2] becomes 1
counts[3] -= 60;           // counts[3] becomes -60

After executing these statements, the array’s contents in memory become:

If you attempt to access an index that is negative, or greater than or equal to length (such as counts[4] or counts[-1]), Java immediately throws an ArrayIndexOutOfBoundsException and halts execution.

0.10.3. Arrays Compared to Lists (ArrayList)¶

Because you have already worked with List and ArrayList in Chapter 8, comparing arrays directly with lists highlights their key differences:

When should you choose an array over an ArrayList?

• Use an array when the number of elements is fixed or known in advance (such as 24 hours in a day, 7 days in a week, or 60 minutes in an hour), when maximizing execution speed and memory efficiency is paramount, or when building multi-dimensional grid boards.

• Use an ArrayList when the collection needs to grow or shrink dynamically as elements are added or removed, or when you need built-in search and reordering methods.

0.10.4. Initializing, Printing, and Naming Arrays¶

When you know the initial values of your array elements in advance, Java provides a convenient shorthand known as an array initializer literal:

String[] coffees = {"Espresso", "Mocha", "Decaf", "Americano"};
int[] primes = {2, 3, 5, 7, 11, 13};

This single statement accomplishes three tasks simultaneously:

1. Allocates an array whose length matches the number of comma-separated items inside the braces.

2. Initializes each slot in sequence with the specified values.

3. Assigns the reference to the variable.

Initializer literals are ideal for small, known sequences. For larger arrays, you will typically allocate the array with new and use a loop to initialize the contents:

int[] numbers = new int[100];
for (int i = 0; i < numbers.length; i++)
{
    numbers[i] = i * 2; // sets slots to 0, 2, 4, 6, ..., 198
}

int[] values = {1, 2, 3, 4};
System.out.println(values);

[I@bf3f7e0

import java.util.Arrays;

// ...
System.out.println(Arrays.toString(values)); // prints: [1, 2, 3, 4]

double[] scores = new double[10];
String[] studentNames = new String[25];
Card[] deck = new Card[52]; // or collective singular noun

0.10.5. Array Reference Semantics, Aliasing, and Copying¶

Array variables in Java are reference variables. When you assign one array variable to another, Java copies only the memory reference—it does not create a new array:

double[] a = new double[3];
a[0] = 10.0;
double[] b = a; // b and a now refer to the EXACT SAME array!

This creates an alias: a and b are two names for the same underlying array in memory:

Any modification made through b is immediately visible through a:

b[0] = 42.0;
System.out.println(a[0]); // prints 42.0!

If your goal is to create an independent duplicate of an array, you must allocate a new array of identical length and copy each element individually:

double[] copy = new double[a.length];
for (int i = 0; i < a.length; i++)
{
    copy[i] = a[i];
}

Alternatively, the Java standard library provides Arrays.copyOf() in java.util.Arrays to perform this operation in a single call:

double[] copy = Arrays.copyOf(a, a.length);

After creating a genuine copy, the memory diagram reflects two distinct objects:

Modifying copy[0] now has no effect on a[0].

0.10.6. Iterating Over Arrays: Numeric For vs. For-Each Loops¶

To process all elements in an array, Java offers two primary loop constructs: the counter-controlled numeric for loop and the enhanced for-each loop.

int[] values = {10, 20, 30, 40};

for (int i = 0; i < values.length; i++)
{
    values[i] = values[i] * 2; // doubles each element in place
}

String[] coffees = {"Espresso", "Mocha", "Decaf", "Americano"};

for (String coffee : coffees)
{
    System.out.println(coffee);
}

0.10.7. Array Index Arithmetic: Circular Wrap-Around & The Modulo Operator¶

In Chapter 4, you briefly encountered Java’s remainder operator (%), also known as the modulo operator, for testing whether an integer is even (number % 2 == 0). When working with arrays, the modulo operator becomes one of your most powerful algorithmic tools for index arithmetic.

The expression a % b computes the integer remainder left over when a is divided by b. For any positive integer b and non-negative integer a, the result of a % b is guaranteed to fall strictly within the range:

Notice that for an array of size N (where valid indices are 0 through N - 1), computing index % array.length guarantees that the resulting value is always a valid index within the bounds of the array!

This mathematical property gives rise to several essential array programming patterns:

Player[] players = new Player[4]; // indices 0, 1, 2, 3
int currentPlayerIndex = 0;

// Clunky approach with an if statement:
currentPlayerIndex++;
if (currentPlayerIndex == players.length)
{
    currentPlayerIndex = 0;
}

// Elegant circular wrap-around:
currentPlayerIndex = (currentPlayerIndex + 1) % players.length;

int elapsedHours = 53;
int hourOfDay = elapsedHours % 24; // evaluates to 5 (5:00 AM)

public void printFormatted(int[] data)
{
    for (int i = 0; i < data.length; i++)
    {
        System.out.print(data[i] + "\t");

        // Print a newline every 5 elements:
        if ((i + 1) % 5 == 0)
        {
            System.out.println();
        }
    }
}

int row = index / COLS; // integer division gives row coordinate
int col = index % COLS; // modulo gives column coordinate

0.10.8. Accumulator Idioms: Summing, Averaging, and Counting¶

An accumulator is a programming pattern where a variable accumulates an answer incrementally across loop iterations. Three fundamental accumulator patterns appear constantly in array processing:

public int sum(int[] numbers)
{
    int total = 0;
    for (int n : numbers)
    {
        total += n;
    }
    return total;
}

public double average(int[] numbers)
{
    if (numbers.length == 0)
    {
        return 0.0;
    }
    return (double) sum(numbers) / numbers.length;
}

public int countPassingScores(double[] scores, double passingGrade)
{
    int count = 0;
    for (double score : scores)
    {
        if (score >= passingGrade)
        {
            count++;
        }
    }
    return count;
}

0.10.9. Frequency Histograms & Array Buckets¶

A particularly elegant application of arrays is the frequency histogram (or bucket tallying). In many domains, data attributes fall into a small, discrete range of integers:

• Hours in a day: integers 0 through 23 (size 24)

• Days in a week: integers 0 through 6 (size 7)

• Test scores: integers 0 through 100 (size 101)

Instead of searching through a list of records every time we want to know how many events occurred at a particular hour, we can use the domain attribute directly as an array index!

Consider a Post class modeling social media messages, where getHour() returns an integer from 0 to 23. We can track the message frequency for all 24 hours of the day using a 24-element integer array:

public class PostMonitor
{
    private int postCount;
    private int[] hourCounts;
    private int[] dayCounts;

    public PostMonitor()
    {
        this.postCount = 0;
        this.hourCounts = new int[24]; // 24 slots, all initialized to 0
        this.dayCounts = new int[7];   // 7 slots, all initialized to 0
    }

    public void recordPost(Post post)
    {
        postCount++;

        // Use the post's hour directly as the array index!
        int hour = post.getHour();
        hourCounts[hour]++;

        // Use the post's day of week directly as the index!
        int day = post.getDay();
        dayCounts[day]++;
    }

    public int getHourCount(int hour)
    {
        return hourCounts[hour];
    }
}

0.10.10. Linear Search: Finding Values and Indices¶

When searching for a specific value in an unsorted array, we examine elements one by one from the beginning until we either find the target or run out of elements. This technique is known as linear search.

public boolean contains(int[] array, int target)
{
    for (int value : array)
    {
        if (value == target)
        {
            return true; // found immediately; terminate early
        }
    }
    return false; // searched the entire array without a match
}

public int indexOf(int[] array, int target)
{
    for (int i = 0; i < array.length; i++)
    {
        if (array[i] == target)
        {
            return i; // returns the earliest occurrence
        }
    }
    return -1; // sentinel value: target not found
}

public int lastIndexOf(int[] array, int target)
{
    for (int i = array.length - 1; i >= 0; i--)
    {
        if (array[i] == target)
        {
            return i; // returns the latest occurrence
        }
    }
    return -1;
}

0.10.11. Extrema Algorithms: Maximum, Minimum & Deterministic Tie-Breaking¶

Another universal array algorithmic pattern is finding extrema—the maximum or minimum value in an array, or the index where that extremum occurs.

public int findMax(int[] array)
{
    if (array.length == 0)
    {
        throw new IllegalArgumentException("Cannot find maximum of empty array");
    }

    int max = array[0]; // assume first element is maximum
    for (int i = 1; i < array.length; i++)
    {
        if (array[i] > max)
        {
            max = array[i]; // found a new maximum
        }
    }
    return max;
}

public int getIndexOfLargest(int[] array)
{
    if (array.length == 0)
    {
        return -1;
    }

    int bestIndex = 0;
    for (int i = 1; i < array.length; i++)
    {
        if (array[i] > array[bestIndex])
        {
            bestIndex = i;
        }
    }
    return bestIndex;
}

0.10.12. Writing Test Assertions for Arrays in JUnit¶

Testing methods that manipulate arrays requires verifying both individual elements and the entire array state. The AssertJ library provides comprehensive, fluent assertions for testing arrays in JUnit:

int[] result = monitor.getHourCounts();

// Check the array length
assertThat(result).hasSize(24);
assertThat(result.length).isEqualTo(24);

// Check specific indices
assertThat(result[0]).isEqualTo(0);
assertThat(result[14]).isEqualTo(5);

String[] coffees = barista.getMenu();

assertThat(coffees).containsExactly(
    "Espresso", "Mocha", "Decaf", "Americano");

assertThat(coffees).contains("Mocha", "Americano");

// Verify elements do not appear
assertThat(coffees).doesNotContain("Latte", "Cappuccino");

// Verify boundary elements
assertThat(coffees).startsWith("Espresso");
assertThat(coffees).endsWith("Americano");

// Verify no duplicates for key items
assertThat(coffees).containsOnlyOnce("Espresso");

// Verify an array is empty
int[] empty = new int[0];
assertThat(empty).isEmpty();

0.10.13. Applying Arrays in a Problem¶

This video discusses a “Web-Analyzer” project and illustrates how arrays can be applied to solve real-world domain problems. You do not need to build the project in the video; it is provided as a practical synthesis of array principles in action.

0.10.14. Programming Practice 9¶