Array Creation and Access

Suppose a program keeps the scores from five quizzes. With only what you know so far, you would declare five variables: quiz1, quiz2, quiz3, quiz4, and quiz5. That works, but it causes problems quickly. A class with 30 quizzes needs 30 declarations. And if the program asks “which quiz do you want to see?” and gets back the number 3, there is no way to turn that number into the name quiz3; you would need a long chain of if statements, one per quiz.

In Topic 4.2 you saw that a data set is a collection of related values that a program works through one value at a time. Java needs a way to keep such a collection under one name, with each value reachable by its position. Think of a row of numbered mailboxes in an apartment lobby: one bank of boxes, all the same size, each with a number on the door. You find a box by its number, not by a separate name.

That structure is an array: a single object that stores a fixed number of values, all of the same type. Each value in an array is called an element. The type of the elements is the array’s element type. An array of int holds only int values; an array of String holds only String references. (The mailbox analogy stops working in one way: real mailboxes can hold letters of any shape, but every slot in a Java array holds exactly one value of the element type.)

Why must every element have the same type? Java needs to know, when your code mentions an element, what kind of value it is, so that it can check your code before it runs (the same reason every variable has a declared type, from Topic 1.2). If one array could hold a name in one slot and a score in the next, Java could not tell whether + on an element means addition or concatenation.

Declaring and creating an array

Making an array takes two parts, which are usually written in one statement:

int[] scores = new int[5];

An array is an object, so it is created with the keyword new, just like the objects you made in Topic 1.13. And as with every object, the variable does not contain the array itself; it holds a reference to it. Here is a picture of memory after the statement runs (you will see in 4.3.3 why every slot holds 0):

scores --> [  0 |  0 |  0 |  0 |  0 ]

double[] prices = new double[3];
boolean[] seatTaken = new boolean[40];
String[] names = new String[4];

public class WrongElementType
{
    public static void main(String[] args)
    {
        int[] scores = new double[5];
        String[] names = new String[4];
    }
}

WrongElementType.java:5: error: incompatible types: double[] cannot be converted to int[]
        int[] scores = new double[5];
                       ^
1 error

public class SizeInDeclaration
{
    public static void main(String[] args)
    {
        int[5] scores;
    }
}

An array is only useful if you can reach the values inside it. In the mailbox picture, you open a box by its number. In Java, that number is the element’s index: its position in the array. You met indexes in Topic 1.15, where the characters of a String were numbered starting from 0. Arrays use the same numbering. The first element is at index 0, the second at index 1, and so on.

To name one element, write the array variable, then the index in square brackets: scores[2] means “the element of scores at index 2”. This is called accessing an element. An expression like scores[2] behaves exactly like a variable of the element type: you can print it, use it in arithmetic, and assign a new value to it.

Here is how the indexes line up for an array of three scores:

index:    0    1    2
value:   88   92   75

int[] scores = new int[3];
scores[0] = 88;
scores[1] = 92;
scores[2] = 75;
System.out.println(scores[1]);
scores[2] = scores[2] + 10;
System.out.println(scores[2]);
System.out.println(scores[0] + scores[1]);

92
85
180

The index does not have to be a literal number. Any expression that produces an int works, including a variable or a little arithmetic. This is what solves the problem from 4.3.1: a number the program computes (or reads as input) can choose the element.

int[] stepCounts = new int[4];
stepCounts[0] = 4200;
stepCounts[1] = 6100;
stepCounts[2] = 3900;
stepCounts[3] = 7500;
int day = 2;
System.out.println(stepCounts[day]);
System.out.println(stepCounts[day + 1]);
stepCounts[day] += 500;
System.out.println(stepCounts[day]);
day = 0;
System.out.println(stepCounts[day]);

3900
7500
4400
4200

int[] scores = new int[3];
scores[0] = 88;
scores[1] = 92;
scores[2] = 75;
System.out.print("First score: ");
System.out.println(scores[1]);

First score: 92

int[] prices = new int[3];
prices[0] = 12;
prices[1] = prices[0] * 2;
prices[2] = prices[1] - prices[0];
prices[0] = prices[2] + 1;
System.out.println(prices[0]);
System.out.println(prices[1]);
System.out.println(prices[2]);

13
24
12

In 4.3.2 the first row of each trace showed every element as 0 before anything was stored. That was not a guess. When new creates an array, Java does not leave the memory holding leftover junk. It fills every element with a default value that depends only on the element type.

You have seen these exact values before. In Topic 3.4, instance variables got default values before a constructor set them. Array elements follow the same rules, for the same reason: memory for a new object always starts in a known state, so a program never reads an unpredictable value.

int[] goals = new int[3];
double[] heights = new double[3];
boolean[] present = new boolean[3];
String[] names = new String[3];
System.out.println(goals[0]);
System.out.println(heights[1]);
System.out.println(present[2]);
System.out.println(names[0]);

0
0.0
false
null

Default values are not only something to watch out for; programs rely on them. Here is a tally of votes for three candidates. Each element counts the votes for one candidate, and each count needs to start at 0, which new already did.

int[] votes = new int[3];
votes[1]++;
votes[2]++;
votes[1]++;
System.out.println(votes[0]);
System.out.println(votes[1]);
System.out.println(votes[2]);

0
2
1

public class NullName
{
    public static void main(String[] args)
    {
        String[] names = new String[3];
        names[0] = "Ava";
        System.out.println(names[0].length());
        System.out.println(names[1].length());
    }
}

3
Exception in thread "main" java.lang.NullPointerException: Cannot invoke "String.length()" because "<local1>[1]" is null
	at NullName.main(NullName.java:8)

double[] tips = new double[4];
boolean[] paid = new boolean[4];
tips[1] = 3.5;
paid[1] = true;
tips[2] = tips[1] + tips[3];
System.out.println(tips[2]);
System.out.println(tips[0]);
System.out.println(paid[0]);
System.out.println(paid[1]);

3.5
0.0
false
true

Often you already know every value when you write the program: the days of the school week, the prices on a menu, the answer key to a quiz. Creating an array with new and then assigning each element on its own line works, but it takes one line per element and makes the values hard to see at a glance.

Java has a shorter way. An initializer list is a list of values inside curly braces, separated by commas, that creates an array and fills it in one step:

String[] days = {"Mon", "Tue", "Wed", "Thu", "Fri"};

There is no new and no size. Java counts the values in the list (five here) and makes an array of exactly that many elements. Every value in the list must fit the element type.

String[] days = {"Mon", "Tue", "Wed", "Thu", "Fri"};
double[] prices = {2.50, 3.75, 1.25};
boolean[] answers = {true, false, true, true};
System.out.println(days[2]);
System.out.println(prices[1]);
System.out.println(answers[1]);
days[0] = "Monday";
System.out.println(days[0]);

days     index:   0      1      2      3      4
         value: "Mon"  "Tue"  "Wed"  "Thu"  "Fri"

prices   index:   0      1      2
         value:  2.5   3.75   1.25

answers  index:   0      1      2      3
         value: true  false  true   true

Wed
3.75
false
Monday

The values in the list do not have to be literals. Any expression of the right type is allowed, and Java evaluates each one when the array is created.

int base = 10;
int[] targets = {base, base * 2, base * 3 + 5};
System.out.println(targets[2]);
base = 50;
System.out.println(targets[0]);

35
10

Both ways of creating an array are useful. Here they are side by side:

public class InitializerLater
{
    public static void main(String[] args)
    {
        int[] scores = {88, 92, 75};
        scores = {90, 95, 80};
    }
}

InitializerLater.java:6: error: illegal start of expression
        scores = {90, 95, 80};
                 ^

int[] laps = {4, 7, 2, 9};
laps[2] = laps[0] + laps[3];
laps[0] = laps[laps[2] - 10];
System.out.println(laps[0]);
System.out.println(laps[2]);

9
13

public class MixedList
{
    public static void main(String[] args)
    {
        int[] ages = {15, 16.5, 17};
        String[] labels = {"gold", 2, "bronze"};
    }
}

Code that works with an array often needs to know how many elements it has, for example to reach the last element. Hard-coding the number is risky: if someone later changes the initializer list from 4 values to 6, every 3 that meant “the last index” is now wrong.

Every array carries its own count. The number of elements is the array’s length, and you read it with the length attribute: write the array variable, a dot, and length, with no parentheses. colors.length is a value stored with the array object, not a method call.

The length is set once, at the moment the array is created (by the number in new int[6] or by the count of values in the list), and it can never change afterward. Java gives an array one block of memory with room for exactly that many elements, side by side; there is no extra room to grow into. The length attribute acts like a final variable from Topic 3.7: you may read it, but no statement can assign to it.

String[] colors = {"red", "green", "blue", "gold"};
int[] blank = new int[6];
System.out.println(colors.length);
System.out.println(blank.length);
System.out.println(colors[colors.length - 1]);
System.out.println(colors[0].length());

4
6
gold
3

Lines 5 and 6 sit next to each other on purpose, because these two are easy to mix up:

int[] scores = {88, 92, 75};
scores = new int[4];
scores[3] = 81;
System.out.println(scores.length);
System.out.println(scores[0]);
System.out.println(scores[3]);

4
0
81

before line 2:   scores --> [ 88 | 92 | 75 ]

after line 2:    scores --> [  0 |  0 |  0 |  0 ]
                            [ 88 | 92 | 75 ]   (no variable refers to this one)

public class LengthMistakes
{
    public static void main(String[] args)
    {
        int[] scores = {88, 92, 75};
        System.out.println(scores.length());
        scores.length = 4;
    }
}

LengthMistakes.java:6: error: cannot find symbol
        System.out.println(scores.length());
                                 ^
  symbol:   method length()
  location: variable scores of type int[]
LengthMistakes.java:7: error: cannot assign a value to final variable length
        scores.length = 4;
              ^
2 errors

double[] times = {12.4, 11.9, 13.2, 12.8, 12.1};
int last = times.length - 1;
System.out.println(times.length);
System.out.println(times[last]);
System.out.println(times[times.length / 2]);

5
12.1
13.2

Indexes start at 0, and the last element is at length - 1. Put those together and you get the full rule: for an array of length n, the valid indexes are 0, 1, 2, … up to n - 1, inclusive. An array of length 3 has valid indexes 0, 1, and 2, and nothing else. Index 3 is not “the end of the array”; it is a slot that does not exist.

index:   -1  |   0    1    2   |   3
               [ 88 | 92 | 75 ]
         out     valid indexes     out

Using any index outside that range, whether to read or to store, makes Java throw an ArrayIndexOutOfBoundsException while the program runs. This is the array version of the StringIndexOutOfBoundsException from Topic 1.15. Java checks every index at the moment it is used, because silently reading or writing memory outside the array would damage other data in the program.

Why doesn’t the compiler catch it? The compiler checks only that the index is an int. It does not know what value a variable like day will hold or how long an array will be when the line runs, so a bad index can be found only while the program runs.

public class OffByOne
{
    public static void main(String[] args)
    {
        int[] scores = {88, 92, 75};
        System.out.println(scores[scores.length - 1]);
        System.out.println(scores[scores.length]);
        System.out.println("Done");
    }
}

75
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
	at OffByOne.main(OffByOne.java:7)

Negative indexes are just as invalid, and they often come from converting a person’s numbering (starting at 1) to an index by subtracting 1.

public class NegativeIndex
{
    public static void main(String[] args)
    {
        String[] floors = {"Lobby", "Gym", "Pool"};
        int choice = 1;
        floors[choice - 1] = "Entrance";
        System.out.println(floors[0]);
        choice = 0;
        floors[choice - 1] = "Basement";
        System.out.println(floors[0]);
    }
}

Entrance
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index -1 out of bounds for length 3
	at NegativeIndex.main(NegativeIndex.java:10)

When an index comes from a calculation or from input, you can make sure it is valid before using it with an if statement and a compound condition from Topics 2.3 and 2.5:

public class GuardedLookup
{
    public static void main(String[] args)
    {
        String[] prizes = {"sticker", "pen", "mug", "hoodie"};
        int pick = 4;
        if (pick >= 0 && pick < prizes.length)
        {
            System.out.println(prizes[pick]);
        }
        else
        {
            System.out.println("No prize at that spot");
        }
        pick = 3;
        if (pick >= 0 && pick < prizes.length)
        {
            System.out.println(prizes[pick]);
        }
        else
        {
            System.out.println("No prize at that spot");
        }
    }
}

No prize at that spot
hoodie

public class StoreOutOfBounds
{
    public static void main(String[] args)
    {
        int[] scores = new int[3];
        scores[0] = 88;
        scores[1] = 92;
        scores[2] = 75;
        System.out.println(scores.length);
        scores[3] = 60;
        System.out.println(scores.length);
    }
}

3
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
	at StoreOutOfBounds.main(StoreOutOfBounds.java:10)

In 4.3.1 you read that elements can be primitive values or object references. So far most examples used int, double, and boolean, where each element holds the value itself. When the element type is a class, such as String or a class you wrote in Unit 3, each element holds a reference to an object, exactly as a variable of that class type would (Topic 1.13).

That one fact explains everything about these arrays:

• Creating the array does not create the objects. new Player[3] makes an array with three slots for references. Each slot starts as null (4.3.3). No Player objects exist until you create them with new Player(…) and store them in the slots.
• An element can be used like any variable of its class. team[0].getName() follows the reference in team[0] and calls getName on that object, using the dot operator from Topic 1.14.
• Copying an element copies the reference. As in Topic 3.6, two elements, or an element and a variable, can refer to the same object.

class Player
{
    private String name;
    private int points;

    public Player(String name)
    {
        this.name = name;
        points = 0;
    }

    public String getName()
    {
        return name;
    }

    public int getPoints()
    {
        return points;
    }

    public void addPoints(int amount)
    {
        points += amount;
    }
}

public class TeamRoster
{
    public static void main(String[] args)
    {
        Player[] team = new Player[3];
        System.out.println(team[0]);
        team[0] = new Player("Ana");
        team[1] = new Player("Ben");
        team[1].addPoints(6);
        team[0].addPoints(4);
        team[1].addPoints(2);
        System.out.println(team[0].getName());
        System.out.println(team[1].getPoints());
        System.out.println(team[2]);
    }
}

null
Ana
8
null

The same rules apply to an array of String. Each element refers to a String object, so you can call String methods from Topic 1.15 on an element:

cities --> [ ref | ref | ref ]
              |     |     |
              v     v     v
          "Denver" "Austin" "Boston"

String[] cities = {"Denver", "Austin", "Boston"};
String code = cities[1].substring(0, 3);
System.out.println(code);
System.out.println(cities[2].length());
cities[0] = cities[0] + " CO";
System.out.println(cities[0]);

Aus
6
Denver CO

Because elements hold references, an element and a variable can be aliases, two names for one object.

class Player
{
    private String name;
    private int points;

    public Player(String name)
    {
        this.name = name;
        points = 0;
    }

    public String getName()
    {
        return name;
    }

    public int getPoints()
    {
        return points;
    }

    public void addPoints(int amount)
    {
        points += amount;
    }
}

public class SharedPlayer
{
    public static void main(String[] args)
    {
        Player star = new Player("Cara");
        Player[] lineup = new Player[2];
        lineup[0] = star;
        lineup[1] = new Player("Dev");
        lineup[0].addPoints(10);
        System.out.println(star.getPoints());
        star.addPoints(3);
        System.out.println(lineup[0].getPoints());
        lineup[0] = lineup[1];
        System.out.println(lineup[0].getName());
        System.out.println(star.getName());
    }
}

10
13
Dev
Cara

class Player
{
    private String name;
    private int points;

    public Player(String name)
    {
        this.name = name;
        points = 0;
    }

    public String getName()
    {
        return name;
    }

    public int getPoints()
    {
        return points;
    }

    public void addPoints(int amount)
    {
        points += amount;
    }
}

public class EmptyRoster
{
    public static void main(String[] args)
    {
        Player[] team = new Player[2];
        team[0] = new Player("Ana");
        team[0].addPoints(5);
        System.out.println(team[0].getPoints());
        team[1].addPoints(5);
        System.out.println(team[1].getPoints());
    }
}

5
Exception in thread "main" java.lang.NullPointerException: Cannot invoke "Player.addPoints(int)" because "<local1>[1]" is null
	at EmptyRoster.main(EmptyRoster.java:36)

class Player
{
    private String name;
    private int points;

    public Player(String name)
    {
        this.name = name;
        points = 0;
    }

    public String getName()
    {
        return name;
    }

    public int getPoints()
    {
        return points;
    }

    public void addPoints(int amount)
    {
        points += amount;
    }
}

public class RosterTrace
{
    public static void main(String[] args)
    {
        Player[] squad = new Player[3];
        squad[2] = new Player("Eli");
        squad[0] = new Player("Fay");
        squad[1] = squad[2];
        squad[1].addPoints(7);
        squad[2].addPoints(1);
        squad[0].addPoints(squad[2].getPoints());
        System.out.println(squad[0].getPoints());
        System.out.println(squad[1].getName());
        System.out.println(squad[2].getPoints());
    }
}

8
Eli
8

This program records lunch votes. It uses an initializer list for the menu, new with default values for the vote counts, the length attribute to keep the two arrays the same size, index arithmetic to reach the last element, and an index check before reading. Predict all five lines of output before you read the trace.

public class LunchVote
{
    public static void main(String[] args)
    {
        String[] menu = {"Pizza", "Tacos", "Salad", "Soup"};
        int[] votes = new int[menu.length];

        votes[1]++;
        votes[3]++;
        votes[1]++;
        votes[0] += 2;

        System.out.println(menu.length + " choices");
        System.out.println(menu[1] + ": " + votes[1]);
        System.out.println(menu[2] + ": " + votes[2]);

        int last = menu.length - 1;
        System.out.println(menu[last] + ": " + votes[last]);

        int request = 4;
        if (request >= 0 && request < menu.length)
        {
            System.out.println(menu[request]);
        }
        else
        {
            System.out.println("Choice " + request + " is not on the menu");
        }
    }
}

index:     0        1        2        3
menu:   "Pizza"  "Tacos"  "Salad"  "Soup"
votes:     0        0        0        0

4 choices
Tacos: 2
Salad: 0
Soup: 1
Choice 4 is not on the menu

Arrays produce a handful of error messages over and over. Use this table to go from the message to the cause.

• An array is an object that stores many values of a single element type under one name. The elements can be primitive values or object references, and the array variable holds a reference to the array.
• new int[5] creates an array of a given length with every element set to its default (0, 0.0, false, or null); an initializer list such as {88, 92, 75} creates an array whose length and contents come from the listed values, and it may appear only in the declaration.
• arrayName[index] reads or changes one element. The index can be any int expression, and the first element is at index 0.
• An array’s length is fixed when it is created and is read with the length attribute, without parentheses. Assigning a new array to a variable makes a new array; it never resizes the old one.
• The valid indexes are 0 through length - 1. Any other index throws an ArrayIndexOutOfBoundsException when the line runs, which the compiler cannot catch.
• In an array of a class type, creating the array creates only null slots; each object must be created and stored before its methods are called, and copying an element copies a reference.

double[] miles = new double[4];
int[] trips = {2, 5, 1};
miles[trips[2]] = 3.5;
miles[0] = miles[1] * trips.length;
trips[0] = trips[0] + miles.length;
System.out.println(miles[0]);
System.out.println(miles[3]);
System.out.println(trips[0]);

10.5
0.0
6

public class LastBadge
{
    public static void main(String[] args)
    {
        String[] badges = {"Bronze", "Silver", "Gold", "Platinum"};
        int count = badges.length;
        System.out.println(count + " badges");
        System.out.println("Top badge: " + badges[count]);
    }
}

        System.out.println("Top badge: " + badges[count - 1]);

class Book
{
    private String title;

    public Book(String title)
    {
        this.title = title;
    }

    public String getTitle()
    {
        return title;
    }
}

public class ShelfNull
{
    public static void main(String[] args)
    {
        Book[] shelf = new Book[3];
        shelf[0] = new Book("Dune");
        System.out.println(shelf[0].getTitle());
        System.out.println(shelf[1].getTitle());
    }
}

int[] code = {3, 0, 2, 1};
System.out.println(code[code[0]]);
code[code[3]] = code[code[2]] + 5;
System.out.println(code[1]);
System.out.println(code[code[1] - 5]);

1
7
2

// I
double[] d = new double[2];
d[2] = 1.5;

// II
boolean[] b = {true, false};
b[1] = !b[0];
System.out.println(b[1]);

// III
String[] s = new String[2];
System.out.println(s[0]);

• I can explain what an array is, why all its elements share one type, and declare and create one with new. Reread
• I can read and change one element using an index in square brackets, starting from index 0. Reread
• I can state the default value of each element of a new int, double, boolean, or reference-type array. Reread
• I can create an array with an initializer list and say how its length is decided. Reread
• I can use the length attribute, reach the last element, and explain why an array cannot grow. Reread
• I can list the valid indexes of an array and predict when an ArrayIndexOutOfBoundsException is thrown. Reread
• I can trace an array of object references, including null slots and two names for one object. Reread