Compound Assignment Operators

Programs change the same variable over and over. A game adds points to a score each time you hit a target. A shopping cart adds each item’s price to a running total. A bank app subtracts each purchase from a balance. In each case the new value depends on the old one.

You can already do this with the assignment statement from Topic 1.4:

score = score + 10;

Recall how Java runs that line. It works out the right side first, using the value score holds right now, and only then stores the result back into score, replacing the old value. If score held 40, the right side is 40 + 10, which is 50, and 50 goes into score.

That works, but notice that the variable name appears twice. In a long program with names like totalPointsThisRound, writing the name twice is tiring and gives you two chances to mistype it. Updating a variable from its own value is so common that Java gives it a shorter form:

score += 10;

Read += as “add to.” The line means “add 10 to score.” It does exactly what score = score + 10; does: Java reads the current value of score, adds 10, and stores the result back in score.

The += symbol is a compound assignment operator: an operator that does an arithmetic operation between a variable’s current value and the value on its right, then stores the result back in that same variable. “Compound” means it combines two jobs, arithmetic and assignment, in one symbol.

Look at each piece of score += 10;:

The left side must be a variable. A compound operator stores a result, and the only place Java can store a value is in a variable, the same reason = needs a variable on its left in Topic 1.4. The order of the two symbols matters: plus first, then equals.

int score = 40;
score += 10;
System.out.println(score);
score += 25;
System.out.println(score);

50
75

Now vary two things: the variable is a double, and the amount added is another variable instead of a literal.

double total = 0.0;
double price = 3.5;
total += price;
total += price;
total += 1.25;
System.out.print("Total: ");
System.out.println(total);

Total: 8.25

int score = 40;
score =+ 10;
System.out.println(score);

int coins = 12;
coins += 8;
coins += coins;
System.out.println(coins);

Adding is not the only update programs need. A balance goes down when you pay for something. A prize doubles. A bill is split among friends. Java has a compound operator for each of the five arithmetic operators you learned in Topic 1.3, and every one works the same way as +=: do the arithmetic between the variable’s current value and the right side, then store the result back in the variable.

Here is that table as code, with each operator starting from a fresh variable that holds 20:

int plus = 20;
plus += 6;
System.out.println(plus);
int minus = 20;
minus -= 6;
System.out.println(minus);
int times = 20;
times *= 6;
System.out.println(times);
int divide = 20;
divide /= 6;
System.out.println(divide);
int remainder = 20;
remainder %= 6;
System.out.println(remainder);

It prints 26, 14, 120, 3, and 2, one per line. Look closely at the last two. Because divide and 6 are both int values, /= follows the integer division rule from Topic 1.3: 20 / 6 is 3.333…, and Java keeps only the whole-number part, 3. And %= stores the remainder: 6 goes into 20 three times (that is 18), leaving 2.

int gems = 50;
gems -= 8;
gems *= 2;
gems /= 5;
gems %= 5;
System.out.print("Gems: ");
System.out.println(gems);

Gems: 1

Now change one thing: the variable is a double. Watch what that does to /=.

double balance = 80.0;
balance -= 12.5;
balance *= 2;
balance /= 4;
System.out.print("Balance: ");
System.out.println(balance);

Balance: 33.75

int price = 15;
price *= 1.5;
System.out.println(price);

int price = 15;
price = price * 1.5;
System.out.println(price);

error: incompatible types: possible lossy conversion from double to int

double price = 15.0;
price *= 1.5;
System.out.println(price);

int pages = 45;
pages -= 9;
pages /= 5;
pages %= 4;
System.out.println(pages);

int slices = 7;
slices /= 2;
System.out.println(slices);

So far the right side of every compound operator has been a single number or variable. It can also be a whole expression. Suppose a store has 10 boxes of a product and each one is replaced by a pack of 2 + 3 boxes:

stock *= 2 + 3;

Which happens: stock * 2, then + 3? Or stock * (2 + 3)? Topic 1.3 taught that * happens before +, which might suggest the first reading. But that is not how compound operators work.

Java first works out the entire right side, down to a single value. Only then does it combine that value with the variable. So stock *= 2 + 3; means stock = stock * (2 + 3);, as if the right side were wrapped in parentheses. This is the same order as a plain assignment in Topic 1.4: the right side is finished before anything is stored. The operator is “multiply the variable by whatever the right side turns out to be.”

int stock = 10;
stock *= 2 + 3;
System.out.println(stock);

The rule matters most with -= and /=, because subtraction and division give different answers when the grouping changes.

int seats = 30;
seats -= 4 + 6;
System.out.println(seats);
int points = 100;
points /= 2 * 5;
System.out.println(points);

20
10

int seatsA = 30;
seatsA = seatsA - 4 + 6;
System.out.println(seatsA);
int seatsB = 30;
seatsB = seatsB - (4 + 6);
System.out.println(seatsB);

32
20

int width = 20;
width -= 2 + 3;
width /= 1 + 2;
System.out.println(width);

One update is more common than all the others: changing a variable by exactly one. A program counts laps, visitors, or correct answers one at a time; a game takes away one life. You could write laps += 1;, and that works. Counting by one is so common, though, that Java has an even shorter form.

The post-increment operator ++ adds 1 to the value stored in a variable. The post-decrement operator -- subtracts 1. “Increment” means increase by a step and “decrement” means decrease by a step; “post” means the operator is written after the variable name. These three statements all do the same thing:

and in the same way, lives--; does what lives -= 1; and lives = lives - 1; do. Like the other compound operators, ++ and -- read the variable’s current value, change it, and store the new value back in the same variable. There is no right side, because the amount is always 1.

int laps = 0;
laps++;
laps++;
laps++;
System.out.print("Laps: ");
System.out.println(laps);
int lives = 3;
lives--;
System.out.print("Lives: ");
System.out.println(lives);

Laps: 3
Lives: 2

Now vary the type. ++ and -- work on any number variable, including a double. They still change it by exactly one; they do not move to the next whole number.

double temperature = 71.5;
temperature++;
System.out.println(temperature);
temperature--;
temperature--;
System.out.println(temperature);

72.5
70.5

71.5 plus one is 72.5. Then two decrements take it down to 70.5. The decimal part is untouched.

One form only. Java also lets you write the plus signs in front of the variable (++laps), and it lets you put laps++ inside a bigger expression, such as in the middle of another calculation or a print statement. Both of those uses follow extra rules that are easy to misread, and neither is part of this course or the AP exam. In this course, ++ and -- always come after the variable, in a statement by themselves, like laps++;. The same goes for every compound operator: use each one as its own statement.

int laps = 0;
laps + 1;
System.out.println(laps);

error: not a statement

int laps;
laps++;
System.out.println(laps);

error: variable laps might not have been initialized

int lives = 3;
lives--;
lives--;
lives++;
lives -= 1;
System.out.println(lives);

int stamps = 5;
stamps =- 1;
System.out.print("Stamps left: ");
System.out.println(stamps);

int stamps = 5;
stamps--;
System.out.print("Stamps left: ");
System.out.println(stamps);

This program follows one round of an arcade game and uses every operator from the chapter. Before reading the trace, try to predict the four lines of output yourself.

public class ArcadeRound
{
    public static void main(String[] args)
    {
        int score = 0;
        int lives = 3;
        int tokens = 20;
        score += 150;
        score *= 2;
        lives--;
        tokens -= 4;
        score -= 25 + 15;
        lives++;
        int prizes = tokens;
        prizes /= 3;
        tokens %= 3;
        System.out.print("Score: ");
        System.out.println(score);
        System.out.print("Lives: ");
        System.out.println(lives);
        System.out.print("Prizes: ");
        System.out.println(prizes);
        System.out.print("Tokens left: ");
        System.out.println(tokens);
    }
}

Score: 260
Lives: 3
Prizes: 5
Tokens left: 1

• A compound assignment operator updates a variable from its own current value in one step: x += 5; means x = x + 5;. There is one for each arithmetic operator: +=, -=, *=, /=, and %=. The left side must be a variable.
• Each update starts from the value the variable holds at that moment, so a series of updates must be traced line by line.
• The whole right side is evaluated first, then combined with the variable: x -= a + b; means x = x - (a + b);.
• The usual type rules apply: with two int values, /= drops the decimal part and %= keeps the remainder. If the result is a double but the variable is an int, the decimal part is silently chopped off.
• x++; adds 1 and x--; subtracts 1. Write them after the variable, as a statement by themselves.
• =+ and =- are not compound operators; they assign a positive or negative value and compile without any warning.

double average = 7;
average /= 2;
System.out.println(average);

int apples = 9;
int baskets = 2;
apples += baskets * 3;
baskets++;
apples %= baskets + 1;
baskets *= apples;
apples--;
System.out.print("Apples: ");
System.out.println(apples);
System.out.print("Baskets: ");
System.out.println(baskets);

Apples: 2
Baskets: 9

int seconds = 200;
int minutes = seconds;
minutes %= 60;
seconds /= 60;
System.out.print("Minutes: ");
System.out.println(minutes);
System.out.print("Seconds: ");
System.out.println(seconds);

int seconds = 200;
int minutes = seconds;
minutes /= 60;
seconds %= 60;
System.out.print("Minutes: ");
System.out.println(minutes);
System.out.print("Seconds: ");
System.out.println(seconds);

Minutes: 3
Seconds: 20

int score = 7;
score /= 2;
score *= 2;
System.out.println(score);

Check each statement. If the answer is “not yet,” reread the linked subsection.

• I can explain what += does and why =+ is a different thing. Reread
• I can trace a series of -=, *=, /=, and %= updates, including integer division. Reread
• I can work out the whole right side before combining it with the variable. Reread
• I can use ++ and -- to add or subtract one, as a statement on its own. Reread