AP CSA Unit 4 Arrays: Working with Collections of Data in Java

Ethical and Social Implications

Arrays sound purely technical—“just a way to store multiple values.” But in real programs, arrays often hold data about people (scores, locations, purchases, search queries, medical measurements). The way you collect, store, process, and share that data can affect privacy, fairness, and trust.

What this means in an arrays unit

An array groups many values under one variable name. That convenience has a social side effect: it becomes easy to scale up from “a few items” to “a dataset of thousands or millions,” and the consequences of mistakes scale too.

For example, if you store student test scores in an int[], then:

• A bug that shifts indices (an “off-by-one” error) could attach the wrong score to the wrong student.
• A program that computes an “average” might hide important differences between groups.
• If the array is printed, logged, or transmitted, you may leak sensitive information.

Privacy and data minimization

A good ethical habit is data minimization: collect/store only what you actually need.

• If you only need the class average, you might not need to permanently store every individual score.
• If you must store them, avoid storing extra identifiers in the same structure unless necessary.

In Java, arrays don’t provide privacy by themselves. If your code has a reference to an array, it can read or modify its elements. That’s why you’ll often see practices like:

• limiting the scope of the array variable (keep it private in a class)
• returning copies of arrays instead of the original (to prevent outside code from mutating internal state)

Fairness and bias when using datasets

When arrays are used to process datasets, the algorithm you write can unintentionally amplify bias.

• If your dataset under-represents a group, an algorithm that “learns” from it (or even just computes summary stats) may produce misleading conclusions.
• If you remove “outliers” without thinking, you may remove valid extreme cases that matter (e.g., accessibility needs).

Even in AP CSA-style problems (like “find the max” or “count values above threshold”), it’s good to ask: What does this computation imply if these numbers represent people?

Transparency and interpretability

Arrays often feed into decisions: rankings, eligibility, alerts.

• If you sort or filter, be clear about the rule.
• If you compute a score, document what it means.

A practical coding takeaway: use meaningful variable names and comments, and avoid “magic numbers” (like a hard-coded cutoff of 72) without explanation.

Exam Focus

• Typical question patterns:
  • Identify what an array-based computation is doing and what it outputs.
  • Reason about the effects of changing a condition in a loop (e.g., >= vs >).
  • Interpret an algorithm’s result in context (especially when values represent measurements).
• Common mistakes:
  • Treating index as if it were the data value (confusing “position” with “meaning”).
  • Ignoring edge cases that affect real people (empty arrays, missing values).
  • Overlooking that printing/logging arrays of personal data is still “sharing data.”

Introduction to Using Data Sets

A data set is a collection of related data values. In AP CSA, you often model a dataset using an array (fixed size) or an ArrayList (resizable). In this section, the core idea is: you rarely process one value at a time in isolation. You process many values with patterns—counting, searching, summarizing, and transforming.

Why arrays are a natural fit for datasets

Arrays give you:

• Grouping: one variable can represent many values.
• Indexing: you can access the “i-th” element quickly.
• Iteration: loops can process each element systematically.

That’s basically what data processing is: repeating the same operation across many records.

Thinking in “records” vs “features”

Sometimes an array represents:

• many measurements of the same thing (e.g., temperatures over time)
• many items in a category (e.g., inventory counts)

In more complex programs, you often use arrays of objects (e.g., Student[]) where each object holds multiple fields. That’s closer to a real dataset table (rows = students, columns = attributes).

Data quality issues you still face with arrays

Even in simple integer arrays, the same real-world data issues appear:

• Missing data: You may use a sentinel value (like -1) to mean “unknown.” This is risky if -1 could also be a valid value. A better approach is often an additional boolean flag or using objects that can represent “missing.”
• Outliers: A single extreme number can distort an average.
• Measurement units: An array of numbers is meaningless unless you know what each number represents.

Example: dataset summary (concept first)

A common dataset task is to compute summary statistics:

• total (sum)
• count
• average (requires sum and count)
• min/max

The important reasoning pattern: you keep “running” information in variables as you traverse the array.

public class DataSummary {
    public static double average(int[] values) {
        if (values.length == 0) {
            return 0.0; // decision: could also throw an exception
        }

        int sum = 0;
        for (int v : values) {
            sum += v;
        }
        return (double) sum / values.length;
    }
}

Notice two important ideas:

1. Empty dataset handling matters—division by 0 is an error.
2. Casting to double before division avoids integer division.

Exam Focus

• Typical question patterns:
  • Predict the result of a loop that computes a summary (sum, count, max).
  • Identify which variables must be initialized before traversing the dataset.
  • Determine what happens with edge cases (empty array, all negatives, etc.).
• Common mistakes:
  • Forgetting that int / int performs integer division in Java.
  • Not handling values.length == 0 when computing an average.
  • Initializing min/max incorrectly (e.g., starting max at 0 when values can be negative).

Array Creation and Access

An array in Java is an object that stores a fixed number of values of the same type. “Fixed number” is the key constraint: once created, an array’s length cannot change.

Why arrays matter

Arrays are one of the first “real” data structures you learn because they force you to think about:

• managing many values with a loop
• careful indexing
• algorithmic patterns (searching, counting, shifting)

They also show up all over AP CSA free-response questions, where you’ll be asked to write or complete methods that manipulate arrays.

Declaring vs creating an array

In Java, you typically do two steps:

1. Declare a variable that can refer to an array.
2. Create the array object with new.

int[] scores;           // declaration (scores is currently not pointing to an array)
scores = new int[5];    // creation (an array of 5 ints)

You can combine them:

int[] scores = new int[5];

When you create new int[5], Java fills the array with default values:

• 0 for int
• 0.0 for double
• false for boolean
• null for object references (like String)

Initializer lists

If you already know the values, you can use an initializer list:

int[] scores = {90, 82, 95, 88};
String[] names = {"Ana", "Bo", "Cy"};

This also sets the length automatically.

Accessing and modifying elements

You access an array element using bracket notation with an index:

• first element index is 0
• last element index is length - 1

int[] scores = {90, 82, 95, 88};
int first = scores[0];      // 90
scores[1] = 85;             // change 82 to 85
int last = scores[scores.length - 1]; // 88

The .length field

Arrays have a public length field (not a method):

int n = scores.length;

This is different from String.length().

What goes wrong: index out of bounds

If you try scores[4] in an array of length 4, Java throws an ArrayIndexOutOfBoundsException.

This is one of the most common bugs in array problems, and it almost always comes from incorrect loop bounds.

Arrays of objects (important AP CSA idea)

Arrays can hold references to objects:

String[] words = new String[3];
words[0] = "hi";
words[1] = null;
words[2] = "bye";

Here, words[1] being null means “no object is referenced there.” If you call a method on null, you get a NullPointerException.

Exam Focus

• Typical question patterns:
  • Determine the value of arr.length and valid index range.
  • Predict the result of code that assigns and reads arr[i].
  • Identify exceptions caused by invalid indices or null elements in object arrays.
• Common mistakes:
  • Using i <= arr.length instead of i < arr.length.
  • Confusing .length (arrays) with .length() (Strings).
  • Forgetting that object arrays may contain null until you assign actual objects.

Traversing Arrays

Traversing an array means visiting its elements—usually in order—to read values, compute something, or update elements. Traversal is the bridge between “I can store many values” and “I can do something useful with them.”

Index-based traversal

The most flexible traversal uses a for loop with an index variable:

for (int i = 0; i < arr.length; i++) {
    // use arr[i]
}

This matters because you can:

• access neighbors (arr[i-1], arr[i+1]) when safe
• update elements (arr[i] = ...)
• traverse only part of the array (e.g., start at 1)

Enhanced for loop (for-each)

Java also has the enhanced for loop:

for (int value : arr) {
    // use value (a copy of the element for primitives)
}

This is great for reading values, but it’s limited:

• You don’t have the index.
• For primitive arrays, assigning to value does not change the array.

Example misconception:

for (int value : arr) {
    value = value + 1; // does NOT change arr
}

To modify the array, use an index-based loop.

Common traversal patterns

Traversal is usually paired with a specific goal:

1) Accumulation (sum, product, concatenation)

You keep a running result variable.

int sum = 0;
for (int v : arr) {
    sum += v;
}

2) Counting based on a condition

You increment a counter when something matches.

int countEven = 0;
for (int v : arr) {
    if (v % 2 == 0) {
        countEven++;
    }
}

3) Finding a maximum/minimum

You track the “best so far.” The safest general initialization is to start from the first element (if the array is non-empty).

public static int max(int[] arr) {
    if (arr.length == 0) {
        throw new IllegalArgumentException("empty array");
    }
    int best = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] > best) {
            best = arr[i];
        }
    }
    return best;
}

4) Searching

You look for a target value and either return a boolean, a count, or an index.

public static boolean contains(String[] arr, String target) {
    for (String s : arr) {
        if (s != null && s.equals(target)) {
            return true;
        }
    }
    return false;
}

Notice the s != null check—important with object arrays.

Traversal order and why it matters

Most traversals go left-to-right, but sometimes direction matters:

• When shifting elements right, you often traverse from right-to-left to avoid overwriting values you still need.
• When removing items by shifting left, you must be careful not to skip elements.

Exam Focus

• Typical question patterns:
  • Trace a loop and determine final values of variables or array elements.
  • Choose whether an enhanced for loop is appropriate or whether you need indices.
  • Identify the effect of traversal direction in an in-place update.
• Common mistakes:
  • Attempting to modify a primitive array using the enhanced for loop.
  • Off-by-one loop bounds (missing last element or going out of bounds).
  • Calling .equals on a possibly null reference (use s != null && s.equals(...)).

Developing Algorithms Using Arrays

Once you can traverse arrays, you can build algorithms—step-by-step procedures that solve problems on collections of data. In AP CSA, many array algorithms are about pattern recognition: you see a problem statement and match it to a known loop pattern (counting, searching, comparing neighbors, etc.).

Why algorithm design with arrays is a big deal

Arrays are simple enough that you can focus on the algorithm itself:

• What information must you track?
• Do you need to look at pairs of elements?
• Are you transforming data in place or producing a result?

These skills transfer directly to more advanced structures (ArrayList, 2D arrays) and to free-response questions.

Algorithm pattern: compute a derived array (map/transform)

Sometimes you create a new array where each element is a function of the original.

Conceptually:

• input array stays unchanged
• output array has same length

public static int[] doubled(int[] arr) {
    int[] out = new int[arr.length];
    for (int i = 0; i < arr.length; i++) {
        out[i] = 2 * arr[i];
    }
    return out;
}

Common pitfall: forgetting to allocate out before assigning out[i].

Algorithm pattern: filter/count (selection)

Arrays have fixed length, so “filtering” often means either:

• counting items that match
• creating a new array of the exact needed size (usually a two-pass approach)

Two-pass approach (teach the idea):

1. count how many match
2. create an array of that size
3. fill it

public static int[] positives(int[] arr) {
    int count = 0;
    for (int v : arr) {
        if (v > 0) count++;
    }

    int[] out = new int[count];
    int j = 0;
    for (int v : arr) {
        if (v > 0) {
            out[j] = v;
            j++;
        }
    }
    return out;
}

This shows a realistic constraint of arrays: because the size is fixed, you often need to know the size ahead of time.

Algorithm pattern: swap and reverse

Reversing is a classic in-place algorithm. The main idea is to swap symmetric elements until you reach the middle.

public static void reverse(int[] arr) {
    for (int i = 0; i < arr.length / 2; i++) {
        int j = arr.length - 1 - i;
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

What can go wrong:

• Using the wrong loop bound (going all the way to arr.length will swap back).
• Miscomputing j.

Algorithm pattern: shifting elements (insertion/removal style)

You’ll sometimes need to make space or close a gap.

Shift right (to insert at index k): traverse from right to left.

public static void shiftRight(int[] arr, int k) {
    for (int i = arr.length - 1; i > k; i--) {
        arr[i] = arr[i - 1];
    }
    // arr[k] is now duplicated; caller can assign arr[k] to the inserted value
}

Shift left (to remove at index k): traverse from left to right.

public static void shiftLeft(int[] arr, int k) {
    for (int i = k; i < arr.length - 1; i++) {
        arr[i] = arr[i + 1];
    }
    // last element is now duplicated; caller decides what “unused” means
}

The key idea: traversal direction prevents overwriting values you still need.

Algorithm pattern: comparing neighbors (adjacent pairs)

Some problems depend on relationships between consecutive elements (increasing sequences, duplicates, local peaks).

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

Common pitfall: starting at i = 0 would require checking arr[-1], which is invalid.

Time cost (conceptual, not heavy math)

AP CSA expects you to reason informally about efficiency. With arrays:

• A single traversal is proportional to the number of elements.
• Nested loops over the array can be much slower for large datasets.

Even if you don’t compute formal Big-O on the exam, it’s useful to recognize when you’re doing “one pass” vs “many passes.”

Exam Focus

• Typical question patterns:
  • Write or complete a method that computes a value (sum/average/max) or modifies an array (reverse, shift, replace).
  • Determine the output of an algorithm after it runs on a given array.
  • Identify correct loop bounds for neighbor comparisons (i starting at 1, ending at length - 1).
• Common mistakes:
  • Overwriting values during shifting because you traverse in the wrong direction.
  • Incorrect initialization for max/min (especially with negatives).
  • Forgetting to handle special cases: empty array, length 1, null elements in object arrays.

Using Text Files

Arrays are often used with data that comes from outside the program—like a text file containing numbers, names, or log entries. Reading text files lets you turn “static code examples” into realistic datasets.

Important AP CSA note

Basic file I/O is standard Java, but it is not part of the AP Computer Science A Java Quick Reference. That means:

• You may use file reading in class projects.
• It’s generally not required for the AP exam itself.

Still, understanding the workflow helps you connect arrays to real datasets.

The core idea: two steps

To use a text file as a dataset, you typically:

1. Parse text into values (e.g., int, double, String).
2. Store those values in a structure you can process (often an ArrayList while reading, then possibly convert to an array).

Why not read directly into an array? Because arrays need a fixed length, but when you open a file you often don’t know how many lines it contains.

Common file formats you can handle

In introductory Java, you’ll most often see:

• one value per line (easy to read)
• comma-separated values (CSV) (a common real-world format)

Reading a file line-by-line with Scanner

One approachable way is java.util.Scanner with java.io.File. You read tokens or lines and build a list.

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

public class FileToArrayExample {
    public static int[] readInts(String filename) throws FileNotFoundException {
        Scanner sc = new Scanner(new File(filename));
        ArrayList<Integer> temp = new ArrayList<>();

        while (sc.hasNextInt()) {
            temp.add(sc.nextInt());
        }
        sc.close();

        int[] arr = new int[temp.size()];
        for (int i = 0; i < temp.size(); i++) {
            arr[i] = temp.get(i);
        }
        return arr;
    }
}

What’s happening conceptually:

• temp can grow as needed while you read.
• After reading, you know the final size, so you create int[] arr.
• You copy values into the array for fast indexed processing.

Parsing CSV-style lines

If a file has lines like:

Ana,90
Bo,82
Cy,95

You might split each line:

String line = sc.nextLine();
String[] parts = line.split(",");
String name = parts[0];
int score = Integer.parseInt(parts[1]);

Common pitfalls:

• Extra spaces: you may need trim().
• Missing fields: parts.length might be smaller than expected.

Linking file input to array algorithms

Once the file is in an array, everything you learned earlier applies:

• traverse to compute averages
• search for a name
• find max/min
• count values meeting a condition

That’s the bigger picture: file input produces the dataset; arrays/loops analyze it.

Exam Focus

• Typical question patterns (classroom/lab-style more than AP exam):
  • Read values from a file into a resizable structure, then process them.
  • Parse and validate text data before storing it.
  • Convert an ArrayList<Integer> to an int[] for indexed algorithms.
• Common mistakes:
  • Assuming the file has a known number of lines and creating an array too early.
  • Not closing the Scanner (resource leak) or not handling FileNotFoundException.
  • Failing to validate parsed data (NumberFormatException, missing CSV fields).