---
title: "AP CSA FRQ 3: ArrayList Data Analysis Guide & Scoring"
description: "AP CSA FRQ 3 is the 5-point ArrayList data analysis question. Learn the scoring pattern, filter-and-calculate strategy, a worked example, and common errors."
canonical: "https://fiveable.me/ap-comp-sci-a/ap-computer-science-a-exam/ap-comp-sci-a-frq-3-data-analysis-with-arraylist/study-guide/ap-comp-sci-a-frq-3-data-analysis-with-arraylist"
type: "study-guide"
subject: "AP Computer Science A"
unit: "*AP Computer Science A Exam"
lastUpdated: "2026-06-12"
---

# AP CSA FRQ 3: ArrayList Data Analysis Guide & Scoring

## Summary

AP CSA FRQ 3 is the 5-point ArrayList data analysis question. Learn the scoring pattern, filter-and-calculate strategy, a worked example, and common errors.

## Guide

## Overview

AP CSA FRQ 3 is the Data Analysis with [ArrayList](/ap-comp-sci-a/unit-4/developing-algorithms-using-arraylists/study-guide/MKbteieYvLOpWIwfqiND "fv-autolink") question, worth 5 of the 25 points in the free-response section. You'll be given a scenario with one or more pre-written classes and asked to write a single method that uses, analyzes, and manipulates data stored in an `ArrayList`. The free-response section as a whole gives you 90 minutes for 4 questions and counts for 45% of your [AP Computer Science A](/ap-comp-sci-a "fv-autolink") exam score.

The typical FRQ 3 task: [traverse](/ap-comp-sci-a/key-terms/traverse "fv-autolink") an `ArrayList` of [objects](/ap-comp-sci-a/key-terms/object "fv-autolink"), filter elements based on one or more conditions, and calculate something (a count, sum, average, maximum, or minimum). You never have to build the `ArrayList` yourself. It already exists as an instance variable in the class you're given. Your job is to loop through it correctly, call methods on the objects inside, and return the right value.

One more thing worth knowing: this question now tests `ArrayList` exclusively. Plain [arrays](/ap-comp-sci-a/unit-4/array-creation-and-access/study-guide/umTe6NA38OqZOhMZjFWi "fv-autolink") were removed from FRQ 3, so every elements-access in your answer should use `ArrayList` methods like `get()` and `size()`, never bracket syntax.

## How AP CSA FRQ 3 Is Scored

FRQ 3 is worth 5 points, the smallest point total of the four FRQs (Question 1 and Question 2 are worth 7 each, and [FRQ 4 on 2D arrays](/ap-comp-sci-a/ap-computer-science-a-exam/ap-comp-sci-a-frq-4-2d-array/study-guide/ap-comp-sci-a-frq-4-2d-array) is worth 6). Based on how past ArrayList questions have been graded, the 5 points tend to map onto five distinct skills:

| Point | What typically earns it |
|---|---|
| Traversal | A loop that accesses every element of the `ArrayList` without going out of bounds, and actually accesses elements inside the loop |
| Method calls on elements | Calling at least one method on an object pulled from the list (like `item.getCost()`), not just on the list itself |
| Condition checking | Correct boolean logic for the filtering criteria, including the right operators for inclusive vs. exclusive bounds |
| Accumulating values | Declaring, initializing, and correctly updating tracking variables (sum, count, max, min) inside the loop |
| Algorithm | The whole solution works together: correct calculation, correct return type, correct final answer |

Treat this [table](/ap-comp-sci-a/unit-4/introduction-to-using-data-sets/study-guide/fq4I4p0XINBBV56xQfTx "fv-autolink") as a strategy map rather than the official rubric for any specific question, since each exam's scoring guidelines vary slightly. But the [pattern](/ap-comp-sci-a/unit-1/why-programming-why-java/study-guide/lVK6rmrBuug17i1Hna9z "fv-autolink") is remarkably consistent.

The [algorithm](/ap-comp-sci-a/key-terms/algorithm "fv-autolink") point is more forgiving than you'd expect. Graders evaluate whether your overall approach would work, so a sound algorithm with a minor syntax slip elsewhere can still earn it. That cuts both ways, though: a beautifully written loop that divides by `list.size()` when it should divide by a filtered count will lose the algorithm point even with flawless syntax.

## How to Approach FRQ 3, Step by Step

The logic in FRQ 3 is usually simple. The real test is whether you can execute clean `ArrayList` syntax under time pressure. Budget roughly 20 minutes for this question and follow a consistent process.

### Read the provided code first (about 5 minutes)

Before writing anything, inventory what you've been given. FRQ 3 usually provides a simple class with getter methods (something like `ItemInfo` with `getCost()` and `isAvailable()`) plus a second class containing an `ArrayList` of those objects. The method you write always lives in the second class.

Two things to check during this read:

1. Which methods exist, and what do they return? You can only call methods that appear in the provided code, and only the [public](/ap-comp-sci-a/key-terms/public "fv-autolink") ones. Inventing a method that doesn't exist costs points.
2. What exactly does the question ask you to return? An average and a sum look similar mid-loop but produce different final lines. Note whether [bounds](/ap-comp-sci-a/key-terms/bounds "fv-autolink") are inclusive ("between low and high, inclusive" means `>=` and `<=`) or exclusive.

### Write the solution (10-12 minutes)

FRQ 3 solutions are typically 10-15 lines of actual code. If you're writing much more than that, step back. You're probably overcomplicating it.

The single most important syntax rule: `ArrayList` access uses `get()`, not brackets. `arr[i]` works on arrays; `list.get(i)` works on an `ArrayList`. Mixing these up is the most common point-loser on this question, and graders are specifically watching for it.

Remember the two-step process for working with elements. When you call `list.get(i)`, you get back a [reference](/ap-comp-sci-a/key-terms/reference "fv-autolink") to an object. You then call methods on that object to read its data. So a condition check looks like `list.get(i).getCost() >= minPrice`, or you store the element first: `ItemInfo item = list.get(i);` then `item.getCost()`. An [enhanced for loop](/ap-comp-sci-a/key-terms/enhanced-for-loop "fv-autolink") (`for (ItemInfo item : inventory)`) handles the "get the element" step for you and is often the cleaner choice when you're only reading data.

Keep your tracking [variables](/ap-comp-sci-a/unit-1/expressions-and-assignment-statements/study-guide/01dr6uUPDAn3SjtK2Psr "fv-autolink") synchronized. If an element passes your filter, [update](/ap-comp-sci-a/unit-2/for-loops/study-guide/DJuLxKz6SiSAX2cEVmCt "fv-autolink") everything that depends on it in the same `if` block. Counting an item but forgetting to add its value to the sum (or vice versa) is one of the most common logic errors on this question.

### Verify (about 5 minutes)

Use your last few minutes to catch the classics: array brackets where `get()` belongs, an uninitialized [accumulator](/ap-comp-sci-a/key-terms/accumulator "fv-autolink") (`double sum;` with no `= 0.0;`), `&&` vs. `||` mix-ups, and off-by-one loop bounds. Most importantly, reread the prompt. Did they ask for an average or a sum? Should the [return type](/ap-comp-sci-a/key-terms/return-type "fv-autolink") be `double` or `int`? These last-minute catches routinely save multiple rubric points.

If you're still working on FRQ 3 after 25 minutes, move on. A partially complete FRQ 4 earns more points than a perfected FRQ 3.

## Worked Example: The Filter-and-Average Pattern

Here's an editorial example of the most common FRQ 3 structure. Suppose you're given an `ItemInfo` class with public methods `isAvailable()` (returns `boolean`) and `getCost()` (returns `double`), and asked to write a method that returns the average cost of available items priced between `low` and `high`, inclusive. A solution following the pattern:

```java
public double averageInRange(double low, double high)
{
    double sum = 0.0;
    int count = 0;
    for (ItemInfo item : inventory)
    {
        if (item.isAvailable() && item.getCost() >= low
                               && item.getCost() <= high)
        {
            sum += item.getCost();
            count++;
        }
    }
    return sum / count;
}
```

Walk through how this maps to the scoring pattern:

- The enhanced for loop accesses every element ([traversal](/ap-comp-sci-a/key-terms/traversal "fv-autolink") point).
- `item.isAvailable()` and `item.getCost()` are method calls on elements from the list (method-call point).
- The compound condition uses `&&` because both criteria must be true, and `>=` / `<=` because the bounds are inclusive (condition point).
- `sum` and `count` are both initialized before the loop and updated together inside the same `if` block (accumulation point).
- The return divides by `count`, the number of items that passed the filter, not by `inventory.size()` (algorithm point).

That last distinction is the trap baked into nearly every average-style FRQ 3. Dividing by the list's full size when only some items qualify gives the wrong answer and loses the algorithm point.

## FRQ 3 Patterns Worth Recognizing

A small set of patterns covers most FRQ 3 questions, so recognizing them on sight is the fastest way to earn these 5 points.

The "filter by multiple criteria" pattern is the most common. The first criterion is usually a [boolean](/ap-comp-sci-a/unit-1/variables-and-primitive-data-types/study-guide/rezA6f3hJz84TKaY5Jjl "fv-autolink") method like `isAvailable()` or `isActive()`. The second compares a numeric value against bounds passed as [parameters](/ap-comp-sci-a/unit-4/recursion/study-guide/p4D3YegZCLwQ3KJVvsd4 "fv-autolink"). Both conditions must be true, so you almost always want `&&`. Be careful here: in everyday English we say "items that are available or under $50" when we logically mean both. Test writers know this and count on the `||` mistake.

The "accumulate and calculate" pattern pairs with it. You're rarely asked to just count things. More often you maintain a sum and a count together to compute an average, or track a running max or min. For max/min problems, initialize your tracker to the first qualifying value or use a sentinel carefully. Initializing `max` to 0 fails if all values are negative.

The method signature itself is predictable: one or two parameters defining the filter criteria, returning a calculated value. You're analyzing the data, not modifying it. If your solution calls `remove()` or `set()`, reread the prompt, because FRQ 3 almost never asks you to change the list.

## Common Mistakes

- **Using array brackets on an ArrayList.** Writing `inventory[i]` instead of `inventory.get(i)` is the number-one syntax error on this question. Drill `get()` until it's automatic.
- **Calling methods on the list instead of its elements.** `inventory.size()` doesn't demonstrate that you can work with the objects inside. Pull an element out first, then call its methods.
- **Dividing by the wrong count.** For a filtered average, divide by the number of items that passed your conditions, not `list.size()`. This single error costs the algorithm point.
- **Uninitialized accumulators.** `double sum;` without `= 0.0;` won't compile in this context. Always initialize sum to 0 and count to 0 before the loop.
- **Wrong boundary operators.** "Inclusive" means `>=` and `<=`. Using strict `>` and `<` silently excludes the endpoints and loses the condition point.
- **Inventing methods that don't exist.** Only call methods shown in the provided classes. Spend your first read confirming exactly what's available.

If you're stuck mid-exam, write the loop, access elements with `get()` or an enhanced for loop, call one method on an element, and attempt some calculation. Even imperfect logic can earn 3 of the 5 points on the mechanical rows, and that partial credit adds up across the section.

## Practice and Next Steps

The fastest way to make `ArrayList` syntax automatic is [repetition](/ap-comp-sci-a/unit-2/algorithms-with-selection-and-repetition/study-guide/42crNSZyW8IRsntk9IHe "fv-autolink") under realistic conditions. Start with [FRQ practice with instant scoring](/ap-comp-sci-a/frq-practice) to get immediate feedback on traversal, filtering, and accumulation, then browse the full [FRQ question bank](/ap-comp-sci-a/frqs) to see how many variations of the filter-and-calculate pattern actually exist. Working through [past exam questions](/ap-comp-sci-a/past-exams) shows you exactly how College Board phrases bounds, conditions, and return requirements.

Since FRQ 3 and FRQ 4 share the traverse-and-analyze structure, review the [FRQ 4 2D Array guide](/ap-comp-sci-a/ap-computer-science-a-exam/ap-comp-sci-a-frq-4-2d-array/study-guide/ap-comp-sci-a-frq-4-2d-array) next so you can move between list and grid traversal without missing a beat. When you're ready to put it all together, take a [full-length practice exam](/ap-comp-sci-a/practice-exam) with the real 90-minute FRQ timing, and use the rest of the [AP Computer Science A exam prep collection](/ap-comp-sci-a/ap-computer-science-a-exam) to round out the other three FRQ types and the multiple-choice section.

## FAQs

### How many points is AP CSA FRQ 3 worth?

FRQ 3, the Data Analysis with ArrayList question, is worth 5 of the 25 points in the free-response section. It's the smallest FRQ on the exam (FRQ 1 and FRQ 2 are 7 points each, FRQ 4 is 6), which makes it one of the quickest point opportunities on the test. The whole free-response section runs 90 minutes and counts for 45% of your AP CSA score.

### What does AP CSA FRQ 3 ask you to do?

FRQ 3 gives you a scenario with pre-written classes and asks you to write one method that uses, analyzes, and manipulates data in an ArrayList. The typical task is traverse-filter-calculate: loop through the list, check conditions on the objects inside, and return a count, sum, average, max, or min. You never create or modify the ArrayList, just analyze it.

### Do you use array syntax or ArrayList syntax on FRQ 3?

ArrayList syntax only. Plain arrays were removed from this question, so element access must use list.get(i), never brackets like arr[i]. Using array bracket syntax on an ArrayList is the single most common point-loser on FRQ 3, so make get() and size() automatic before exam day with [timed FRQ practice](/ap-comp-sci-a/frq-practice).

### How long should you spend on FRQ 3?

About 20 minutes is a reasonable budget: roughly 5 minutes reading the provided classes, 10-12 minutes writing your method, and 5 minutes verifying. You have 90 minutes total for all 4 FRQs. If you're past 25 minutes on FRQ 3, move on, since a partially complete FRQ 4 earns more points than a perfected FRQ 3.

### Why can't you divide by list.size() when calculating an average on FRQ 3?

Because most FRQ 3 averages only include items that pass a filter, so you have to divide by the count of qualifying items, not the full list size. Dividing by list.size() gives the wrong answer and costs you the algorithm point. Keep a separate count variable and update it in the same if block where you add to your sum.

## Structured Data

```json
{"@context":"https://schema.org","@type":"FAQPage","inLanguage":"en","mainEntity":[{"@type":"Question","@id":"https://fiveable.me/ap-comp-sci-a/ap-computer-science-a-exam/ap-comp-sci-a-frq-3-data-analysis-with-arraylist/study-guide/ap-comp-sci-a-frq-3-data-analysis-with-arraylist#how-many-points-is-ap-csa-frq-3-worth","name":"How many points is AP CSA FRQ 3 worth?","acceptedAnswer":{"@type":"Answer","text":"FRQ 3, the Data Analysis with ArrayList question, is worth 5 of the 25 points in the free-response section. It's the smallest FRQ on the exam (FRQ 1 and FRQ 2 are 7 points each, FRQ 4 is 6), which makes it one of the quickest point opportunities on the test. The whole free-response section runs 90 minutes and counts for 45% of your AP CSA score."}},{"@type":"Question","@id":"https://fiveable.me/ap-comp-sci-a/ap-computer-science-a-exam/ap-comp-sci-a-frq-3-data-analysis-with-arraylist/study-guide/ap-comp-sci-a-frq-3-data-analysis-with-arraylist#what-does-ap-csa-frq-3-ask-you-to-do","name":"What does AP CSA FRQ 3 ask you to do?","acceptedAnswer":{"@type":"Answer","text":"FRQ 3 gives you a scenario with pre-written classes and asks you to write one method that uses, analyzes, and manipulates data in an ArrayList. The typical task is traverse-filter-calculate: loop through the list, check conditions on the objects inside, and return a count, sum, average, max, or min. You never create or modify the ArrayList, just analyze it."}},{"@type":"Question","@id":"https://fiveable.me/ap-comp-sci-a/ap-computer-science-a-exam/ap-comp-sci-a-frq-3-data-analysis-with-arraylist/study-guide/ap-comp-sci-a-frq-3-data-analysis-with-arraylist#do-you-use-array-syntax-or-arraylist-syntax-on-frq-3","name":"Do you use array syntax or ArrayList syntax on FRQ 3?","acceptedAnswer":{"@type":"Answer","text":"ArrayList syntax only. Plain arrays were removed from this question, so element access must use list.get(i), never brackets like arr[i]. Using array bracket syntax on an ArrayList is the single most common point-loser on FRQ 3, so make get() and size() automatic before exam day with <a href=\"/ap-comp-sci-a/frq-practice\">timed FRQ practice</a>."}},{"@type":"Question","@id":"https://fiveable.me/ap-comp-sci-a/ap-computer-science-a-exam/ap-comp-sci-a-frq-3-data-analysis-with-arraylist/study-guide/ap-comp-sci-a-frq-3-data-analysis-with-arraylist#how-long-should-you-spend-on-frq-3","name":"How long should you spend on FRQ 3?","acceptedAnswer":{"@type":"Answer","text":"About 20 minutes is a reasonable budget: roughly 5 minutes reading the provided classes, 10-12 minutes writing your method, and 5 minutes verifying. You have 90 minutes total for all 4 FRQs. If you're past 25 minutes on FRQ 3, move on, since a partially complete FRQ 4 earns more points than a perfected FRQ 3."}},{"@type":"Question","@id":"https://fiveable.me/ap-comp-sci-a/ap-computer-science-a-exam/ap-comp-sci-a-frq-3-data-analysis-with-arraylist/study-guide/ap-comp-sci-a-frq-3-data-analysis-with-arraylist#why-cant-you-divide-by-listsize-when-calculating-an-average-on-frq-3","name":"Why can't you divide by list.size() when calculating an average on FRQ 3?","acceptedAnswer":{"@type":"Answer","text":"Because most FRQ 3 averages only include items that pass a filter, so you have to divide by the count of qualifying items, not the full list size. Dividing by list.size() gives the wrong answer and costs you the algorithm point. Keep a separate count variable and update it in the same if block where you add to your sum."}}]}
```