AP CSA Study Plan

Admin checklist

Self-study does not register you for the exam — confirm with CAIS / AP coordinator.

Exam seat confirmed — CAIS/AP coordinator confirms order, venue, fee & deadline
College Board account — legal name matches ID; login & recovery work
AP Classroom access — join class or exam-only section
Bluebook installed — supported device + official test preview before May

This week

Sep 16–21, 2026 · Setup + Unit 1 foundations (start Wed)

Wed: types & variables + Check (5 snippets)
Thu: expressions, casting, integer division
Fri: compound ops + Math (random 1–6)
Sat (opt): redo Wed snippets from memory
Sun (opt): light rest or flashcards

Aligned to Ziv Sep 9–30 focus; official start Wed Sep 16 (skip Tue).

Today’s jot

Date:
Types touched:
Snippet (what I wrote):
Predict →
Actual →
One sentence: int vs double this week —
Shaky:

Exam at a glance

Wed 12 May 2027 · Session 2
3 hours fully digital in Bluebook
42 MCQ · 90 min · 55%
4 FRQ · 90 min · 45%

Aim for a consistent estimated 4/5 range — universities decide credit; a 3 is “qualified.”

FRQ 1 · Methods & control

Write two methods, or one constructor and one method, using calls, conditions/loops and String methods.

FRQ 2 · Class design

Implement a class: header, instance variables, constructor and required method from a specification.

FRQ 3 · ArrayList

Traverse and manipulate data stored in an ArrayList.

FRQ 4 · 2D array

Traverse and manipulate rows, columns and elements in a two-dimensional array.

Complete course · 4 units

Revised 2026–27 framework — not the old 10 units. Code analysis is ~37–53% of MCQ. Inheritance is removed as a core unit.

Unit 1 · Using Objects and Methods

15–25% MCQ

Algorithms, program structure, compilation & runtime
int / double / boolean; assignment, arithmetic, compound, remainder
Integer division, casting, overflow; objects, references, null, aliasing
Methods, params, return, overloading; String + prescribed methods
Math + random; wrappers / autoboxing; comments, pre/postconditions

Output: 25–35 short programs, mini-project, unit test, methods FRQ

Primitives, assignment & arithmetic
Casting, integer division & overflow
Objects, references, null & aliasing
Methods, params, return & overloading
String + prescribed methods
Math, random, wrappers / autoboxing
Comments, preconditions & postconditions
Output goals done (programs + mini-project + test + FRQ)

Unit 2 · Selection and Iteration

25–35% MCQ

Relational / Boolean ops; if / else / nested; De Morgan
Short-circuit; correct comparisons (primitive, String, reference)
while / for / nested; accumulators, counters, max/min
String traversal; off-by-one & infinite loops; tracing

Output: 40+ exercises, simulation, timed FRQ parts, cumulative test

Boolean logic, if/else & De Morgan
Short-circuit & correct comparisons
while / for / nested loops
Accumulators, counters, max/min
String traversal & construction
Off-by-one, infinite loops & tracing
Output goals done (40+ + simulation + FRQs + test)

Unit 3 · Class Creation

10–18% MCQ

Class headers, private fields, constructors, accessors / mutators
Public / private; instance / static; this; scope
Pass-by-value; helpers; invariants / pre/post; client testing

Inheritance is not a core unit — do not let an old textbook drive the plan.

Output: several small classes + ≥4 class-design tasks/FRQs

Headers, private fields & encapsulation
Constructors & initialization
Accessors, mutators & behaviour methods
Public/private, instance/static, this & scope
Pass-by-value & reference mutation
Helpers, invariants & pre/post
Client testing & reference/runtime errors
Output goals done (classes + ≥4 design FRQs)

Unit 4 · Data Collections

30–40% MCQ

1D arrays; enhanced for; ArrayList API
2D arrays; standard algorithms (count/sum/avg/min/max/filter/replace)
Searching + prescribed sorting; recursion (base / recursive / trace)
Reading text files / data sets; boundary & runtime errors

Output: array / ArrayList / grid projects + repeated timed FRQ 3 & 4

1D arrays & enhanced for
ArrayList API & safe traversal
2D arrays & nested traversal
Standard algorithms (count/sum/avg/min/max/filter)
Searching & prescribed sorting
Recursion: base, recursive call & trace
Text files / data sets
Boundary & runtime errors
Output goals done (projects + timed FRQ 3/4)

35-week calendar

Sep → May 11 · from Ziv Learning Studio guide

Dates	Focus	Required work	Checkpoint
9–30 Sep	Setup + Unit 1 foundations	Register; install tools; diagnostic; syntax, types, expressions, casts, methods & basic objects. Code 4 days/week.	Write, compile & debug 10 small programs without AI writing them.
October	Finish Unit 1	Objects, references, Strings, Math, wrappers & documentation. Build a quiz, calculator or simple game.	65%+ unit MCQ; explain aliasing, integer division, String equality & return values.
November	Unit 2A	Boolean logic, conditions, equivalence, short-circuiting & tracing.	Solve unfamiliar condition-tracing problems without running the code.
December	Unit 2B	Loops, nested loops, String traversal & common loop algorithms; 8–10 CodingBat weekly.	65%+ cumulative Unit 1–2 test; write standard patterns from a blank screen.
January	Unit 3	Design several small classes; practise new-style specification tables.	Write a complete class—header, fields, constructor & method—in 25 minutes.
February	Unit 4A	Arrays & ArrayList; begin one timed collection FRQ each week.	No confusion among `array.length`, `String.length()` & `list.size()`.
1–15 March	Unit 4B	2D arrays, standard algorithms & data analysis.	Complete ArrayList & 2D-array FRQs under time.
16–31 March	Finish content	Recursion, files/data sets, cumulative review & first full 3-hour mock.	Score with rubrics; rank the top five recurring errors.
1–14 April	Targeted repair	Relearn three weakest areas; two mixed MCQ sets & all four FRQ types each week.	75%+ mixed MCQ & ~70%+ of available FRQ rubric points.
15–30 April	Exam simulation	Two full timed exams; Bluebook navigation; type without compiler/autocomplete.	Two consecutive results in the estimated 4/5 range.
1–11 May	Taper	One early final mock, then short error/algorithm review. Confirm device & admission.	Rested, equipped and consistent—not cramming.

Repeatable 7½-hour week

2 × 60 min — Learn a topic, then reproduce examples without looking
3 × 60 min — Write and debug code from a blank screen
60 min — Trace MCQs by hand; explain each mistake
75 min — Complete an FRQ or a small project
15 min — Update tracker and error log

Every fourth week: replace the project with a cumulative timed test. Aim ~70% writing/tracing, 20% explanation, 10% projects.

Progress targets

December: 65%+ on unit MCQs
February: 70%+ and able to complete individual FRQ parts
31 March: all curriculum content completed
Mid-April: 75%+ mixed MCQ / ~70% FRQ rubric points
Final two mocks: stable estimated 4/5 range

Resources

Free core — enough to finish the course

College Board CED — authoritative curriculum and samples
CSAwesome2 (2026+) — primary interactive course; do not use CSAwesome v1 as main sequence
Official Java Quick Reference — keep open from week one
CodingBat Java — short logic, String, loop and array drills
Official released FRQs — questions, rubrics, samples, commentary
AP Classroom — topic questions & progress checks after enrollment
BlueJ or IntelliJ IDEA Community + current JDK (BlueJ simpler for beginners)
Bluebook — required digital-exam practice

Optional paid — choose one

Recommended: Barron’s AP CSA Premium, 13th ed. (Teukolsky & Carman), ISBN 9798349700354 — revised 2026 exam, six practice tests
Alternative: Princeton Review AP CSA Premium Prep, 9th ed., ISBN 9780593518410
Extra FRQ depth: Be Prepared for the AP CSA Exam in Java, 9th ed. (2026)

Do not use Barron’s 12th edition or another old 10-unit book as the primary resource. Older books may emphasize removed inheritance content, omit files/data sets, or describe the former exam.

Past FRQs, traps & AI discipline

How to use past exam questions

During content learning: pick individual parts by topic; don’t burn full recent papers early
From February: rotate all four current FRQ categories under a ~22-minute target
After every FRQ: mark with the official rubric, then rewrite missed sections without the solution
In April: reserve unused material for two or three full simulations

Older released questions do not fully align with the 2025–26 revision. Prioritize 2026+ and current FRQ categories; use 2023–25 selectively for still-valid Java skills and ignore removed-topic points.

Classic traps

Use .equals for String content — not ==
Zero-based indexing and exclusive upper bounds
Distinguish array.length, String.length(), list.size()
Removing from an ArrayList while moving forward can skip elements — trace index shifts
Test empty, one-element, first/last, all-match / no-match, and permitted null cases
FRQs are typed in Bluebook with no IDE compiler, debugger or autocomplete — practise plain editor
Wrong bounds, return value, mutation or assumptions can cost more than a small syntax slip
AP CSA ≠ AP CSP — no Create performance task; Java programming + code analysis only

AI discipline

Attempt first. AI may explain or generate fresh practice, but you must then solve again independently. Otherwise it hides readiness. Best strategy: write and trace Java every week from September, finish new content by 31 March, and spend April on timed mixed practice plus disciplined error correction.

Tomorrow · Wed Sep 16 · first session

~45–60 min · Unit 1 foundations · types & variables

Setup (5–10 min) — Open BlueJ or IntelliJ + JDK. Confirm a “Hello” program compiles and runs. Skim the Java Quick Reference once.
Learn (15–20 min) — int, double, boolean; declaring variables; assignment. Note the difference between integer and floating-point division.
Check · 5 snippets (15–20 min) — Write five tiny programs from a blank screen (e.g. declare mixed types, print a sum, store a remainder, flip a boolean, cast a double to int). Predict output before running.
Jot (5 min) — Fill today’s jot template (Copy button above). Mark Wed checkbox when done.

Skip Tue. Weekend is optional redo / rest only.