---
title: "Assignment of Operators"  
description: "The Simple Assignment OperatorOne of the most common operators that you'll encounter is the simple assignment operator \"=\". You saw this operator in t"  
author: "ANkita gupta"  
published: 2015-05-11  
updated: 2018-02-21  
canonical: https://www.mindstick.com/blog/10884/assignment-of-operators  
category: "java"  
tags: ["java"]  
reading_time: 6 minutes  

---

# Assignment of Operators

##### The Simple Assignment Operator

One of the most common operators that you'll encounter is the simple [assignment](https://www.mindstick.com/articles/126300/apa-citation-style-get-to-know-about-it-for-your-next-assignment) operator "=". You saw this operator in the Bicycle class; it assigns the value on its right to the operand on its left:

```
int cadence = 0;
 int speed = 0;
 int gear = 1;
```

This operator can also be used on objects to assign object references, as discussed in Creating objects..

##### The Arithmetic Operators

The Java [programming language](https://www.mindstick.com/articles/329035/5-most-in-demand-programming-languages-to-consider-for-your-app-development-in-2022) provides operators that perform addition, subtraction, multiplication, and division. There's a good chance you'll recognize them by their counterparts in basic mathematics. The only symbol that might look new to you is "%", which divides one operand by another and returns the remainder as its result.

| Operator | Description |
| --- | --- |
| + | Additive operator (also used for String [concatenation](https://www.mindstick.com/forum/34153/how-to-write-program-to-file-concatenation-program-in-java-i-o)) |
| - | Subtraction operator |
| * | Multiplication operator |
| / | Division operator |
| % | Remainder operator |

The following program, ArithmeticDemo, tests the [arithmetic operators](https://www.mindstick.com/forum/157625/what-is-meant-by-arithmetic-operators-in-python).

```
class ArithmeticDemo {

    public static void main (String[] args) {

        int result = 1 + 2;
        // result is now 3
        System.out.println("1 + 2 = " + result);
        int original_result = result;

        result = result - 1;
        // result is now 2
        System.out.println(original_result + " - 1 = " + result);
        original_result = result;

        result = result * 2;
        // result is now 4
        System.out.println(original_result + " * 2 = " + result);
        original_result = result;

        result = result / 2;
        // result is now 2
        System.out.println(original_result + " / 2 = " + result);
        original_result = result;

        result = result + 8;
        // result is now 10
        System.out.println(original_result + " + 8 = " + result);
        original_result = result;

        result = result % 7;
        // result is now 3
        System.out.println(original_result + " % 7 = " + result);
    }
}
```

This program prints the following:

```
1 + 2 = 3
3 - 1 = 2
2 * 2 = 4
4 / 2 = 2
2 + 8 = 10
10 % 7 = 3
```

You can also combine the arithmetic operators with the simple assignment operator to create compound assignments. For example, x+=1; and x=x+1; both increment the value of x by 1.

The + operator can also be used for concatenating (joining) [two strings](https://www.mindstick.com/forum/159716/regex-match-all-characters-between-two-strings) together, as shown in the following [ConcatDemo](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/examples/ConcatDemo.java) program:

```
class ConcatDemo {
    public static void main(String[] args){
        String firstString = "This is";
        String secondString = " a concatenated string.";
        String thirdString = firstString+secondString;
        System.out.println(thirdString);
    }
}
```

By the end of this program, the variable thirdString contains "This is a concatenated string.", which gets printed to standard output.

##### The Unary Operators

The unary operators require only one operand; they perform various operations such as incrementing/decrementing a value by one, negating an [expression](https://www.mindstick.com/articles/1861/sqlite-expressions), or inverting the value of a boolean.

| Operator | Description |
| --- | --- |
| + | Unary plus operator; indicates positive value (numbers are positive without this, however) |
| - | Unary minus operator; negates an expression |
| ++ | Increment operator; increments a value by 1 |
| -- | Decrement operator; decrements a value by 1 |
| ! | Logical complement operator; inverts the value of a boolean |

The following program, [UnaryDemo](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/examples/UnaryDemo.java), tests the unary operators:

```
class UnaryDemo {

    public static void main(String[] args) {

        int result = +1;
        // result is now 1
        System.out.println(result);

        result--;
        // result is now 0
        System.out.println(result);

        result++;
        // result is now 1
        System.out.println(result);

        result = -result;
        // result is now -1
        System.out.println(result);

        boolean success = false;
        // false
        System.out.println(success);
        // true
        System.out.println(!success);
    }
}
```

The increment/decrement operators can be applied before (prefix) or after (postfix) the operand. The code result++; and ++result; will both end in result being incremented by one. The only difference is that the prefix version (++result) evaluates to the incremented value, whereas the postfix version (result++) evaluates to the original value. If you are just performing a simple increment/decrement, it doesn't [really matter](https://yourviews.mindstick.com/view/85689/does-rahul-gandhi-name-really-matter-to-indians) which version you choose. But if you use this operator in part of a larger expression, the one that you choose may make a significant difference.

The following program, [PrePostDemo](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/examples/PrePostDemo.java), illustrates the prefix/postfix unary increment operator:

```
class PrePostDemo {
    public static void main(String[] args){
        int i = 3;
        i++;
        // prints 4
        System.out.println(i);
        ++i;
        // prints 5
        System.out.println(i);
        // prints 6
        System.out.println(++i);
        // prints 6
        System.out.println(i++);
        // prints 7
        System.out.println(i);
    }
}
```

---

Original Source: https://www.mindstick.com/blog/10884/assignment-of-operators

Copyright © MindStick Software Pvt. Ltd. This Markdown version is provided for developers, AI systems, and offline reading.