In AP Computer Science A, a counter variable is an int initialized before a loop (usually to 0) and incremented inside the loop to track how many times something happens, such as how many iterations have run or how many values meet a condition.
A counter variable is exactly what it sounds like. It's a variable, almost always an int starting at 0, that you bump up with count++ every time something you care about happens inside a loop. Counting iterations? Increment every pass. Counting how many values are even, negative, or above a threshold? Wrap the increment in an if statement so it only fires on a match.
The pattern has three steps that never change. First, initialize the counter before the loop. Second, increment it inside the loop (sometimes conditionally). Third, use the final value after the loop. If you initialize the counter inside the loop body, it resets to 0 every iteration and your count is wrong. That mistake is one of the most common ways AP students lose points on counting code.
Counter variables live in Topic 2.8 (For Loops) in Unit 2: Selection and Iteration, supporting learning objective 2.8.A, which asks you to develop code for iterative processes and determine their results. Per EK 2.8.A.2, the variable initialized in a for loop header is the loop control variable, and in the classic for (int i = 0; i < n; i++) pattern, that variable IS a counter. It counts which iteration you're on. Beyond that, the count-with-a-condition pattern is one of the standard algorithms the exam expects you to write fluently, and it reappears constantly once you hit arrays, ArrayLists, and 2D arrays. Counting how many elements meet a criterion is a perennial FRQ subtask.
Keep studying AP® Computer Science A Unit 2
Accumulator Variable (Unit 2)
A counter is really just a special accumulator. An accumulator adds varying amounts each iteration (like summing values), while a counter always adds exactly 1. Same setup, same 'initialize before, update inside' structure.
For Loop Control Variable (Unit 2)
The i in for (int i = 0; i < n; i++) is a built-in counter. The loop header handles the initialization and update for you, which is why for loops are the natural choice when you know how many times to repeat.
If Statements Inside Loops (Unit 2)
The conditional count pattern combines selection and iteration. The loop visits every value, the if decides whether this one counts, and the counter remembers the running total. This combo is the backbone of 'how many elements satisfy X' questions.
Array and ArrayList Traversals (Units 4 & 5 in newer course frameworks)
Counting elements that meet a condition is a go-to FRQ subtask once data structures show up. The counter pattern you learn in Unit 2 transfers directly. Initialize 0, loop through the structure, increment on a match, return the count.
On multiple choice, counter variables show up in code-tracing questions. You'll see a loop, and you have to determine the counter's final value, which means tracking exactly how many times the increment executes (watch the loop bounds carefully, since off-by-one errors are the trap). No released FRQ uses the phrase 'counter variable' verbatim, but the pattern itself is everywhere in free response. Methods that return 'the number of elements that...' require you to write the full pattern yourself, including initializing the counter to 0 before the loop, incrementing inside an if statement, and returning the count after the loop ends. Forgetting to initialize, initializing inside the loop, or returning inside the loop body (which exits after the first match) are all rubric-killing mistakes.
Both are initialized before a loop and updated inside it, but a counter adds exactly 1 each time (count++) to answer 'how many?', while an accumulator adds a varying amount (sum += value) to answer 'how much in total?'. If a question asks for the number of items, you need a counter. If it asks for a sum or total, you need an accumulator. To compute an average, you often need both.
A counter variable is initialized to 0 before a loop and incremented inside the loop to track how many times something happens.
Initialize the counter outside the loop; if you declare it inside the loop body, it resets to 0 every iteration and the count is wrong.
The loop control variable in a standard for loop header (EK 2.8.A.2) is itself a counter that tracks which iteration you're on.
To count only values that meet a condition, put the increment inside an if statement within the loop.
A counter always adds 1; an accumulator adds varying amounts. Use a counter for 'how many' and an accumulator for 'how much.'
When tracing loop code on the MCQ section, count exactly how many times the increment line runs, since off-by-one bounds errors are the classic trap.
It's a variable, usually an int initialized to 0 before a loop, that gets incremented inside the loop to count iterations or count how many values meet some condition. It's part of the Topic 2.8 iteration toolkit under learning objective 2.8.A.
A counter always increments by exactly 1 (count++) to answer 'how many?', while an accumulator adds different amounts each iteration (sum += value) to answer 'how much total?'. Computing an average uses both, since average = sum / count.
Yes, in the standard pattern for (int i = 0; i < n; i++), the loop control variable i is a counter that tracks the iteration number. EK 2.8.A.2 calls the variable in the initialization part the loop control variable, and the update part increments it each pass.
Almost always yes for counting tasks, and it must happen before the loop starts. Initializing it inside the loop body resets it every iteration, which is a classic bug that produces a final count of 0 or 1 and costs FRQ points.
Yes. A loop like for (int i = 10; i > 0; i--) uses a counter that decrements. The Boolean expression in the header still controls when the loop stops, exactly as EK 2.8.A.1 describes the three parts of a for loop header.
Connect this key term to the AP exam workflow: review the course, practice questions, and check related study tools.
Review units, study guides, and course resources.
Check this vocabulary in multiple-choice context.
Apply key concepts in written AP responses.
Estimate the exam score you are working toward.
Review the highest-yield facts before practice.
Put the full course together before test day.