In Java, assignment operators are used to assign values to variables. The most basic assignment operator is the = operator, which simply assigns the value on the right-hand side to the variable on the left-hand side.
In addition to the basic assignment operator, Java provides several compound assignment operators that combine arithmetic or bitwise operations with assignment.
Table of Contents
In this tutorial, we will cover:
Basic Assignment Operator (=)
Compound Assignment Operators (e.g., +=, -=, *=, /=, etc.)
Examples of Each Operator
Key Considerations
1. Basic Assignment Operator (=)
The simplest and most commonly used assignment operator is the = operator. It assigns the value on the right-hand side to the variable on the left-hand side.
Syntax:
variable = value; Example 1: Basic Assignment
public class BasicAssignmentExample {
public static void main(String[] args) {
// Assigning integer value
int x = 10;
// Assigning double value
double y = 20.5;
// Assigning string value
String name = "Alice";
// Printing values
System.out.println("x: " + x); // 10
System.out.println("y: " + y); // 20.5
System.out.println("name: " + name); // Alice
}
}
Explanation:
The = operator is used to assign values to variables of different data types (integer, double, and string).
Once assigned, the variables x, y, and name hold the specified values.
2. Compound Assignment Operators
In Java, compound assignment operators are used to perform an operation (such as addition, subtraction, multiplication, or division) on a variable and assign the result to that variable. These operators are shorthand for the longer forms that involve both the operation and assignment.
List of Compound Assignment Operators:
+=: Adds the right operand to the left operand and assigns the result to the left operand.
-=: Subtracts the right operand from the left operand and assigns the result to the left operand.
*=: Multiplies the left operand by the right operand and assigns the result to the left operand.
/=: Divides the left operand by the right operand and assigns the result to the left operand.
%=: Takes the modulus (remainder) of the left operand divided by the right operand and assigns the result to the left operand.
&=: Performs a bitwise AND and assigns the result to the left operand.
|=: Performs a bitwise OR and assigns the result to the left operand.
^=: Performs a bitwise XOR and assigns the result to the left operand.
<<=: Left shifts the bits of the left operand and assigns the result to the left operand. >>=: Right shifts the bits of the left operand and assigns the result to the left operand.
Examples of Each Operator
Example 2: Addition Assignment (+=)
public class AdditionAssignmentExample {
public static void main(String[] args) {
int a = 5;
a += 10; // Equivalent to: a = a + 10;
System.out.println("a after +=: " + a); // Output: 15
}
}
Explanation:
The expression a += 10 adds 10 to the value of a and then assigns the result to a. This is shorthand for a = a + 10.
Example 3: Subtraction Assignment (-=)
public class SubtractionAssignmentExample {
public static void main(String[] args) {
int b = 20;
b -= 5; // Equivalent to: b = b - 5;
System.out.println("b after -=: " + b); // Output: 15
}
}
Explanation:
The expression b -= 5 subtracts 5 from the value of b and then assigns the result to b. This is shorthand for b = b – 5.
Example 4: Multiplication Assignment (*=)
public class MultiplicationAssignmentExample {
public static void main(String[] args) {
int c = 4;
c *= 3; // Equivalent to: c = c * 3;
System.out.println("c after *=: " + c); // Output: 12
}
}
Explanation:
The expression c *= 3 multiplies c by 3 and then assigns the result to c. This is shorthand for c = c * 3.
Example 5: Division Assignment (/=)
public class DivisionAssignmentExample {
public static void main(String[] args) {
int d = 20;
d /= 4; // Equivalent to: d = d / 4;
System.out.println("d after /=: " + d); // Output: 5
}
}
Explanation:
The expression d /= 4 divides d by 4 and then assigns the result to d. This is shorthand for d = d / 4.
Example 6: Modulus Assignment (%=)
public class ModulusAssignmentExample {
public static void main(String[] args) {
int e = 15;
e %= 4; // Equivalent to: e = e % 4;
System.out.println("e after %=: " + e); // Output: 3
}
}
Explanation:
The expression e %= 4 calculates the remainder of e divided by 4 and assigns the result to e. This is shorthand for e = e % 4.
Example 7: Bitwise AND Assignment (&=)
public class BitwiseAndAssignmentExample {
public static void main(String[] args) {
int f = 6; // Binary: 110
f &= 3; // Binary: 011
// Result: 010 (2 in decimal)
System.out.println("f after &=: " + f); // Output: 2
}
}
Explanation:
The expression f &= 3 performs a bitwise AND operation between f and 3. The result is assigned to f.
Example 8: Bitwise OR Assignment (|=)
public class BitwiseOrAssignmentExample {
public static void main(String[] args) {
int g = 5; // Binary: 101
g |= 2; // Binary: 010
// Result: 111 (7 in decimal)
System.out.println("g after |=: " + g); // Output: 7
}
}
Explanation:
The expression g |= 2 performs a bitwise OR operation between g and 2. The result is assigned to g.
Example 9: Bitwise XOR Assignment (^=)
public class BitwiseXorAssignmentExample {
public static void main(String[] args) {
int h = 7; // Binary: 111
h ^= 3; // Binary: 011
// Result: 100 (4 in decimal)
System.out.println("h after ^=: " + h); // Output: 4
}
}
Explanation:
The expression h ^= 3 performs a bitwise XOR operation between h and 3. The result is assigned to h.
Example 10: Left Shift Assignment (<<=)
public class LeftShiftAssignmentExample {
public static void main(String[] args) {
int i = 5; // Binary: 101
i <<= 1; // Left shift by 1: 1010 (10 in decimal)
System.out.println("i after <<=: " + i); // Output: 10
}
}
Explanation:
The expression i <<= 1 left-shifts the bits of i by 1 position. This is equivalent to multiplying i by 2. Example 11: Right Shift Assignment (>>=)
public class RightShiftAssignmentExample {
public static void main(String[] args) {
int j = 8; // Binary: 1000
j >>= 2; // Right shift by 2: 0010 (2 in decimal)
System.out.println("j after >>=: " + j); // Output: 2
}
}
Explanation:
The expression j >>= 2 right-shifts the bits of j by 2 positions. This is equivalent to dividing j by 4 (since 2^2 = 4).
3. Key Considerations
Data Types: Compound assignment operators work with different data types, but it's important to ensure that the operation is meaningful for the type. For example, using /= for integer types will perform integer division, which discards the fractional part.
Implicit Casting: When using compound assignment operators, implicit type casting may occur if the operands are of different types. Be aware of this to avoid unexpected behavior.
Example:
int a = 10; double b = 2.5; a += b; // a will be cast to 12 (b is truncated) System.out.println(a); // Output: 12
Bitwise Operations: The bitwise compound operators (&=, |=, ^=, <<=, >>=) are primarily used in low-level programming or performance-critical sections of code, so they are less commonly encountered in everyday Java programming.
Conclusion
In this tutorial, we explored assignment operators in Java, including:
Basic Assignment (=): Used to assign values to variables.
Compound Assignment Operators: Shorthand for performing an operation and assignment in one step (e.g., +=, -=, *=, /=).
Examples of each operator with code demonstrations.
Key considerations when working with assignment operators, including implicit casting and data types.
By understanding and effectively using these assignment operators, you can write cleaner and more concise code.