Unit 4: Data Collections

1. Personal data is a privacy risk

Every time someone uses a computer, an app or a website, personal data can be collected: names, locations, contacts, search history, health or school records. Once this data is stored on a computer system, the person’s privacy is at risk 4.1.A.1. Stored data can be stolen in a data breach, shared with other companies, or combined with other data to reveal more than the user ever agreed to share.

Programmers make choices that decide how big that risk is. When you develop a new program, you should try to safeguard the personal privacy of the user 4.1.A.1:

• Collect only what you need. A fitness app that counts steps does not need the user’s contact list.
• Protect what you store. Keep personal data away from places where other users or programs can read it.
• Keep it only as long as needed. Old data that is deleted cannot leak.
• Be honest with users. Tell them what is collected and why.

Watch out: “The data is only stored, not shared” does not make it safe. Storage itself is the risk.

2. Algorithmic bias

Algorithmic bias describes systemic and repeated errors in a program that create unfair outcomes for a specific group of users 4.1.B.1. “Systemic” means the error comes from how the program or its data is built, so it happens again and again to the same group.

Example: a face-unlock feature is trained mostly on photos of adults. It works well for adults but often fails for children. The program has no single “bug” line, yet it keeps treating one group of users unfairly. The cause is the data used to build it.

Feature	One random error	Algorithmic bias
How often?	Once, by chance	Repeated
Who is affected?	Anyone	A specific group of users
Where it comes from	A slip in one run	The design or the data (systemic)

3. How was the data collected?

Before you use a data set to extrapolate new information or draw conclusions, you should know how the data was collected and whether that method could bring bias 4.1.B.2.

A school wants to know how students travel to school. Compare two collection methods:

Collection method	Possible bias
An online form shared only in the cycling club group chat	Cyclists are over-represented, so “most students cycle” would be a biased conclusion.
A short question asked to every student at the start of first lesson	Everyone has the same chance to answer, so the result is much more representative.

Every answer in the first data set may be true, but the method still produces a biased picture.

4. Incomplete and inaccurate data

Some data sets are incomplete (values are missing) or inaccurate (values are wrong). If a program is developed or used with such data, it can work incorrectly or inefficiently 4.1.B.3.

In this example, a weather station failed on one day and stored -999.0 as a “missing” marker. The program averages the readings without knowing that.

double day1 = 21.5;
double day2 = 23.0;
double day3 = -999.0;   // sensor failed; this is not a real temperature
double day4 = 22.5;

double average = (day1 + day2 + day3 + day4) / 4;
System.out.println("Average temperature: " + average);

Output:

Average temperature: -233.0

The algorithm is correct, but the inaccurate data makes the answer useless. A program can also become inefficient with bad data, for example by processing thousands of duplicate records.

Watch out: when a question describes missing values, typing errors or duplicate records, the expected answer is usually that the program may produce incorrect results.

5. Choosing the right data set

The contents of a data set are usually related to a specific question or topic. A data set collected for one question might not give correct answers, or support extrapolation, for a different question 4.1.C.1.

Question: “Which hour of the day is busiest at a city library?”

Data set	Appropriate?	Why
Library entrance gate counts, by hour, for the last year	Yes	It measures visits per hour at that library.
Number of books borrowed per month	No	Monthly totals cannot show hours, and borrowing is not the same as visiting.
Gate counts, by hour, from a different city’s library	No	It is about a different library, so it cannot answer the question for this one.
A survey asking residents their favorite book	No	It is about a different topic.

To choose, check that the data set matches the question’s topic, place (population) and time period, and that it measures the thing the question asks about.

1. What a data set is

A data set is a collection of specific pieces of information, or data 4.2.A.1. You meet data sets everywhere:

Everyday data set	The pieces of data
A week of temperatures	18.5, 21.0, 19.5, …
A class’s quiz scores	7, 9, 10, 6, …
A playlist	song titles
A step counter	steps per day

2. Processing values one at a time

You can manipulate and analyze a data set to solve a problem or answer a question 4.2.A.2. The key pattern: the values are accessed and used one at a time, and each one is processed according to the outcome you want 4.2.A.2.

Problem: “On how many days this week did a runner run more than 5 km?” Written in plain language, the algorithm is:

1. Set a counter to 0.
2. Look at the next day’s distance.
3. If that distance is greater than 5, add 1 to the counter.
4. Repeat steps 2 and 3 until every day has been looked at.
5. The counter is the answer.

This “visit each value and update a running result” pattern is called a traversal in code, and it is the heart of the rest of Unit 4.

3. Plan with a table or chart

Data can be represented in a diagram such as a chart or table, and that visual can be used to plan the algorithm 4.2.A.3. Here is the runner’s week as a table, with an extra row that traces the counter after each value is processed:

Day	Mon	Tue	Wed	Thu	Fri	Sat	Sun
Distance (km)	4.0	6.5	5.0	8.0	3.5	10.0	5.5
Greater than 5?	no	yes	no	yes	no	yes	yes
Counter after this day	0	1	1	2	2	3	4

The trace shows the answer is 4, and it also catches a common trap: 5.0 is not greater than 5, so Wednesday does not count.

A chart works too. A bar chart of the distances with a line drawn at 5 km lets you count the bars above the line, which is exactly what the algorithm does one bar at a time.

4. From plan to code (preview)

Once the table works on paper, each written step becomes a line of code. Topic 4.3 shows how to store the data in an array; this preview shows how closely the code follows the plan.

double[] distances = {4.0, 6.5, 5.0, 8.0, 3.5, 10.0, 5.5};
int count = 0;                          // step 1
for (double d : distances)              // steps 2 and 4: each value, one at a time
{
    if (d > 5)                          // step 3
    {
        count++;
    }
}
System.out.println("Days over 5 km: " + count);   // step 5

Output:

Days over 5 km: 4

Watch out: the trace table is also your test. If the code prints something different from the last cell of your trace, either the plan or the code has a mistake.

1. What an array is

An array stores multiple values of the same type 4.3.A.1. Instead of six separate variables for six scores, you use one array variable with six elements. The values can be primitive values (such as int, double or boolean) or object references (such as String objects) 4.3.A.1.

The type of an array is written with square brackets after the element type:

int[] goals;          // an array of int values
double[] prices;      // an array of double values
String[] players;     // an array of String references

Declaring the variable does not create the array yet. An array is an object, so it is created with new or with an initializer list (sections 2 and 3). This page is about one-dimensional (1D) arrays: a single row of elements.

Watch out: every element must match the declared type.

int[] scores = {90, 85.5, 77};

Compiler error:

error: incompatible types: possible lossy conversion from double to int

2. Creating an array with new

When you create an array with the keyword new, you give its length, and every element is set to the default value for its type 4.3.A.3:

Element type	Default value
int	0
double	0.0
boolean	false
any reference type (String, a class)	null

int[] goals = new int[4];
double[] prices = new double[3];
boolean[] present = new boolean[2];
String[] players = new String[3];

System.out.println(goals[0] + " " + prices[0] + " " + present[0] + " " + players[0]);
System.out.println("goals has " + goals.length + " elements");

Output:

0 0.0 false null
goals has 4 elements

The length of an array is established when it is created and cannot be changed 4.3.A.2. You read it with the length attribute 4.3.A.2. Notice: no parentheses. length is an attribute of the array, not a method.

int[] goals = new int[4];
int n = goals.length();

Compiler error:

error: cannot find symbol

And because the length cannot change, you cannot assign to it:

int[] goals = new int[4];
goals.length = 10;

Compiler error:

error: cannot assign a value to final variable length

3. Initializer lists

An initializer list creates an array and fills it with the values you list, all in one step 4.3.A.4. The length is the number of values in the list.

String[] days = {"Mon", "Tue", "Wed", "Thu", "Fri"};
int[] laps = {62, 58, 60};

System.out.println(days.length);
System.out.println(laps.length);

Output:

5
3

Here is how days looks in memory. The index row is what you use to reach each element.

index	0	1	2	3	4
days	“Mon”	“Tue”	“Wed”	“Thu”	“Fri”

4. Accessing and modifying elements

Square brackets [] with an index access an element, and the same brackets on the left of = modify it 4.3.A.5.

int[] scores = {7, 4, 9, 6};

System.out.println(scores[2]);     // read index 2

scores[1] = 10;                    // change index 1
scores[3] = scores[3] + 2;         // read index 3, add 2, store it back
scores[0]++;                       // works like any int variable

System.out.println(scores[0] + " " + scores[1] + " " + scores[2] + " " + scores[3]);

Output:

9
8 10 9 8

index	0	1	2	3
before	7	4	9	6
after	8	10	9	8

The index can be any int expression, such as a variable or scores.length - 1:

int[] scores = {7, 4, 9, 6};
int i = 1;
System.out.println(scores[i + 1]);
System.out.println(scores[scores.length - 1]);   // always the last element

Output:

9
6

5. Valid indexes and ArrayIndexOutOfBoundsException

The valid index values for an array are 0 through one less than the length of the array, inclusive 4.3.A.6. For an array of length 4, that means 0, 1, 2 and 3. Using any index outside that range results in an ArrayIndexOutOfBoundsException 4.3.A.6.

The code compiles, because the compiler does not check index values. The error happens at run time, and the program stops.

int[] scores = {7, 4, 9, 6};
System.out.println(scores[3]);
System.out.println(scores[4]);
System.out.println("done");

Output:

6
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4

Real view: this is the first line the console shows. “done” is never printed, because the exception stops the program. A negative index such as scores[-1] causes the same exception.

Watch out: scores[scores.length] is always out of bounds. The last element is scores[scores.length - 1].

6. Arrays of object references

An array of a reference type stores references, not the objects themselves 4.3.A.1. After new, every element is null, so you must assign objects before calling methods on them.

String[] team = new String[3];
team[0] = "Ana";
team[2] = "Leo";

System.out.println(team[0].length());
System.out.println(team[1]);
System.out.println(team[1].length());

Output:

3
null
Exception in thread "main" java.lang.NullPointerException: Cannot invoke "String.length()" because "team[1]" is null

index	0	1	2
team	“Ana”	null	“Leo”

Printing a null element is fine; it prints null. Calling a method on it, such as team[1].length(), throws a NullPointerException. (The exact wording after the colon depends on your Java version and settings; on the AP® exam you only need the exception name.)

1. What a traversal is

Traversing an array means using repetition statements (loops) to access all of the elements in an array, or an ordered sequence of them 4.4.A.1. “Ordered sequence” matters: a traversal can visit every element front to back, but also backward, every other element, or just part of the array.

2. Indexed for loops and while loops

A traversal with an indexed for loop or a while loop accesses the elements through their indexes 4.4.A.2. The loop variable is the index, and arr[i] is the element.

int[] temps = {12, 15, 9, 20};

for (int i = 0; i < temps.length; i++)
{
    System.out.println("Day " + i + ": " + temps[i]);
}

Output:

Day 0: 12
Day 1: 15
Day 2: 9
Day 3: 20

The same traversal written as a while loop: the three parts of the for header move to three places 4.4.A.2.

int[] temps = {12, 15, 9, 20};

int i = 0;                      // start
while (i < temps.length)        // condition
{
    System.out.println("Day " + i + ": " + temps[i]);
    i++;                        // update
}

Output:

Day 0: 12
Day 1: 15
Day 2: 9
Day 3: 20

Because you control the index, you can visit an ordered sequence instead of everything:

int[] temps = {12, 15, 9, 20, 17};

for (int i = temps.length - 1; i >= 0; i--)     // backward
{
    System.out.print(temps[i] + " ");
}
System.out.println();

for (int i = 0; i < temps.length; i += 2)       // every other element
{
    System.out.print(temps[i] + " ");
}
System.out.println();

Output:

17 20 9 15 12 
12 9 17 

An indexed loop can also change elements, because temps[i] on the left of = writes into the array:

int[] temps = {12, 15, 9, 20};
for (int i = 0; i < temps.length; i++)
{
    temps[i] = temps[i] * 2;
}
System.out.println(temps[0] + " " + temps[1] + " " + temps[2] + " " + temps[3]);

Output:

24 30 18 40

Watch out: the most common traversal bug is <= instead of <.

int[] temps = {12, 15, 9, 20};
for (int i = 0; i <= temps.length; i++)
{
    System.out.println(temps[i]);
}

Output:

12
15
9
20
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4

3. The enhanced for loop

An enhanced for loop header declares a variable, called the enhanced for loop variable. On each iteration, that variable is assigned a copy of the next element, without using its index 4.4.A.3. Read the colon as “in”: “for each score in scores”.

int[] scores = {8, 6, 10};
int total = 0;

for (int score : scores)
{
    total += score;
}
System.out.println("Total: " + total);

Output:

Total: 24

The type of the loop variable must match the element type (int for an int[], String for a String[]).

4. Assigning to the loop variable changes nothing

Because the loop variable holds a copy, assigning a new value to it does not change the value stored in the array 4.4.A.4.

int[] scores = {8, 6, 10};

for (int score : scores)
{
    score = 0;                  // changes only the copy
}
System.out.println(scores[0] + " " + scores[1] + " " + scores[2]);

Output:

8 6 10

index	0	1	2
scores before	8	6	10
scores after	8	6	10

The code compiles and runs with no error, which is why this is a classic exam trap. To reset the array, use an indexed loop: scores[i] = 0;.

5. Enhanced for loops with object references

When an array stores object references, the loop variable gets a copy of each reference. The copy still points to the same object, so calling a method on the loop variable can modify that object’s attributes 4.4.A.5. What it does not change is the references stored in the array 4.4.A.5.

public class Team
{
    public static void main(String[] args)
    {
        Player[] squad = {new Player("Mia", 3), new Player("Sam", 5)};

        for (Player p : squad)
        {
            p.addPoints(10);            // changes the object p refers to
        }
        System.out.println(squad[0].getPoints() + " " + squad[1].getPoints());

        for (Player p : squad)
        {
            p = new Player("New", 0);   // changes only the copy of the reference
        }
        System.out.println(squad[0].getName() + " " + squad[1].getName());
    }
}

class Player
{
    private String name;
    private int points;

    public Player(String n, int pts)
    {
        name = n;
        points = pts;
    }

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

    public int getPoints()
    {
        return points;
    }

    public String getName()
    {
        return name;
    }
}

Output:

13 15
Mia Sam

The first loop changed the players’ points (an attribute of each object). The second loop tried to put new players in the array, but the array still refers to Mia and Sam.

6. Rewriting an enhanced for loop

Code that traverses an array with an enhanced for loop can always be rewritten with an indexed for loop or a while loop 4.4.A.6. The pattern: the loop variable x becomes arr[i].

String[] words = {"red", "blue", "green"};

for (String w : words)                        // enhanced for
{
    System.out.print(w.length() + " ");
}
System.out.println();

for (int i = 0; i < words.length; i++)        // indexed for
{
    System.out.print(words[i].length() + " ");
}
System.out.println();

int k = 0;                                    // while
while (k < words.length)
{
    System.out.print(words[k].length() + " ");
    k++;
}
System.out.println();

Output:

3 4 5 
3 4 5 
3 4 5 

The opposite is not always possible. Choose an indexed loop when you need any of these:

You need to…	Enhanced for?	Indexed for or while?
read every element, in order	yes	yes
know the position (index) of an element	no	yes
compare an element with its neighbor	no	yes
change the values stored in the array	no	yes
go backward or skip elements	no	yes

1. Minimum and maximum

There are standard algorithms that use array traversals, and the first ones find a minimum or maximum value 4.5.A.1. The plan: start with the first element as the “best so far”, then compare every other element and replace the best when a new one beats it.

public static int findMax(int[] arr)
{
    int max = arr[0];
    for (int i = 1; i < arr.length; i++)
    {
        if (arr[i] > max)
        {
            max = arr[i];
        }
    }
    return max;
}

int[] depths = {-12, -4, -30, -7};
System.out.println(findMax(depths));

Output:

-4

Watch out: if max started at 0, this call would return 0, a value that is not even in the array. For a minimum, flip the comparison to <. To find the index of the max instead of the value, store maxIndex = 0 and compare arr[i] > arr[maxIndex].

2. Sum, average and count

To compute a sum, start at 0 and add every element. The average is the sum divided by the number of elements 4.5.A.1. To determine the number of elements having a particular property, start a counter at 0 and add 1 each time an element passes the test 4.5.A.1.

int[] goals = {2, 0, 3, 1, 4, 0, 1};

int sum = 0;
int count = 0;
for (int g : goals)
{
    sum += g;
    if (g >= 2)          // the property: 2 or more goals
    {
        count++;
    }
}
double average = (double) sum / goals.length;

System.out.println("Sum: " + sum);
System.out.println("Average: " + average);
System.out.println("Games with 2+ goals: " + count);
System.out.println("Integer division: " + sum / goals.length);

Output:

Sum: 11
Average: 1.5714285714285714
Games with 2+ goals: 3
Integer division: 1

Watch out: sum / goals.length with two int values is integer division. Cast one side to double first.

3. At least one, and all

To determine if at least one element has a property, return true as soon as you find one; only after checking every element can you return false 4.5.A.1. To determine if all elements have a property, return false as soon as one fails; only after the loop can you return true 4.5.A.1.

public static boolean anyFreezing(double[] temps)
{
    for (double t : temps)
    {
        if (t < 0)
        {
            return true;        // one is enough
        }
    }
    return false;               // checked them all, none found
}

public static boolean allPassing(int[] scores)
{
    for (int s : scores)
    {
        if (s < 60)
        {
            return false;       // one failure is enough
        }
    }
    return true;                // checked them all, none failed
}

double[] week = {3.5, 1.0, -2.0, 4.5};
int[] quiz = {75, 88, 59, 91};
System.out.println(anyFreezing(week));
System.out.println(allPassing(quiz));

Output:

true
false

Watch out: this version of allPassing is wrong, because it returns on the very first element:

public static boolean allPassingBroken(int[] scores)
{
    for (int s : scores)
    {
        if (s >= 60)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    return true;
}

int[] quiz = {75, 88, 59, 91};
System.out.println(allPassingBroken(quiz));

Output:

true

It looked only at 75 and stopped. The correct answer is false, because 59 fails.

4. Consecutive pairs and duplicates

To access all consecutive pairs of elements, look at arr[i] and arr[i + 1] 4.5.A.1. Because arr[i + 1] must be a valid index, the loop stops one early: i < arr.length - 1.

int[] steps = {4000, 6500, 6200, 9000, 12000};

for (int i = 0; i < steps.length - 1; i++)
{
    int change = steps[i + 1] - steps[i];
    System.out.println("Day " + i + " to day " + (i + 1) + ": " + change);
}

Output:

Day 0 to day 1: 2500
Day 1 to day 2: -300
Day 2 to day 3: 2800
Day 3 to day 4: 3000

With i < steps.length, the last pass would read steps[5] and throw an ArrayIndexOutOfBoundsException.

To determine the presence or absence of duplicate elements, compare each element with every element after it 4.5.A.1. The inner loop starts at i + 1, so no element is compared with itself and no pair is checked twice.

public static boolean hasDuplicate(String[] names)
{
    for (int i = 0; i < names.length; i++)
    {
        for (int j = i + 1; j < names.length; j++)
        {
            if (names[i].equals(names[j]))
            {
                return true;
            }
        }
    }
    return false;
}

String[] signUps = {"Ada", "Ben", "Cleo", "Ben"};
String[] team = {"Ada", "Ben", "Cleo"};
System.out.println(hasDuplicate(signUps));
System.out.println(hasDuplicate(team));

Output:

true
false

Watch out: if the inner loop started at j = 0, every name would be compared with itself and the method would always return true. Use equals, not ==, to compare String objects.

5. Shift and rotate

To shift elements left, every element moves to the index one lower and the first value is lost. To rotate left, you save that first value and put it in the empty last spot 4.5.A.1.

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

int first = queue[0];                       // save the value that falls off
for (int i = 0; i < queue.length - 1; i++)
{
    queue[i] = queue[i + 1];                // move each element one place left
}
queue[queue.length - 1] = first;            // rotate: wrap it around

for (int q : queue)
{
    System.out.print(q + " ");
}
System.out.println();

Output:

20 30 40 50 10 

index	0	1	2	3	4
before	10	20	30	40	50
after shift left (last spot not set yet)	20	30	40	50	50
after rotate left	20	30	40	50	10

A plain shift left stops after the loop; the last spot usually gets a filler value such as 0.

To shift or rotate right, the loop must run backward, from the end toward index 1. Otherwise each value overwrites the next one before it is moved.

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

int last = queue[queue.length - 1];
for (int i = queue.length - 1; i > 0; i--)
{
    queue[i] = queue[i - 1];
}
queue[0] = last;

for (int q : queue)
{
    System.out.print(q + " ");
}
System.out.println();

Output:

50 10 20 30 40 

Watch out: a forward loop for a right shift copies the first value everywhere:

int[] queue = {10, 20, 30, 40, 50};
for (int i = 1; i < queue.length; i++)
{
    queue[i] = queue[i - 1];
}
for (int q : queue)
{
    System.out.print(q + " ");
}
System.out.println();

Output:

10 10 10 10 10 

6. Reverse

To reverse the order of the elements in place, swap the first and last, then the second and second-to-last, and so on until the middle 4.5.A.1. The mirror of index i is arr.length - 1 - i. A swap needs a temporary variable.

String[] podium = {"gold", "silver", "bronze", "fourth", "fifth"};

for (int i = 0; i < podium.length / 2; i++)
{
    String temp = podium[i];
    podium[i] = podium[podium.length - 1 - i];
    podium[podium.length - 1 - i] = temp;
}
for (String p : podium)
{
    System.out.print(p + " ");
}
System.out.println();

Output:

fifth fourth bronze silver gold 

index	0	1	2	3	4
before	“gold”	“silver”	“bronze”	“fourth”	“fifth”
after i = 0 (swap 0 and 4)	“fifth”	“silver”	“bronze”	“fourth”	“gold”
after i = 1 (swap 1 and 3)	“fifth”	“fourth”	“bronze”	“silver”	“gold”

The loop stops when i reaches 5 / 2, which is 2; the middle element stays put. If the loop ran to podium.length, it would swap every pair a second time and put the array back in its original order.

A second way is to build a new array, filling it from the back of the original:

int[] laps = {61, 59, 64, 58};
int[] reversed = new int[laps.length];
for (int i = 0; i < laps.length; i++)
{
    reversed[laps.length - 1 - i] = laps[i];
}
for (int lap : reversed)
{
    System.out.print(lap + " ");
}
System.out.println();

Output:

58 64 59 61 

1. Files and the classes that open them

A file is storage for data that persists when the program is not running, and a program can retrieve that data while it runs 4.6.A.1. A variable disappears when the program ends; a file such as scores.txt stays on the disk.

A file is connected to a program with two classes: File and Scanner 4.6.A.2. You open a file by creating a File object, with the file name as the argument of the constructor File(String str), where str is the pathname of the file 4.6.A.3. Then you pass that File to the Scanner(File f) constructor, which creates a Scanner that reads from it 4.6.A.6.

Step	Code	What it does
1. Name the file	File f = new File("scores.txt");	Connects a File object to the file name
2. Make a reader	Scanner input = new Scanner(f);	A Scanner that reads from that file
3. Read	input.nextInt(), input.next(), …	Returns the next piece of data
4. Close	input.close();	Ends the connection

File and IOException are in the java.io package, so an import statement must make them available 4.6.A.5. Scanner is in java.util, so it needs an import too.

2. throws IOException

When you use the File class, Java requires you to say what to do if the file with that name cannot be opened. One way is to add throws IOException to the header of the method that uses the file 4.6.A.4. If the file name is invalid, the program then terminates 4.6.A.4.

The data file used in this section, scores.txt:

12 7 25
9 14
30

A complete program that reads the first two numbers:

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class FirstScores
{
    public static void main(String[] args) throws IOException
    {
        File f = new File("scores.txt");
        Scanner input = new Scanner(f);

        int a = input.nextInt();
        int b = input.nextInt();
        System.out.println(a + b);

        input.close();
    }
}

Output:

19

Real view: forget throws IOException and the code does not compile.

import java.io.File;
import java.util.Scanner;

public class NoThrows
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner(new File("scores.txt"));
        System.out.println(input.nextInt());
        input.close();
    }
}

Compiler error:

error: unreported exception FileNotFoundException; must be caught or declared to be thrown

A FileNotFoundException is a kind of IOException, which is why throws IOException covers it. Forget the import for File and you get a different compiler error:

import java.io.IOException;
import java.util.Scanner;

public class NoImport
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("scores.txt"));
        input.close();
    }
}

Compiler error:

error: cannot find symbol

With everything correct but a file name that does not exist (here score.txt, a typo), the program compiles and then terminates when it runs:

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class Typo
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("score.txt"));
        System.out.println("opened");
        input.close();
    }
}

Output:

Exception in thread "main" java.io.FileNotFoundException: score.txt (No such file or directory)

“opened” is never printed. (On some operating systems the message in brackets is worded differently.)

3. Scanner methods

These Scanner methods are in the Java Quick Reference 4.6.A.6. A token is a piece of text separated from the next one by whitespace (spaces, tabs or line breaks).

Method	Returns	If it goes wrong
int nextInt()	the next int	InputMismatchException if the next token is not an int or is out of range
double nextDouble()	the next double	InputMismatchException if the next token is not a double
boolean nextBoolean()	the next boolean (true or false)	InputMismatchException if it is not a boolean
String next()	the next token as a String
String nextLine()	the rest of the current line as a String (can be the empty string right after another Scanner method)
boolean hasNext()	true if there is another item to read, false otherwise
void close()	nothing; closes the scanner

The data file teams.txt, one team per line (name, wins, average goals, qualified):

Lions 3 4.5 true
Hawks 1 2.0 false

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class Teams
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("teams.txt"));

        String name = input.next();
        int wins = input.nextInt();
        double avg = input.nextDouble();
        boolean qualified = input.nextBoolean();

        System.out.println(name + " won " + wins + " games");
        System.out.println("Average goals: " + avg);
        System.out.println("Qualified: " + qualified);
        System.out.println("Next team: " + input.next());

        input.close();
    }
}

Output:

Lions won 3 games
Average goals: 4.5
Qualified: true
Next team: Hawks

Notice that the line break after true does not matter to next(): it is just whitespace between tokens.

When a token does not match the method, the program stops with an InputMismatchException 4.6.A.6. The file laps.txt contains 8 5 abc 4:

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class Laps
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("laps.txt"));
        int total = 0;
        while (input.hasNext())
        {
            total += input.nextInt();
            System.out.println("Total so far: " + total);
        }
        input.close();
    }
}

Output:

Total so far: 8
Total so far: 13
Exception in thread "main" java.util.InputMismatchException

hasNext() was true (the token abc exists), but nextInt() cannot turn it into an int.

Background: keyboard input is outside the scope of the AP® Computer Science A course and exam 4.6.A.6. Also, nextLine handles whitespace differently from the other methods, so mixing nextLine with nextInt, next and the others on the same file sometimes needs extra code to adjust 4.6.A.7. Writing or analyzing code that mixes them is outside the scope of the exam 4.6.A.7. A safe rule: either read tokens (next, nextInt, …) or read whole lines (nextLine), not both.

4. Reading until the end with hasNext

A while loop can keep reading as long as the file still contains items, using hasNext as the loop condition 4.6.A.9. This is the standard file traversal:

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class SumScores
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("scores.txt"));
        int sum = 0;
        int count = 0;

        while (input.hasNext())
        {
            int s = input.nextInt();
            sum += s;
            count++;
        }
        input.close();

        System.out.println(count + " scores, sum " + sum);
        System.out.println("Average: " + (double) sum / count);
    }
}

Output:

6 scores, sum 97
Average: 16.166666666666668

The numbers were on three lines in scores.txt, but the loop does not care: it reads token after token until hasNext() returns false. Calling nextInt() again after that would throw a NoSuchElementException.

When you are finished with the file, close it with the close method from Scanner 4.6.A.10. Closing releases the file for other programs and makes clear the reading is over.

5. Reading lines and splitting them

Many data files store one record per line, with the values separated by commas. Read each whole line with nextLine() and break it into parts with the String method split 4.6.A.8: String[] split(String del) returns a String array where each element is a substring of the original, split around matches of del 4.6.A.8.

The data file roster.txt:

Ana,12,true
Ben,9,false
Cleo,15,true

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class Roster
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("roster.txt"));

        while (input.hasNext())
        {
            String line = input.nextLine();
            String[] parts = line.split(",");
            System.out.println(parts[0] + " has " + parts.length + " fields; points = " + parts[1]);
        }
        input.close();
    }
}

Output:

Ana has 3 fields; points = 12
Ben has 3 fields; points = 9
Cleo has 3 fields; points = 15

For the line "Ana,12,true", split(",") gives this array:

index	0	1	2
parts	“Ana”	“12”	“true”

Every element is a String, even "12". To do arithmetic with it, convert it with Integer.parseInt (topic 4.7).

String date = "2026 11 12";
String[] pieces = date.split(" ");
System.out.println(pieces.length);
System.out.println(pieces[1] + pieces[2]);

Output:

3
1112

pieces[1] + pieces[2] joins two strings, so the result is 1112, not 23.

Background: the del argument is a regular expression, a pattern language. Some characters such as . and * have special meanings in it. Code that uses those special properties is outside the scope of the AP® exam 4.6.A.8, so on the exam expect simple separators like ",", " " or ":".

1. Integer and Double objects

Each primitive type has a matching wrapper class whose objects hold one value of that type. For the AP® exam you need two: Integer (wraps an int) and Double (wraps a double). Both are part of the java.lang package 4.7.A.1, like String and Math, so no import is needed.

Integer objects are immutable: once an Integer object is created, its attributes cannot be changed 4.7.A.1. Double objects are immutable in the same way 4.7.A.1. There is no method like setValue.

Primitive type	Wrapper class	Example value
int	Integer	42
double	Double	3.75

Why bother? Some Java code only works with objects. The most important example is ArrayList (topic 4.8), which stores object references. A list of whole numbers must use Integer:

ArrayList<int> laps = new ArrayList<int>();

Compiler error:

error: unexpected type

2. Autoboxing

Autoboxing is the automatic conversion the Java compiler makes from a primitive type to its wrapper class: an int to an Integer, a double to a Double 4.7.A.2. The compiler applies it when a primitive value is assigned to a variable of the wrapper class, or passed as a parameter to a method that expects an object of that wrapper class 4.7.A.2.

public static void showBoxed(Integer box)
{
    System.out.println("Received the object " + box);
}

Integer goals = 3;          // assigned to an Integer variable: autoboxing
Double price = 4.99;        // assigned to a Double variable: autoboxing

int bonus = 7;
showBoxed(bonus);           // passed to an Integer parameter: autoboxing

System.out.println(goals + " " + price);

Output:

Received the object 7
3 4.99

The match must be exact in type: a double value cannot be boxed into an Integer.

Integer wrong = 4.5;

Compiler error:

error: incompatible types: double cannot be converted to Integer

3. Unboxing

Unboxing is the automatic conversion the Java compiler makes from a wrapper class to its primitive type: an Integer to an int, a Double to a double 4.7.A.3. The compiler applies it when a wrapper object is assigned to a variable of the primitive type, or passed as a parameter to a method that expects that primitive type 4.7.A.3.

public static double half(double value)
{
    return value / 2;
}

Integer stored = 25;
Double rate = 0.5;

int plain = stored;                   // assigned to an int variable: unboxing
System.out.println(plain + 5);

System.out.println(half(rate));       // passed to a double parameter: unboxing
System.out.println(stored * rate);    // arithmetic unboxes both

Output:

30
0.25
12.5

Watch out: a wrapper variable is a reference, so it can be null. Unboxing null fails at run time.

Integer missing = null;
int value = missing;
System.out.println(value);

Output:

Exception in thread "main" java.lang.NullPointerException: Cannot invoke "java.lang.Integer.intValue()" because "missing" is null

The program stops with a NullPointerException. (The exact wording after the colon depends on your Java version and settings; on the AP® exam you only need the exception name.)

4. Immutable in practice

Because Integer objects cannot change, code that looks like it changes one actually creates a new object. The variable gets a reference to the new object, and any other variable still refers to the old one.

Integer score = 10;
Integer saved = score;      // both refer to the same Integer object

score++;                    // unbox 10, add 1, box 11 into a NEW object

System.out.println(score);
System.out.println(saved);

Output:

11
10

Watch out: == on two wrapper objects compares references, not values. Compare with equals, or unbox to int first.

Integer a = 1000;
Integer b = 1000;
int x = a;                  // unboxing
int y = b;                  // unboxing
System.out.println(a.equals(b));
System.out.println(x == y);
System.out.println(a == b);

Output:

true
true
false

(The == result for small values such as 5 can be true, because Java reuses some small Integer objects. Never rely on it.)

5. parseInt and parseDouble

Data read from a file or split from a line arrives as String values. Two static methods in the Java Quick Reference convert them to numbers:

• static int parseInt(String s) in Integer returns the String argument as an int 4.7.A.4.
• static double parseDouble(String s) in Double returns the String argument as a double 4.7.A.5.

String line = "Ana,12,8.5";
String[] parts = line.split(",");

int points = Integer.parseInt(parts[1]);
double minutes = Double.parseDouble(parts[2]);

System.out.println(parts[1] + parts[1]);     // String + String: joins
System.out.println(points + points);         // int + int: adds
System.out.println(points / minutes);

Output:

1212
24
1.411764705882353

Watch out: the String must really look like a number of that type, or the program stops with a NumberFormatException.

System.out.println(Double.parseDouble("12"));
System.out.println(Integer.parseInt("12.0"));

Output:

12.0
Exception in thread "main" java.lang.NumberFormatException: For input string: "12.0"

parseDouble("12") works (a whole number is a valid double), but parseInt("12.0") fails.

1. Creating an ArrayList

An ArrayList object is mutable in size (it can grow and shrink) and it contains object references 4.8.A.1. The class is part of the java.util package, so an import statement must make it available 4.8.A.4. The constructor ArrayList() constructs an empty list 4.8.A.2.

Java allows the generic type ArrayList<E>, where the type parameter E is the type of the elements 4.8.A.3. With ArrayList<E>, the parameters and return types of the ArrayList methods are type E. Using ArrayList<E> is preferred over plain ArrayList, because it lets the compiler find errors that would otherwise only be found at run time 4.8.A.3.

import java.util.ArrayList;

public class Playlist
{
    public static void main(String[] args)
    {
        ArrayList<String> songs = new ArrayList<String>();
        System.out.println(songs.size());
        System.out.println(songs);
    }
}

Output:

0
[]

Printing an ArrayList shows its elements in square brackets, separated by commas.

With a type parameter, a wrong type is caught by the compiler:

ArrayList<String> songs = new ArrayList<String>();
songs.add(42);

Compiler error:

error: incompatible types: int cannot be converted to String

Background: without a type parameter, the same kind of mistake compiles and only fails when the program runs. This is why ArrayList<E> is preferred.

ArrayList songs = new ArrayList();
songs.add(42);
String first = (String) songs.get(0);
System.out.println(first);

Output:

Exception in thread "main" java.lang.ClassCastException: class java.lang.Integer cannot be cast to class java.lang.String (java.lang.Integer and java.lang.String are in module java.base of loader 'bootstrap')

Because the elements are object references, a list of numbers uses a wrapper class: ArrayList<Integer> or ArrayList<Double>. Autoboxing and unboxing (topic 4.7) convert for you.

2. size, add and get

These methods are in the Java Quick Reference 4.8.A.5:

• int size() returns the number of elements in the list.
• boolean add(E obj) appends obj to the end of the list and returns true.
• E get(int index) returns the element at position index.

ArrayList<Integer> laps = new ArrayList<Integer>();
laps.add(62);                          // autoboxing: int 62 becomes an Integer
laps.add(58);
boolean ok = laps.add(60);

System.out.println(ok);
System.out.println(laps.size());
System.out.println(laps.get(1));
int best = laps.get(1);                // unboxing
System.out.println(best + 1);
System.out.println(laps);

Output:

true
3
58
59
[62, 58, 60]

index	0	1	2
laps	62	58	60

3. add at an index: shifting right

void add(int index, E obj) inserts obj at position index, where 0 <= index <= size. The elements at position index and higher move to the right (1 is added to their indices), and 1 is added to the size 4.8.A.5.

ArrayList<String> queue = new ArrayList<String>();
queue.add("Ana");
queue.add("Ben");
queue.add("Cleo");

queue.add(1, "Dev");          // insert at index 1
System.out.println(queue);

queue.add(4, "Eli");          // index == size: same as appending
System.out.println(queue);
System.out.println(queue.size());

Output:

[Ana, Dev, Ben, Cleo]
[Ana, Dev, Ben, Cleo, Eli]
5

index	0	1	2	3	4
before	“Ana”	“Ben”	“Cleo”
after add(1, "Dev")	“Ana”	“Dev”	“Ben”	“Cleo”
after add(4, "Eli")	“Ana”	“Dev”	“Ben”	“Cleo”	“Eli”

“Ben” was at index 1 and is now at index 2: inserting changed its index.

4. set and remove

• E set(int index, E obj) replaces the element at position index with obj and returns the element formerly at that position 4.8.A.5. The size does not change.
• E remove(int index) removes the element at position index, moves the elements at index + 1 and higher to the left (1 is subtracted from their indices), subtracts 1 from the size, and returns the element formerly at that position 4.8.A.5.

ArrayList<String> queue = new ArrayList<String>();
queue.add("Ana");
queue.add("Dev");
queue.add("Ben");
queue.add("Cleo");

String old = queue.set(2, "Bea");
System.out.println(old + " was replaced: " + queue);

String gone = queue.remove(0);
System.out.println(gone + " left: " + queue);
System.out.println("Now first: " + queue.get(0) + ", size " + queue.size());

Output:

Ben was replaced: [Ana, Dev, Bea, Cleo]
Ana left: [Dev, Bea, Cleo]
Now first: Dev, size 3

index	0	1	2	3
before	“Ana”	“Dev”	“Ben”	“Cleo”
after set(2, "Bea")	“Ana”	“Dev”	“Bea”	“Cleo”
after remove(0)	“Dev”	“Bea”	“Cleo”

Watch out: with an ArrayList<Integer>, remove(1) uses the Quick Reference method remove(int index): it removes the element at index 1, not the value 1.

ArrayList<Integer> nums = new ArrayList<Integer>();
nums.add(1);
nums.add(5);
nums.add(9);
nums.remove(1);
System.out.println(nums);

Output:

[1, 9]

5. Valid indexes and IndexOutOfBoundsException

The indices of an ArrayList start at 0 and end at the number of elements minus 1 4.8.A.6, so get, set and remove accept 0 to size() - 1. (Only add(index, obj) also accepts size().) Any other index throws an IndexOutOfBoundsException when the code runs.

ArrayList<Double> times = new ArrayList<Double>();
times.add(9.8);
times.add(10.1);
times.add(9.9);

System.out.println(times.get(times.size() - 1));
System.out.println(times.get(times.size()));

Output:

9.9
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index 3 out of bounds for length 3

set cannot grow a list either. On an empty list, set(0, ...) fails because index 0 does not exist yet; use add.

6. Array or ArrayList?

Task	Array (int[] a)	ArrayList<Integer> list
Create	new int[5] or {3, 1, 4}	new ArrayList<Integer>() (starts empty)
Number of elements	a.length	list.size()
Read element i	a[i]	list.get(i)
Change element i	a[i] = 7;	list.set(i, 7);
Add at the end	not possible (fixed length)	list.add(7);
Insert or remove in the middle	write your own shift	list.add(i, 7); and list.remove(i);
Element types	primitives or references	references only
Bad index	ArrayIndexOutOfBoundsException	IndexOutOfBoundsException

1. Traversing an ArrayList

Traversing an ArrayList means using iteration (loops) or recursive statements to access all of the elements, or an ordered sequence of them 4.9.A.1. The loops look like array loops with two changes: size() instead of length, and get(i) instead of [i].

ArrayList<Integer> steps = new ArrayList<Integer>();
steps.add(5200);
steps.add(8100);
steps.add(7400);

for (int i = 0; i < steps.size(); i++)          // indexed for
{
    System.out.print(steps.get(i) + " ");
}
System.out.println();

int total = 0;
for (int s : steps)                             // enhanced for (unboxing to int)
{
    total += s;
}
System.out.println("Total: " + total);

int k = steps.size() - 1;                       // while, backward
while (k >= 0)
{
    System.out.print(steps.get(k) + " ");
    k--;
}
System.out.println();

Output:

5200 8100 7400 
Total: 20700
7400 8100 5200 

To change elements, use set in an indexed loop (assigning to the enhanced for loop variable changes nothing, as with arrays):

ArrayList<String> tags = new ArrayList<String>();
tags.add("java");
tags.add("loop");

for (int i = 0; i < tags.size(); i++)
{
    tags.set(i, "#" + tags.get(i));
}
System.out.println(tags);

Output:

[#java, #loop]

Preview: a traversal can also be recursive: a method handles one element and then calls itself for the rest. Recursion is covered in topic 4.16; here is a small example to trace.

public static void printFrom(ArrayList<String> list, int index)
{
    if (index < list.size())
    {
        System.out.print(list.get(index) + " ");
        printFrom(list, index + 1);
    }
}

ArrayList<String> stops = new ArrayList<String>();
stops.add("Park");
stops.add("Museum");
stops.add("Harbor");
printFrom(stops, 0);
System.out.println();

Output:

Park Museum Harbor 

2. Removing during a traversal: the skipping bug

Deleting elements during a traversal of an ArrayList requires special techniques to avoid skipping elements 4.9.A.2. The reason: remove(i) shifts every later element one place left, so the next element moves into index i. If the loop then does i++, that element is never checked.

Goal: remove every score below 50.

ArrayList<Integer> scores = new ArrayList<Integer>();
scores.add(72);
scores.add(40);
scores.add(35);
scores.add(90);

for (int i = 0; i < scores.size(); i++)
{
    if (scores.get(i) < 50)
    {
        scores.remove(i);
    }
}
System.out.println(scores);

Output:

[72, 35, 90]

35 survived. Trace it:

i	list at the start of the pass	get(i)	action
0	[72, 40, 35, 90]	72	keep
1	[72, 40, 35, 90]	40	remove(1); 35 shifts to index 1
2	[72, 35, 90]	90	keep (35, now at index 1, was skipped)

3. Two safe ways to remove

Technique 1: only move forward when nothing was removed.

ArrayList<Integer> scores = new ArrayList<Integer>();
scores.add(72);
scores.add(40);
scores.add(35);
scores.add(90);

int i = 0;
while (i < scores.size())
{
    if (scores.get(i) < 50)
    {
        scores.remove(i);       // the next element is now at index i: check it next
    }
    else
    {
        i++;
    }
}
System.out.println(scores);

Output:

[72, 90]

(The same idea in a for loop is to write i--; right after remove(i), so the i++ in the header cancels it out.)

Technique 2: traverse backward. Removing at index i only shifts elements after i, and a backward loop has already checked those.

ArrayList<Integer> scores = new ArrayList<Integer>();
scores.add(72);
scores.add(40);
scores.add(35);
scores.add(90);

for (int i = scores.size() - 1; i >= 0; i--)
{
    if (scores.get(i) < 50)
    {
        scores.remove(i);
    }
}
System.out.println(scores);

Output:

[72, 90]

i	list at the start of the pass	get(i)	action
3	[72, 40, 35, 90]	90	keep
2	[72, 40, 35, 90]	35	remove(2)
1	[72, 40, 90]	40	remove(1)
0	[72, 90]	72	keep

4. Adding during a traversal

Adding has the opposite shift. add(i, obj) pushes the current element to index i + 1, so a forward loop meets it again on the next pass. Goal: put a “warm up” before every “run”.

ArrayList<String> plan = new ArrayList<String>();
plan.add("run");
plan.add("rest");
plan.add("run");

for (int i = 0; i < plan.size(); i++)
{
    if (plan.get(i).equals("run"))
    {
        plan.add(i, "warm up");
        i++;                    // skip past the "run" that just moved to i + 1
    }
}
System.out.println(plan);

Output:

[warm up, run, rest, warm up, run]

Without the extra i++, the loop would find the same “run” at index i + 1, insert again, and keep going until the program runs out of memory.

5. IndexOutOfBoundsException

Attempting to access an index value outside the range 0 to size() - 1 results in an IndexOutOfBoundsException 4.9.A.3. Two ways it happens in traversals:

ArrayList<String> names = new ArrayList<String>();
names.add("Ada");
names.add("Ben");

for (int i = 0; i <= names.size(); i++)        // <= is one pass too many
{
    System.out.println(names.get(i));
}

Output:

Ada
Ben
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index 2 out of bounds for length 2

Saving the size in a variable before a loop that removes elements also fails, because the list gets shorter but the saved number does not:

ArrayList<Integer> nums = new ArrayList<Integer>();
nums.add(4);
nums.add(-1);
nums.add(6);

int n = nums.size();                            // 3, and it stays 3
for (int i = 0; i < n; i++)
{
    if (nums.get(i) < 0)
    {
        nums.remove(i);
    }
}
System.out.println(nums);

Output:

Exception in thread "main" java.lang.IndexOutOfBoundsException: Index 2 out of bounds for length 2

i	list at the start of the pass	get(i)	action
0	[4, -1, 6]	4	keep
1	[4, -1, 6]	-1	remove(1); the size is now 2
2	[4, 6]	get(2)	exception: n is still 3, but index 2 no longer exists

Write i < nums.size() in the condition so the loop sees the current size (and combine it with a technique from section 3).

6. ConcurrentModificationException

Changing the size of an ArrayList while traversing it with an enhanced for loop can result in a ConcurrentModificationException 4.9.A.4. So when you use an enhanced for loop on an ArrayList, you should not add or remove elements 4.9.A.4.

ArrayList<String> cart = new ArrayList<String>();
cart.add("apple");
cart.add("soda");
cart.add("bread");
cart.add("soda");

for (String item : cart)
{
    if (item.equals("soda"))
    {
        cart.remove(1);
    }
}
System.out.println(cart);

Output:

Exception in thread "main" java.util.ConcurrentModificationException

The code compiles; the exception happens when the loop tries to move to the next element after the list has changed size. Adding inside an enhanced for loop fails the same way. Use one of the indexed techniques from section 3 instead.

Loop type	Read elements	Replace with set	Remove or add
indexed for / while	yes	yes	yes, with a special technique
enhanced for	yes	no (no index)	no: ConcurrentModificationException

1. Minimum, maximum, sum and average

An ArrayList algorithm is a traversal with a purpose. For a minimum or maximum, keep the best value seen so far and compare every element with it 4.10.A.1. For a sum, add each element to a running total; for an average, divide that total by size() using double division 4.10.A.1.

ArrayList<Integer> temps = new ArrayList<Integer>();
temps.add(-4);
temps.add(-9);
temps.add(-1);
temps.add(-6);

int max = temps.get(0);
int min = temps.get(0);
int sum = 0;
for (int t : temps)
{
    if (t > max)
    {
        max = t;
    }
    if (t < min)
    {
        min = t;
    }
    sum += t;
}
double avg = (double) sum / temps.size();
System.out.println("max " + max + ", min " + min);
System.out.println("average " + avg);

Output:

max -1, min -9
average -5.0

Watch out: if max started at 0, it would stay 0 for this all-negative list. Seed with the first element. Also, sum / temps.size() with two int values drops the decimal part.

2. Property checks: at least one, all, and how many

Three algorithms ask a yes/no question about each element 4.10.A.1:

Question	Variable	When to stop early
Does at least one element have the property?	boolean	Return true at the first match
Do all elements have the property?	boolean	Return false at the first failure
How many elements have the property?	int counter	Never: visit every element

public static boolean anyOver(ArrayList<Integer> scores, int limit)
{
    for (int s : scores)
    {
        if (s > limit)
        {
            return true;
        }
    }
    return false;
}

public static boolean allPassing(ArrayList<Integer> scores)
{
    for (int s : scores)
    {
        if (s < 60)
        {
            return false;
        }
    }
    return true;
}

public static int countEven(ArrayList<Integer> scores)
{
    int count = 0;
    for (int s : scores)
    {
        if (s % 2 == 0)
        {
            count++;
        }
    }
    return count;
}

ArrayList<Integer> scores = new ArrayList<Integer>();
scores.add(72);
scores.add(95);
scores.add(58);
scores.add(80);
System.out.println(anyOver(scores, 90));
System.out.println(allPassing(scores));
System.out.println(countEven(scores));

Output:

true
false
3

Watch out: putting else return true; inside the loop of allPassing makes the method decide after looking at only one element.

3. Consecutive pairs and duplicates

To compare each element with its neighbor, visit all consecutive pairs: get(i) and get(i + 1). The loop must stop at size() - 1 so that i + 1 is still a valid index 4.10.A.1.

To find duplicates, compare every element with every element after it, using nested loops 4.10.A.1. Use equals for objects such as String.

ArrayList<String> playlist = new ArrayList<String>();
playlist.add("Rain");
playlist.add("Echo");
playlist.add("Rain");
playlist.add("Glow");

int changes = 0;
for (int i = 0; i < playlist.size() - 1; i++)
{
    if (playlist.get(i).compareTo(playlist.get(i + 1)) > 0)
    {
        changes++;
    }
}
System.out.println("Out-of-order pairs: " + changes);

boolean hasDuplicate = false;
for (int i = 0; i < playlist.size(); i++)
{
    for (int j = i + 1; j < playlist.size(); j++)
    {
        if (playlist.get(i).equals(playlist.get(j)))
        {
            hasDuplicate = true;
        }
    }
}
System.out.println("Duplicate: " + hasDuplicate);

Output:

Out-of-order pairs: 2
Duplicate: true

The pairs checked are (“Rain”, “Echo”), (“Echo”, “Rain”) and (“Rain”, “Glow”). The first and the last pair are out of alphabetical order. Watch out: with i < playlist.size() the last pass calls get(4) and the program stops with an IndexOutOfBoundsException.

4. Shift, rotate and reverse

A shift moves every element one place left or right. A rotate is a shift where the element that falls off one end comes back at the other end 4.10.A.1. With an ArrayList you can rotate by moving one element: remove(0) returns the first element, and add puts it at the end. You can also do it the array way, with set and a saved value.

To reverse, swap the first and last elements, then the second and second to last, and stop at the middle 4.10.A.1.

ArrayList<Integer> lane = new ArrayList<Integer>();
for (int k = 1; k <= 5; k++)
{
    lane.add(k * 10);
}

// rotate left by one, using set and a saved value
int first = lane.get(0);
for (int i = 0; i < lane.size() - 1; i++)
{
    lane.set(i, lane.get(i + 1));
}
lane.set(lane.size() - 1, first);
System.out.println(lane);

// rotate right by one, using remove and add
lane.add(0, lane.remove(lane.size() - 1));
System.out.println(lane);

// reverse: swap pairs from the outside in
for (int i = 0; i < lane.size() / 2; i++)
{
    int j = lane.size() - 1 - i;
    int temp = lane.get(i);
    lane.set(i, lane.get(j));
    lane.set(j, temp);
}
System.out.println(lane);

Output:

[20, 30, 40, 50, 10]
[10, 20, 30, 40, 50]
[50, 40, 30, 20, 10]

Watch out: if the reverse loop ran to i < lane.size(), it would swap every pair twice and the list would end up back in its original order.

5. Inserting and deleting elements

add(index, obj) inserts and moves later elements right; remove(index) deletes and moves later elements left 4.10.A.1. Both change size(), so a loop that inserts or deletes must control its index carefully.

Deleting. The safest pattern runs backward. The elements that shift are the ones already visited, so nothing is skipped.

ArrayList<Integer> stock = new ArrayList<Integer>();
stock.add(0);
stock.add(0);
stock.add(7);
stock.add(0);
stock.add(3);

// buggy: forward loop always does i++
ArrayList<Integer> copy = new ArrayList<Integer>(stock);
for (int i = 0; i < copy.size(); i++)
{
    if (copy.get(i) == 0)
    {
        copy.remove(i);
    }
}
System.out.println("forward: " + copy);

// correct: backward loop
for (int i = stock.size() - 1; i >= 0; i--)
{
    if (stock.get(i) == 0)
    {
        stock.remove(i);
    }
}
System.out.println("backward: " + stock);

Output:

forward: [0, 7, 3]
backward: [7, 3]

Trace of the buggy loop: at i = 0 the first 0 is removed and the second 0 slides into index 0, but i becomes 1, so that 0 is never checked.

Inserting. After inserting at index i, the element you were looking at is now at i + 1. Skip past the new element so the loop does not process it again (or insert forever).

ArrayList<String> line = new ArrayList<String>();
line.add("Ana");
line.add("VIP");
line.add("Ben");
line.add("VIP");

for (int i = 0; i < line.size(); i++)
{
    if (line.get(i).equals("VIP"))
    {
        line.add(i, "Guard");
        i++; // jump over the element we just inserted
    }
}
System.out.println(line);

Output:

[Ana, Guard, VIP, Ben, Guard, VIP]

Watch out: calling add or remove on a list inside an enhanced for loop over that same list throws a ConcurrentModificationException.

6. Traversing more than one collection at a time

Some algorithms need two String, array or ArrayList objects at once 4.10.A.2. Two common shapes:

• Parallel traversal: one index walks through both collections, so element i of one belongs with element i of the other.
• Nested traversal: for each element of the first collection, walk through the whole second collection.

String[] players = {"Kai", "Lena", "Omar"};
ArrayList<Integer> goals = new ArrayList<Integer>();
goals.add(3);
goals.add(5);
goals.add(2);

String best = players[0];
int bestGoals = goals.get(0);
for (int i = 1; i < players.length; i++)
{
    if (goals.get(i) > bestGoals)
    {
        bestGoals = goals.get(i);
        best = players[i];
    }
}
System.out.println(best + " scored " + bestGoals);

// count letters of a word that also appear in a second word
String a = "plane";
String b = "apple";
int shared = 0;
for (int i = 0; i < a.length(); i++)
{
    if (b.indexOf(a.substring(i, i + 1)) >= 0)
    {
        shared++;
    }
}
System.out.println("shared letters: " + shared);

Output:

Lena scored 5
shared letters: 4

In “plane”, the letters p, l, a and e appear in “apple”; n does not. Watch out: parallel traversal only works if both collections have the same length, or if the loop stops at the shorter one.

1. A 2D array is an array of arrays

A two-dimensional (2D) array stores related data in rows and columns, such as seats in a cinema or scores per player per round. Java stores it as an array of arrays: the outer array holds the rows, and each row is a 1D array 4.11.A.1. So creating and indexing a 2D array works much like a 1D array, with one extra pair of brackets 4.11.A.1.

Like a 1D array, a 2D array’s size is set when it is created and cannot change 4.11.A.1. It can store primitive data (int, double, boolean) or object references (String, or any class) 4.11.A.1.

int[][] seats = new int[2][3];        // 2 rows, 3 columns of int
String[][] board = new String[3][3];  // 3 rows, 3 columns of references
System.out.println(seats.length + " rows, " + seats[0].length + " columns");
System.out.println(board.length * board[0].length + " squares");

Output:

2 rows, 3 columns
9 squares

Picture seats like this:

	column 0	column 1	column 2
row 0	seats[0][0]	seats[0][1]	seats[0][2]
row 1	seats[1][0]	seats[1][1]	seats[1][2]

Scope note: every 2D array on the AP® exam is rectangular (every row has the same length). Arrays with rows of different lengths are outside the course 4.11.A.1.

2. Creating with new: default values

When you create a 2D array with the keyword new, every element starts at the default value for its type 4.11.A.2:

Element type	Default value
int	0
double	0.0
boolean	false
any reference type (String, a class)	null

int[][] counts = new int[2][2];
double[][] prices = new double[2][2];
boolean[][] booked = new boolean[2][2];
String[][] names = new String[2][2];
System.out.println(counts[1][1] + " " + prices[0][1] + " " + booked[1][0] + " " + names[0][0]);

Output:

0 0.0 false null

Watch out: names[0][0].length() would throw a NullPointerException, because the element holds null and not a String object.

3. Creating with an initializer list

An initializer list for a 2D array is a list of initializer lists: each inner list is one row, written like a 1D array 4.11.A.3. Java counts the rows and columns for you.

int[][] scores = { {12, 15, 9, 20},
                   {18, 11, 14, 16},
                   {10, 19, 13, 17} };
String[][] menu = { {"soup", "salad"},
                    {"pasta", "rice"} };
System.out.println(scores.length + " x " + scores[0].length);
System.out.println(menu[1][0]);

Output:

3 x 4
pasta

4. Reading and changing one element: [row][col]

Two indexes in square brackets reach one element: arr[row][col] 4.11.A.4. For the AP® exam, the first index is the row and the second index is the column 4.11.A.4. The same expression reads a value or, on the left of =, changes it.

int[][] scores = { {12, 15, 9, 20},
                   {18, 11, 14, 16},
                   {10, 19, 13, 17} };
System.out.println(scores[1][2]);   // row 1, column 2
scores[2][0] = scores[0][3] + 5;    // change row 2, column 0
scores[0][1]++;
System.out.println(scores[2][0] + " " + scores[0][1]);

Output:

14
25 16

The grid after the two changes:

	col 0	col 1	col 2	col 3
row 0	12	16	9	20
row 1	18	11	14	16
row 2	25	19	13	17

5. One row as a 1D array

Use the array name with a single pair of brackets, arr[r], to get row r as a 1D array 4.11.A.5. This is a reference to the real row, not a copy, so changes through it change the 2D array.

double[][] rain = { {2.5, 0.0, 1.0},
                    {4.0, 3.5, 0.5} };
double[] week2 = rain[1];          // the whole second row
System.out.println(week2.length);
week2[0] = 9.9;                    // changes rain[1][0] too
System.out.println(rain[1][0]);

Output:

3
9.9

Watch out: there is no single-bracket way to get a column. A column must be built with a loop over the rows.

6. Size, valid indexes and ArrayIndexOutOfBoundsException

For a 2D array named grid 4.11.A.6:

What you want	Expression	Valid index values
Number of rows	grid.length	rows 0 to grid.length - 1
Number of columns	grid[0].length (the length of any row)	columns 0 to grid[0].length - 1

Any index outside these ranges throws an ArrayIndexOutOfBoundsException when the program runs 4.11.A.6.

String[][] maze = new String[4][6];
System.out.println("rows: " + maze.length);
System.out.println("columns: " + maze[0].length);
System.out.println("last row index: " + (maze.length - 1));
maze[3][6] = "#";   // column 6 does not exist

Output:

rows: 4
columns: 6
last row index: 3
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 6 out of bounds for length 6

The message says “length 6” because the bad index was the column: each row has length 6, so the last column is 5.