AP CSA Exam Guide: What to Expect and What to Practice

If AP CSA feels huge, start with the exam, not the course

AP Computer Science A can feel endless when it turns into one long stream of Java topics.

That is when students usually start doing things that feel productive but do not help much:

• rereading notes on syntax
• watching review videos instead of touching code
• treating every missed question like a random accident

The exam is not asking for all of Java. It is asking whether you can read code, trace code, and write short clean pieces of code under time.

A fast example of what AP CSA is really testing

Look at this:

int total = 0;
for (int i = 1; i <= 4; i++) {
    total += i;
}
System.out.println(total);

This is not a “hard Java” problem. It is a tracing problem.

If you can track:

• where the loop starts
• when it stops
• what changes each pass

you get the answer fast.

That is AP CSA in miniature.

The 2026 AP CSA exam at a glance

The 2026 AP Computer Science A exam is:

• fully digital in Bluebook
• Friday, May 15, 2026
• 3 hours total

It has two sections.

Section I: Multiple Choice

• 42 questions
• 1 hour 30 minutes
• 55% of the exam score

The multiple-choice section mostly asks you to:

• predict output
• determine which code segment works
• spot a bug or bad assumption
• describe what a method or loop is doing

Section II: Free Response

• 4 questions
• 1 hour 30 minutes
• 45% of the exam score

The four FRQs have stable shapes:

1. Methods and Control Structures
2. Class Design
3. Data Analysis with ArrayList
4. 2D Array

You still do not know the exact prompt, but you usually know the kind of move you will need to make.

The course changed, and some older AP CSA advice is now stale

A lot of older AP CSA resources still talk about a 10-unit course and may spend real time on inheritance. That was the old setup.

For the current public AP CSA framework, College Board now groups the course into 4 units:

• Unit 1: Using Objects and Methods — 15% to 25%
• Unit 2: Selection and Iteration — 25% to 35%
• Unit 3: Class Creation — 10% to 18%
• Unit 4: Data Collections — 30% to 40%

The practical takeaway:

• loops and conditionals matter a lot
• arrays, ArrayList, and 2D arrays matter a lot
• class-writing still matters, but not as much as students often assume

And if your prep source is leaning hard on inheritance, it is not aligned to the current exam.

What AP CSA is really rewarding

It feels like a syntax test when you are rattled. It is really a pattern-recognition test built out of Java.

Across both sections, the exam keeps rewarding the same habits:

• trace one line at a time instead of guessing from the vibe
• pay attention to the method contract
• separate return values from side effects
• keep indexes, bounds, and loop direction under control
• use the right traversal for the data structure in front of you

If you lose control of the state, AP CSA gets noisy fast. If you can keep state organized, the exam gets much calmer.

Where the score usually moves fastest

Because the current public weighting is uneven, your study time should be uneven too.

Unit 2: Selection and Iteration

This is one of the heaviest parts of the course. You need to be comfortable with:

• if, if-else, and chained conditionals
• for and while loops
• loop bounds
• counting, summing, filtering, and searching
• tracing conditions without skipping steps

If loops still feel slippery, do not move on politely. That is one of the main places the exam will keep charging you rent.

Unit 4: Data Collections

This is the other heavyweight. You need clean control of:

• arrays
• ArrayList
• 2D arrays
• traversal order
• mutation while iterating
• size() versus length

This is also where many FRQ points live.

Unit 3: Class Creation

You still need it. You should know how to:

• choose fields
• write a constructor
• use this
• return the right type
• write short helper methods that match the spec

But if your study plan spends all week polishing class vocab while your loop tracing is shaky, the plan is upside down.

How to think about the multiple-choice section

The multiple-choice section is mostly about execution.

A good reader keeps asking:

• What are the variables right now?
• How many times does this loop really run?
• What changes after this line or method call?

The clean rule is:

Trace what the code does, not what you think it meant to do.

How to think about the FRQs

The FRQs feel harder because you have to produce code from scratch. But the shapes are predictable enough that you should know what kind of problem you are in.

Each question has a known family.

FRQ 1 and 2

These are the “read the spec closely” questions. Students lose points here by writing too early, returning the wrong thing, or blurring fields and parameters. For the specific moves that keep showing up here, see our walkthrough of AP CSA FRQ 1 and 2: methods and class design.

FRQ 3 and 4

These are the data-structure questions. Students lose points here by mutating a list carelessly or mixing up rows and columns in a grid. The clearer playbook is in AP CSA FRQ 3 and 4: ArrayList and 2D array strategy.

Pacing that actually fits the exam

Multiple choice

You have 90 minutes for 42 questions, which is a little over 2 minutes per question on average.

That is enough time if you do not keep restarting the trace.

The worst pacing habit is half-tracing, getting nervous, and restarting from the top. A better rhythm is:

1. identify the task
2. track the changing values
3. check the answer against the actual code path

Free response

You have 90 minutes for 4 FRQs, which means roughly 22 minutes each, with some wiggle room.

Do not try to write immediately. Spend the first minute or two translating the prompt into a checklist:

• What is given?
• What must be returned or changed?
• What fields, parameters, or methods already exist?
• What edge case can break this?

That small pause usually saves more time than it costs.

If your study time is short, a structured pass through the course is usually a better use of it than rereading notes; the cleanest version of that is in how to study AP CSA without getting stuck in syntax.

A strong AP CSA study plan is not complicated

Each week should include:

• short code-tracing reps
• one or two focused multiple-choice sets
• at least one FRQ write-up
• mistake review by pattern

Sort misses like this:

• off-by-one
• wrong branch
• forgot to update state
• returned the wrong value
• mixed up size() and length
• removed from a list incorrectly
• mixed up row and column

That is much more useful than writing “careless.”

What to do in the final stretch

In the last two weeks, do not try to become a different programmer. Try to become a cleaner AP CSA test taker.

Prioritize:

• tracing without an IDE
• short FRQ reps under time
• reviewing old misses until you can name the trap fast
• practicing with the Java Quick Reference so it feels familiar

You do not need to sound smart about computer science. You need to stay clear long enough to collect the available points.