I covered these briefly in Doing Math in Java, Part 1. Now I'll go into a bit more detail.

**The Simple Assignment Operator**

The simple assignment operator is

`=`.

It places the value from the expression on its right side into the variable on its left.

This is covered in detail in Left Becomes Right.

Also see the Java Language Specification: The Simple Assignment Operator.

**The Compound Assignment Operators**

The compound assignment operators are:

`+=`, "plus-equals",

`-=`, "minus-equals",

`*=`, "times-equals" or "star-equals",

`/=`, "divided by-equals" or "slash-equals",

`%=`, "remainder-equals" or "percent-equals",

`&=`, "and-equals",

`|=`, "or-equals",

`^=`, "exor-equals" or "caret-equals",

`>>=`, "signed-shift-right-equals",

`<<=`, "shift-left-equals",

`>>>=`, "unsigned-shift-right-equals".

**Commonality**

Each of these operators has a variable to assign a value to before it, and an expression that results in a value after it:

`variable`

`operator`

`expression`

The expression has to result in a value that is compatible with

`variable`'s type.

Java will calculate the value of

`expression`,

perform the calculation

`variable`

`optype`

`expression`, where

`optype`is the assignment operator without the equals sign.

Then it will place the result of that calculation into

`variable`.

`+=`, "Plus-Equals"Plus-equals adds the value after += to the original value of the variable, then puts the result into the variable.

`-=`, "Minus-Equals"This subtracts the value after the operator from the original value in the variable, then stores the result in the variable.

`*=`, "Times-Equals"Multiply the variable by the value on the right of the operator, put the result in variable.

`/=`, "Divided by-Equals"Same as the above, but for division.

`%=`, "Remainder-Equals"This finds the

*remainder*of the variable's initial value divided by the value after the operator. That

*remainder*is then put into the variable.

See Java's Modulo Operator--Wrapping Around for more information on how the remainder (or modulo) operator

`%`works.

`&=`, "And-Equals"And-equals does a bit-wise AND of the value after the assignment operator with the original value of the variable, then puts the results in the variable.

`|=`, "Or-Equals"Or-equals does a bit-wise OR of the variable and the value after the operator. The result is placed in the variable.

`^=`, "Exor-Equals"Exor-equals is short of Exclusive-Or Equals (and it is often written xor-equals). It does a bitwise exclusive-or of the variable and the value after the assignment operator, then puts the result into the variable.

`>>=`, "Signed-Shift-Right-Equals"This does a signed right shift of the variable a number of times equal to the expression after the assignment operator. The result is placed in variable.

`<<=`, "Shift-Left-Equals"This does the same thing as signed-shift-right-equals, except it does a signed left shift (each bit in the variable gets moved to the left

*expression*times.

`>>>=`, "Unsigned-Shift-Right-Equals"This one moves all the bits, unlike the signed shifts which leave the sign bit (highest order bit) alone.

**Not Quite the Whole Story**

That covers how these operators behave with numerical and other simple values. These operators have other behaviors when used with Strings, Arrays, and other complex value types. That goes beyond the scope of this article, however, more on that can be found at the links given under "Additional Information".

**Additional Information**

See the Java Language Specification: Compound Assignment Operators, Multiplicative Operators, Additive Operators, Bit-wise and Logical Operators.