AP CSA FRQ Practice Plan: A 2-Week Route for Methods and Arrays

The short answer

AP CSA FRQ practice works best when it is organized by task type.

Do not just write random Java. The exam is not asking for a full application. It is asking whether you can read a specification, use the provided class or method context, and write a small piece of correct code under time.

Use this two-week plan:

• methods and control structures
• class design
• ArrayList traversal and mutation
• 2D array traversal
• mixed review
• mistake cleanup

The four-step FRQ routine

Use this routine before every FRQ:

1. Translate the prompt into inputs, fields, return value, and mutation.
2. Trace one example by hand.
3. Write the required method or class.
4. Review the answer against the exact contract.

The most common mistake is solving a nearby problem instead of the one the prompt actually asked.

Why this plan is different from a generic FRQ calendar

Most FRQ calendars say to do one question a day. That is not enough for AP CSA because the miss is often not “Java knowledge.” It is contract reading.

This plan rotates by the contract the prompt gives you:

• methods and control: can you return exactly what the method asks for?
• class design: can you separate fields, parameters, constructors, and helper methods?
• ArrayList: can you mutate without skipping shifted elements?
• 2D arrays: can you keep row and column meaning straight?

Use the AP CSA exam guide when you need the full format map, then come back here for the practice loop. If your misses cluster around list or grid traversal, move straight to ArrayList and 2D array FRQ strategy before doing another mixed set.

Mini rubric for every AP CSA FRQ attempt

Before you score the code, score the setup:

Check	What has to be clear before coding
Contract	What method, class, field, or return value is the prompt asking for?
Inputs	Which values are parameters, instance variables, or local variables?
Mutation	Does the prompt want the object or list changed, or only a returned result?
Trace	What happens on one tiny example, including loop bounds and indexes?
Review label	If it fails, is the miss spec translation, loop bound, state, return, ArrayList shift, or row/column order?

If the contract row is fuzzy, writing more Java usually makes the answer worse. Translate the prompt first, then code.

What to do today

Choose one old FRQ and spend five minutes without coding:

1. underline the required method or class
2. list fields, parameters, and locals
3. write one two-row trace table
4. predict the return value or mutation

Then code only after the contract is visible. If the trace breaks, jump to AP CSA multiple-choice tracing patterns before doing another full FRQ.

Days 1-2: Methods and control structures

Focus on one method at a time.

Practice:

• loop bounds
• conditionals
• helper method calls
• return values
• accumulator variables

After each attempt, ask:

• did I use the provided method correctly?
• did I return the requested value?
• did my loop visit every required element exactly once?

Days 3-4: Class design

Class design goes wrong when students blur fields and parameters.

Practice:

• identifying private instance variables
• writing constructors
• using this when needed
• storing state for later methods
• returning values from object state

Before writing code, make a small table:

Prompt fact	Field, parameter, or local variable?
saved across methods	field
passed into one method	parameter
used only during calculation	local variable

Days 5-6: ArrayList

ArrayList FRQs often test mutation while traversing.

Practice:

• removing while iterating
• avoiding skipped elements
• adding in the right position
• using size() and get()
• separating index from value

When removing items, be especially careful about index shifts. If the list shrinks, the next element may slide into the current index.

Days 7-8: 2D arrays

2D array mistakes are usually row/column mistakes.

Practice:

• outer loop rows, inner loop columns
• rectangular traversal
• boundary checks
• accumulating per row or per column
• returning a position or count

Write the dimensions before coding:

arr.length is rows.

arr[0].length is columns.

Days 9-10: Mixed timed sets

Now mix the types.

Do not review only by score. Review by mistake label:

• spec translation
• loop bounds
• wrong return
• field/parameter confusion
• ArrayList index shift
• 2D row/column confusion
• mutation missed or added by accident

The label tells you what to practice next.

Days 11-12: Redo misses

Redo the same FRQs or similar ones without looking at the old solution.

If you miss the same pattern again, write a rule.

Example:

“When removing from an ArrayList while moving forward, decrement the index or use a traversal strategy that does not skip the shifted item.”

Days 13-14: Final light pass

Do one short mixed set and one reading-only drill.

For the reading-only drill, do not code. Just translate prompts into fields, parameters, loops, return values, and mutation.

That may feel too simple, but it trains the step students skip under pressure.

Bottom line

AP CSA FRQ improvement is usually not about writing fancier Java.

It is about reading the prompt more exactly, tracing small examples, and avoiding the same loop, state, and traversal mistakes.