assignment operator java list

Java Tutorial

Java methods, java classes, java file handling, java how to's, java reference, java examples, java operators.

Operators are used to perform operations on variables and values.

In the example below, we use the + operator to add together two values:

Try it Yourself »

Although the + operator is often used to add together two values, like in the example above, it can also be used to add together a variable and a value, or a variable and another variable:

Java divides the operators into the following groups:

• Arithmetic operators
• Assignment operators
• Comparison operators
• Logical operators
• Bitwise operators

Arithmetic Operators

Arithmetic operators are used to perform common mathematical operations.

Advertisement

Java Assignment Operators

Assignment operators are used to assign values to variables.

In the example below, we use the assignment operator ( = ) to assign the value 10 to a variable called x :

The addition assignment operator ( += ) adds a value to a variable:

A list of all assignment operators:

Java Comparison Operators

Comparison operators are used to compare two values (or variables). This is important in programming, because it helps us to find answers and make decisions.

The return value of a comparison is either true or false . These values are known as Boolean values , and you will learn more about them in the Booleans and If..Else chapter.

In the following example, we use the greater than operator ( > ) to find out if 5 is greater than 3:

Java Logical Operators

You can also test for true or false values with logical operators.

Logical operators are used to determine the logic between variables or values:

Java Bitwise Operators

Bitwise operators are used to perform binary logic with the bits of an integer or long integer.

Note: The Bitwise examples above use 4-bit unsigned examples, but Java uses 32-bit signed integers and 64-bit signed long integers. Because of this, in Java, ~5 will not return 10. It will return -6. ~00000000000000000000000000000101 will return 11111111111111111111111111111010

In Java, 9 >> 1 will not return 12. It will return 4. 00000000000000000000000000001001 >> 1 will return 00000000000000000000000000000100

Test Yourself With Exercises

Multiply 10 with 5 , and print the result.

Start the Exercise

COLOR PICKER

Contact Sales

If you want to use W3Schools services as an educational institution, team or enterprise, send us an e-mail: [email protected]

Report Error

If you want to report an error, or if you want to make a suggestion, send us an e-mail: [email protected]

Top Tutorials

Top references, top examples, get certified.

Java Assignment Operators

Java programming tutorial index.

The Java Assignment Operators are used when you want to assign a value to the expression. The assignment operator denoted by the single equal sign = .

In a Java assignment statement, any expression can be on the right side and the left side must be a variable name. For example, this does not mean that "a" is equal to "b", instead, it means assigning the value of 'b' to 'a'. It is as follows:

Java also has the facility of chain assignment operators, where we can specify a single value for multiple variables.

• Java - Home
• Java - Overview
• Java - History
• Java - Features
• Java vs C++
• Java Virtual Machine (JVM)
• Java - JDK vs JRE vs JVM
• Java - Hello World Program
• Java - Environment Setup
• Java - Basic Syntax
• Java - Variable Types
• Java - Data Types
• Java - Type Casting
• Java - Unicode System
• Java - Basic Operators
• Java - Comments
• Java - User Input
• Java - Date & Time

Java Control Statements

• Java - Loop Control
• Java - Decision Making
• Java - If-else
• Java - Switch
• Java - For Loops
• Java - For-Each Loops
• Java - While Loops
• Java - do-while Loops
• Java - Break
• Java - Continue

Object Oriented Programming

• Java - OOPs Concepts
• Java - Object & Classes
• Java - Class Attributes
• Java - Class Methods
• Java - Methods
• Java - Variables Scope
• Java - Constructors
• Java - Access Modifiers
• Java - Inheritance
• Java - Aggregation
• Java - Polymorphism
• Java - Overriding
• Java - Method Overloading
• Java - Dynamic Binding
• Java - Static Binding
• Java - Instance Initializer Block
• Java - Abstraction
• Java - Encapsulation
• Java - Interfaces
• Java - Packages
• Java - Inner Classes
• Java - Static Class
• Java - Anonymous Class
• Java - Singleton Class
• Java - Wrapper Classes
• Java - Enums
• Java - Enum Constructor
• Java - Enum Strings
• Java - Reflection

Java Built-in Classes

• Java - Number
• Java - Boolean
• Java - Characters
• Java - Strings
• Java - Arrays
• Java - Math Class

Java File Handling

• Java - Files
• Java - Create a File
• Java - Write to File
• Java - Read Files
• Java - Delete Files
• Java - Directories
• Java - I/O Streams

Java Error & Exceptions

• Java - Exceptions
• Java - try-catch Block
• Java - try-with-resources
• Java - Multi-catch Block
• Java - Nested try Block
• Java - Finally Block
• Java - throw Exception
• Java - Exception Propagation
• Java - Built-in Exceptions
• Java - Custom Exception
• Java - Annotations
• Java - Logging
• Java - Assertions

Java Multithreading

• Java - Multithreading
• Java - Thread Life Cycle
• Java - Creating a Thread
• Java - Starting a Thread
• Java - Joining Threads
• Java - Naming Thread
• Java - Thread Scheduler
• Java - Thread Pools
• Java - Main Thread
• Java - Thread Priority
• Java - Daemon Threads
• Java - Thread Group
• Java - Shutdown Hook

Java Synchronization

• Java - Synchronization
• Java - Block Synchronization
• Java - Static Synchronization
• Java - Inter-thread Communication
• Java - Thread Deadlock
• Java - Interrupting a Thread
• Java - Thread Control
• Java - Reentrant Monitor

Java Networking

• Java - Networking
• Java - Socket Programming
• Java - URL Processing
• Java - URL Class
• Java - URLConnection Class
• Java - HttpURLConnection Class
• Java - Socket Class
• Java - ServerSocket Class
• Java - InetAddress Class
• Java - Generics

Java Collections

• Java - Collections
• Java - Collection Interface

Java Interfaces

• Java - List Interface
• Java - Queue Interface
• Java - Map Interface
• Java - SortedMap Interface
• Java - Set Interface
• Java - SortedSet Interface

Java Data Structures

• Java - Data Structures
• Java - Enumeration

Java Collections Algorithms

• Java - Collections Algorithms
• Java - Iterators
• Java - Comparators
• Java - Comparable Interface in Java

Advanced Java

• Java - Command-Line Arguments
• Java - Lambda Expressions
• Java - Sending Email
• Java - Applet Basics
• Java - Javadoc Comments
• Java - Autoboxing and Unboxing
• Java - File Mismatch Method
• Java - REPL (JShell)
• Java - Multi-Release Jar Files
• Java - Private Interface Methods
• Java - Inner Class Diamond Operator
• Java - Multiresolution Image API
• Java - Collection Factory Methods
• Java - Module System
• Java - Nashorn JavaScript
• Java - Optional Class
• Java - Method References
• Java - Functional Interfaces
• Java - Default Methods
• Java - Base64 Encode Decode
• Java - Switch Expressions
• Java - Teeing Collectors
• Java - Microbenchmark
• Java - Text Blocks
• Java - Dynamic CDS archive
• Java - Z Garbage Collector (ZGC)
• Java - Null Pointer Exception
• Java - Packaging Tools
• Java - NUMA Aware G1
• Java - Sealed Classes
• Java - Record Classes
• Java - Hidden Classes
• Java - Pattern Matching
• Java - Compact Number Formatting
• Java - Programming Examples
• Java - Garbage Collection
• Java - JIT Compiler

Java Miscellaneous

• Java - Recursion
• Java - Regular Expressions
• Java - Serialization
• Java - Process API Improvements
• Java - Stream API Improvements
• Java - Enhanced @Deprecated Annotation
• Java - CompletableFuture API Improvements
• Java - Maths Methods
• Java - Streams
• Java - Datetime Api
• Java 8 - New Features
• Java 9 - New Features
• Java 10 - New Features
• Java 11 - New Features
• Java 12 - New Features
• Java 13 - New Features
• Java 14 - New Features
• Java 15 - New Features
• Java 16 - New Features
• Java - Keywords Reference

Java APIs & Frameworks

• JDBC Tutorial
• SWING Tutorial
• AWT Tutorial
• Servlets Tutorial
• JSP Tutorial

Java Class References

• Java - Scanner Class
• Java - Arrays Class
• Java - ArrayList
• Java - Vector Class
• Java - Stack Class
• Java - PriorityQueue
• Java - Deque Interface
• Java - LinkedList
• Java - ArrayDeque
• Java - HashMap
• Java - LinkedHashMap
• Java - WeakHashMap
• Java - EnumMap
• Java - TreeMap
• Java - The IdentityHashMap Class
• Java - HashSet
• Java - EnumSet
• Java - LinkedHashSet
• Java - TreeSet
• Java - BitSet Class
• Java - Dictionary
• Java - Hashtable
• Java - Properties
• Java - Array Methods

Java Useful Resources

• Java Compiler
• Java - Questions and Answers
• Java 8 - Questions and Answers
• Java - Quick Guide
• Java - Useful Resources
• Java - Discussion
• Java - Examples
• Selected Reading
• UPSC IAS Exams Notes
• Developer's Best Practices
• Questions and Answers
• Effective Resume Writing
• HR Interview Questions
• Computer Glossary

Java - Assignment Operators with Examples

Java assignment operators.

Following are the assignment operators supported by Java language −

The following programs are simple examples which demonstrate the assignment operators. Copy and paste the following Java programs as Test.java file, and compile and run the programs −

In this example, we're creating three variables a,b and c and using assignment operators . We've performed simple assignment, addition AND assignment, subtraction AND assignment and multiplication AND assignment operations and printed the results.

In this example, we're creating two variables a and c and using assignment operators . We've performed Divide AND assignment, Multiply AND assignment, Modulus AND assignment, bitwise exclusive OR AND assignment, OR AND assignment operations and printed the results.

In this example, we're creating two variables a and c and using assignment operators . We've performed Left shift AND assignment, Right shift AND assignment, operations and printed the results.

• TutorialKart
• SAP Tutorials
• Salesforce Admin
• Salesforce Developer
• Visualforce
• Informatica
• Kafka Tutorial
• Spark Tutorial
• Tomcat Tutorial
• Python Tkinter

Programming

• Bash Script
• Julia Tutorial
• CouchDB Tutorial
• MongoDB Tutorial
• PostgreSQL Tutorial
• Android Compose
• Flutter Tutorial
• Kotlin Android

Web & Server

• Selenium Java
• Java Basics
• Java Tutorial
• Java HelloWorld Program
• Java Program Structure
• Java Datatypes
• Java Variable Types
• Java Access Modifiers
• Java Operators
• Java Decision Making
• Print array
• Initialize array
• Array of integers
• Array of strings
• Array of objects
• Array of arrays
• Iterate over array
• Array For loop
• Array while loop
• Append element to array
• Check if array is empty
• Array average
• Check if array contains
• Array ForEach
• Array - Find Index of Item
• Concatenate arrays
• Find smallest number in array
• Find largest number in array
• Array reverse
• Classes and Objects
• Inheritance
• Polymorphism
• Method Overloading
• Method Overriding/
• Abstraction
• Abstract methods and classes
• Encapsulation
• Print string
• Read string from console
• Create string from Char array
• Create string from Byte array
• Concatenate two strings
• Get index of the first Occurrence of substring
• Get index of nth occurrence of substring
• Check if two strings are equal
• Check if string ends with specific suffix
• Check if string starts with specific prefix
• Check if string is blank
• Check if string is empty
• Check if string contains search substring
• Validate if string is a Phone Number
• Character Level
• Get character at specific index in string
• Get first character in string
• Get last character from string
• Transformations
• Replace first occurrence of string
• Replace all occurrences of a string
• Join strings
• Join strings in string array
• Join strings in ArrayList
• Reverse a string
• Trim string
• Split string
• Remove whitespaces in string
• Replace multiple spaces with single space
• Comparisons
• Compare strings lexicographically
• Compare String and CharSequence
• Compare String and StringBuffer
• Java Exception Handling StringIndexOutOfBoundsException
• Convert string to int
• Convert string to float
• Convert string to double
• Convert string to long
• Convert string to boolean
• Convert int to string
• Convert int to float
• Convert int to double
• Convert int to long
• Convert int to char
• Convert float to string
• Convert float to int
• Convert float to double
• Convert float to long
• Convert long to string
• Convert long to float
• Convert long to double
• Convert long to int
• Convert double to string
• Convert double to float
• Convert double to int
• Convert double to long
• Convert char to int
• Convert boolean to string
• Create a file
• Read file as string
• Write string to file
• Delete File
• Rename File
• Download File from URL
• Replace a String in File
• Filter list of files or directories
• Check if file is readable
• Check if file is writable
• Check if file is executable
• Read contents of a file line by line using BufferedReader
• Read contents of a File line by line using Stream
• Check if n is positive or negative
• Read integer from console
• Add two integers
• Count digits in number
• Largest of three numbers
• Smallest of three numbers
• Even numbers
• Odd numbers
• Reverse a number
• Prime Number
• Print All Prime Numbers
• Factors of a Number
• Check Palindrome number
• Check Palindrome string
• Swap two numbers
• Even or Odd number
• Java Classes
• ArrayList add()
• ArrayList addAll()
• ArrayList clear()
• ArrayList clone()
• ArrayList contains()
• ArrayList ensureCapacity()
• ArrayList forEach()
• ArrayList get()
• ArrayList indexOf()
• ArrayList isEmpty()
• ArrayList iterator()
• ArrayList lastIndexOf()
• ArrayList listIterator()
• ArrayList remove()
• ArrayList removeAll()
• ArrayList removeIf()
• ArrayList removeRange()
• ArrayList retainAll()
• ArrayList set()
• ArrayList size()
• ArrayList spliterator()
• ArrayList subList()
• ArrayList toArray()
• ArrayList trimToSize()
• HashMap clear()
• HashMap clone()
• HashMap compute()
• HashMap computeIfAbsent()
• HashMap computeIfPresent()
• HashMap containsKey()
• HashMap containsValue()
• HashMap entrySet()
• HashMap get()
• HashMap isEmpty()
• HashMap keySet()
• HashMap merge()
• HashMap put()
• HashMap putAll()
• HashMap remove()
• HashMap size()
• HashMap values()
• HashSet add()
• HashSet clear()
• HashSet clone()
• HashSet contains()
• HashSet isEmpty()
• HashSet iterator()
• HashSet remove()
• HashSet size()
• HashSet spliterator()
• Integer bitCount()
• Integer byteValue()
• Integer compare()
• Integer compareTo()
• Integer compareUnsigned()
• Integer decode()
• Integer divideUnsigned()
• Integer doubleValue()
• Integer equals()
• Integer floatValue()
• Integer getInteger()
• Integer hashCode()
• Integer highestOneBit()
• Integer intValue()
• Integer longValue()
• Integer lowestOneBit()
• Integer max()
• Integer min()
• Integer numberOfLeadingZeros()
• Integer numberOfTrailingZeros()
• Integer parseInt()
• Integer parseUnsignedInt()
• Integer remainderUnsigned()
• Integer reverse()
• Integer reverseBytes()
• Integer rotateLeft()
• Integer rotateRight()
• Integer shortValue()
• Integer signum()
• Integer sum()
• Integer toBinaryString()
• Integer toHexString()
• Integer toOctalString()
• Integer toString()
• Integer toUnsignedLong()
• Integer toUnsignedString()
• Integer valueOf()
• StringBuilder append()
• StringBuilder appendCodePoint()
• StringBuilder capacity()
• StringBuilder charAt()
• StringBuilder chars()
• StringBuilder codePointAt()
• StringBuilder codePointBefore()
• StringBuilder codePointCount()
• StringBuilder codePoints()
• StringBuilder delete()
• StringBuilder deleteCharAt()
• StringBuilder ensureCapacity()
• StringBuilder getChars()
• StringBuilder indexOf()
• StringBuilder insert()
• StringBuilder lastIndexOf()
• StringBuilder length()
• StringBuilder offsetByCodePoints()
• StringBuilder replace()
• StringBuilder reverse()
• StringBuilder setCharAt()
• StringBuilder setLength()
• StringBuilder subSequence()
• StringBuilder substring()
• StringBuilder toString()
• StringBuilder trimToSize()
• Arrays.asList()
• Arrays.binarySearch()
• Arrays.copyOf()
• Arrays.copyOfRange()
• Arrays.deepEquals()
• Arrays.deepToString()
• Arrays.equals()
• Arrays.fill()
• Arrays.hashCode()
• Arrays.sort()
• Arrays.toString()
• Random doubles()
• Random ints()
• Random longs()
• Random next()
• Random nextBoolean()
• Random nextBytes()
• Random nextDouble()
• Random nextFloat()
• Random nextGaussian()
• Random nextInt()
• Random nextLong()
• Random setSeed()
• Math random
• Math signum
• Math toDegrees
• Math toRadians
• Java Date & Time
• ❯ Java Tutorial

Java Assignment Operators

Java Assignment Operators are used to optionally perform an action with given operands and assign the result back to given variable (left operand).

The syntax of any Assignment Operator with operands is

In this tutorial, we will learn about different Assignment Operators available in Java programming language and go through each of these Assignment Operations in detail, with the help of examples.

Operator Symbol – Example – Description

The following table specifies symbol, example, and description for each of the Assignment Operator in Java.

Simple Assignment

In the following example, we assign a value of 2 to x using Simple Assignment Operator.

Addition Assignment

In the following example, we add 3 to x and assign the result to x using Addition Assignment Operator.

Subtraction Assignment

In the following example, we subtract 3 from x and assign the result to x using Subtraction Assignment Operator.

Multiplication Assignment

In the following example, we multiply 3 to x and assign the result to x using Multiplication Assignment Operator.

Division Assignment

In the following example, we divide x by 3 and assign the quotient to x using Division Assignment Operator.

Remainder Assignment

In the following example, we divide x by 3 and assign the remainder to x using Remainder Assignment Operator.

Bitwise AND Assignment

In the following example, we do bitwise AND operation between x and 3 and assign the result to x using Bitwise AND Assignment Operator.

Bitwise OR Assignment

In the following example, we do bitwise OR operation between x and 3 and assign the result to x using Bitwise OR Assignment Operator.

Bitwise XOR Assignment

In the following example, we do bitwise XOR operation between x and 3 and assign the result to x using Bitwise XOR Assignment Operator.

Left-shift Assignment

In the following example, we left-shift x by 3 places and assign the result to x using Left-shift Assignment Operator.

Right-shift Assignment

In the following example, we right-shift x by 3 places and assign the result to x using Right-shift Assignment Operator.

In this Java Tutorial , we learned what Assignment Operators are, and how to use them in Java programs, with the help of examples.

Popular Courses by TutorialKart

App developement, web development, online tools.

The Java Tutorials have been written for JDK 8. Examples and practices described in this page don't take advantage of improvements introduced in later releases and might use technology no longer available. See Java Language Changes for a summary of updated language features in Java SE 9 and subsequent releases. See JDK Release Notes for information about new features, enhancements, and removed or deprecated options for all JDK releases.

Assignment, Arithmetic, and Unary Operators

The simple assignment operator.

One of the most common operators that you'll encounter is the simple assignment operator " = ". You saw this operator in the Bicycle class; it assigns the value on its right to the operand on its left:

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

The Arithmetic Operators

The Java programming language 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.

The following program, ArithmeticDemo , tests the arithmetic operators.

This program prints the following:

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 together, as shown in the following ConcatDemo program:

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, or inverting the value of a boolean.

The following program, UnaryDemo , tests the unary operators:

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 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 , illustrates the prefix/postfix unary increment operator:

About Oracle | Contact Us | Legal Notices | Terms of Use | Your Privacy Rights

Copyright © 1995, 2022 Oracle and/or its affiliates. All rights reserved.

• C Programming
• Java Programming
• Data Structures
• Web Development
• Tech Interview

Java's Basic and Shorthand Assignment Operators

Reference assignment, primitive assignment, primitive casting, shorthand assignment operators, basic assignment operator.

Java's basic assignment operator is a single equals-to (=) sign that assigns the right-hand side value to the left-hand side operand. On left side of the assignment operator there must be a variable that can hold the value assigned to it. Assignment operator operates on both primitive and reference types. It has the following syntax: var = expression; Note that the type of var must be compatible with the type of expression .

Chaining of assignment operator is also possible where we can create a chain of assignments in order to assign a single value to multiple variables. For example,

The above piece of code sets the variables x, y, and z to 100 using a single statement. This works because the = is an operator that yields the value of the right-hand expression. Thus, the value of z = 100 is 100, which is then assigned to y , which in turn is assigned to x . Using a "chain of assignment" is an easy way to set a group of variables to a common value.

A variable referring to an object is a reference variable not an object. We can assign a newly created object to an object reference variable as follows:

The above line of code performs three tasks

• Creates a reference variable named st1 , of type Student .
• Creates a new Student object on the heap.
• Assigns the newly created Student object to the reference variable st1

We can also assign null to an object reference variable, which simply means the variable is not referring to any object:

Above line of code creates space for the Student reference variable st2 but doesn't create an actual Student object.

Note that, we can also use a reference variable to refer to any object that is a subclass of the declared reference variable type.

Primitive variables can be assigned either by using a literal or the result of an expression. For example,

The most important point that we should keep in mind, while assigning primitive types is if we are going to assign a bigger value to a smaller type, we have to typecast it properly. In Above piece of code the literal integer 130 is implicitly an int but it is acceptable here because the variable x is of type int . It gets weird if you try 130 to assign to a byte variable. For example, The below piece of code will not compile because literal 130 is implicitly an integer and it does not fit into a smaller type byte x . Likewise, byte c = a + b will also not compile because the result of an expression involving anything int-sized or smaller is always an int .

Casting lets us convert primitive values from one type to another (specially from bigger to smaller types). Casts can be implicit or explicit. An implicit cast means we don't have to write code for the cast; the conversion happens automatically. Typically, an implicit cast happens when we do a widening conversion. In other words, putting a smaller thing (say, a byte ) into a bigger container (like an int ). Remember those "possible loss of precision" compiler errors we saw during assignments. Those happened when we tried to put a larger thing (say, an int ) into a smaller container (like a byte ). The large-value-into-small-container conversion is referred to as narrowing and requires an explicit cast, where we tell the compiler that we are aware of the danger and accept full responsibility.

As a final note on casting, it is very important to note that the shorthand assignment operators let us perform addition, subtraction, multiplication or division without putting in an explicit cast. In fact, +=, -=, *=, and /= will all put in an implicit cast. Below is an example:

In addition to the basic assignment operator, Java also defines 12 shorthand assignment operators that combine assignment with the 5 arithmetic operators ( += , -= , *= , /= , %= ) and the 6 bitwise and shift operators ( &= , |= , ^= , <<= , >>= , >>>= ). For example, the += operator reads the value of the left variable, adds the value of the right operand to it, stores the sum back into the left variable as a side effect, and returns the sum as the value of the expression. Thus, the expression x += 2 is almost the same x = x + 2 .

The difference between these two expressions is that when we use the += operator, the left operand is evaluated only once. This makes a difference when that operand has a side effect. Consider the following two expressions a[i++] += 2; and a[i++] = a[i++] + 2; , which are not equivalent:

In this tutorial we discussed basic and shorthand (compound) assignment operators of Java. Hope you have enjoyed reading this tutorial. Please do write us if you have any suggestion/comment or come across any error on this page. Thanks for reading!

• Core Java Volume I - Fundamentals
• Java: The Complete Reference, Seventh Edition
• Operators: Sun tutorial
• Bit Twiddling Hacks
• C Programming Tutorials
• Java Programming Tutorials
• Data Structures Tutorials
• All Tech Interview Questions
• C Interview Question Answers
• Java Interview Question Answers
• DSA Interview Question Answers

Get Free Tutorials by Email

About the Author

Krishan Kumar is the founder and main contributor for cs-fundamentals.com. He is a software professional (post graduated from BITS-Pilani) and loves writing technical articles on programming and data structures.

Today's Tech News

• Write For Us

Java Assignment Operators

Java Assignment Operators example

• Java Operators

Last updated: January 8, 2024

Get non-trivial analysis (and trivial, too!) suggested right inside your IDE or Git platform so you can code smart, create more value, and stay confident when you push.

Get CodiumAI for free and become part of a community of over 280,000 developers who are already experiencing improved and quicker coding.

Write code that works the way you meant it to:

>> CodiumAI. Meaningful Code Tests for Busy Devs

Java applications have a notoriously slow startup and a long warmup time. The CRaC (Coordinated Restore at Checkpoint) project from OpenJDK can help improve these issues by creating a checkpoint with an application's peak performance and restoring an instance of the JVM to that point.

To take full advantage of this feature, BellSoft provides containers that are highly optimized for Java applications. These package Alpaquita Linux (a full-featured OS optimized for Java and cloud environment) and Liberica JDK (an open-source Java runtime based on OpenJDK).

These ready-to-use images allow us to easily integrate CRaC in a Spring Boot application:

Improve Java application performance with CRaC support

Modern software architecture is often broken. Slow delivery leads to missed opportunities, innovation is stalled due to architectural complexities, and engineering resources are exceedingly expensive.

Orkes is the leading workflow orchestration platform built to enable teams to transform the way they develop, connect, and deploy applications, microservices, AI agents, and more.

With Orkes Conductor managed through Orkes Cloud, developers can focus on building mission critical applications without worrying about infrastructure maintenance to meet goals and, simply put, taking new products live faster and reducing total cost of ownership.

Try a 14-Day Free Trial of Orkes Conductor today.

Azure Container Apps is a fully managed serverless container service that enables you to build and deploy modern, cloud-native Java applications and microservices at scale. It offers a simplified developer experience while providing the flexibility and portability of containers.

Of course, Azure Container Apps has really solid support for our ecosystem, from a number of build options, managed Java components, native metrics, dynamic logger, and quite a bit more.

To learn more about Java features on Azure Container Apps, you can get started over on the documentation page .

And, you can also ask questions and leave feedback on the Azure Container Apps GitHub page .

Whether you're just starting out or have years of experience, Spring Boot is obviously a great choice for building a web application.

Jmix builds on this highly powerful and mature Boot stack, allowing devs to build and deliver full-stack web applications without having to code the frontend. Quite flexibly as well, from simple web GUI CRUD applications to complex enterprise solutions.

Concretely, The Jmix Platform includes a framework built on top of Spring Boot, JPA, and Vaadin , and comes with Jmix Studio, an IntelliJ IDEA plugin equipped with a suite of developer productivity tools.

The platform comes with interconnected out-of-the-box add-ons for report generation, BPM, maps, instant web app generation from a DB, and quite a bit more:

>> Become an efficient full-stack developer with Jmix

DbSchema is a super-flexible database designer, which can take you from designing the DB with your team all the way to safely deploying the schema .

The way it does all of that is by using a design model , a database-independent image of the schema, which can be shared in a team using GIT and compared or deployed on to any database.

And, of course, it can be heavily visual, allowing you to interact with the database using diagrams, visually compose queries, explore the data, generate random data, import data or build HTML5 database reports.

>> Take a look at DBSchema

Do JSON right with Jackson

Download the E-book

Get the most out of the Apache HTTP Client

Get Started with Apache Maven:

Working on getting your persistence layer right with Spring?

Explore the eBook

Building a REST API with Spring?

Get started with Spring and Spring Boot, through the Learn Spring course:

Explore Spring Boot 3 and Spring 6 in-depth through building a full REST API with the framework:

>> REST With Spring (new)

Get started with Spring and Spring Boot, through the reference Learn Spring course:

>> LEARN SPRING

The AI Assistant to boost Boost your productivity writing unit tests - Machinet AI .

AI is all the rage these days, but for very good reason. The highly practical coding companion, you'll get the power of AI-assisted coding and automated unit test generation . Machinet's Unit Test AI Agent utilizes your own project context to create meaningful unit tests that intelligently aligns with the behavior of the code. And, the AI Chat crafts code and fixes errors with ease, like a helpful sidekick.

Simplify Your Coding Journey with Machinet AI :

>> Install Machinet AI in your IntelliJ

Yes, Spring Security can be complex, from the more advanced functionality within the Core to the deep OAuth support in the framework.

I built the security material as two full courses - Core and OAuth , to get practical with these more complex scenarios. We explore when and how to use each feature and code through it on the backing project .

You can explore the course here:

>> Learn Spring Security

Spring Data JPA is a great way to handle the complexity of JPA with the powerful simplicity of Spring Boot .

Get started with Spring Data JPA through the guided reference course:

>> CHECK OUT THE COURSE

Get started with Spring Boot and with core Spring, through the Learn Spring course:

1. Overview

Operators are a fundamental building block of any programming language. We use operators to perform operations on values and variables.

Java provides many groups of operators. They are categorized by their functionalities.

In this tutorial, we’ll walk through all Java operators to understand their functionalities and how to use them.

2. Arithmetic Operators

We use arithmetic operators to perform simple mathematical operations. We should note that arithmetic operators only work with primitive number types and their boxed types , such as int and  Integer .

Next, let’s see what operators we have in the arithmetic operator group.

2.1. The Addition Operator

The addition operator (+) allows us to add two values or concatenate two strings:

2.2. The Subtraction Operator

Usually, we use the subtraction operator (-) to subtract one value from another:

2.3. The Multiplication Operator

The multiplication operator (*) is used to multiply two values or variables:

2.4. The Division Operator

The division operator (/) allows us to divide the left-hand value by the right-hand one:

When we use the division operator on two integer values ( byte , short , int , and long ), we should note that the result is the quotient value. The remainder is not included .

As the example above shows, if we calculate 15 / 2 , the quotient is 7, and the remainder is 1 . Therefore, we have 15 / 2 = 7 .

2.5. The Modulo Operator

We can get the quotient using the division operator. However, if we just want to get the remainder of a division calculation, we can use the modulo operator (%):

3. Unary Operators

As the name implies, unary operators only require one single operand . For example, we usually use unary operators to increment, decrement, or negate a variable or value.

Now, let’s see the details of unary operators in Java.

3.1. The Unary Plus Operator

The unary plus operator (+) indicates a positive value. If the number is positive, we can omit the ‘+’ operator:

3.2. The Unary Minus Operator

Opposite to the unary plus operator, the unary minus operator (-) negates a value or an expression:

3.3. The Logical Complement Operator

The logical complement operator (!) is also known as the “NOT” operator . We can use it to invert the value of a boolean variable or value:

3.4. The Increment Operator

The increment operator (++) allows us to increase the value of a variable by 1:

3.5. The Decrement Opeartor

The decrement operator (–) does the opposite of the increment operator. It decreases the value of a variable by 1:

We should keep in mind that the increment and decrement operators can only be used on a variable . For example, “ int a = 5; a++; ” is fine. However, the expression “ 5++ ” won’t be compiled.

4. Relational Operators

Relational operators can be called “comparison operators” as well. Basically, we use these operators to compare two values or variables.

4.1. The “Equal To” Operator

We use the “equal to” operator (==) to compare the values on both sides. If they’re equal, the operation returns true :

The “equal to” operator is pretty straightforward. On the other hand, the Object class has provided the equals() method. As the Object class is the superclass of all Java classes, all Java objects can use the equals() method to compare each other.

When we want to compare two objects – for instance, when we compare Long objects or compare String s –  we should choose between the comparison method from the equals() method and that of the “equal to” operator wisely .

4.2. The “Not Equal To” Operator

The “not equal to” operator (!=) does the opposite of the ‘==’ operator. If the values on both sides are not equal, the operation returns true :

4.3. The “Greater Than” Operator

When we compare two values with the “greater than” operator (>), it returns true if the value on the left-hand side is greater than the value on the right-hand side:

4.4. The “Greater Than or Equal To” Operator

The “greater than or equal to” operator (>=) compares the values on both sides and returns true if the left-hand side operand is greater than or equal to the right-hand side operand:

4.5. The “Less Than” Operator

The “less than” operator (<) compares two values on both sides and returns true if the value on the left-hand side is less than the value on the right-hand side:

4.6. The “Less Than or Equal To” Operator

Similarly, the “less than or equal to” operator (<=) compares the values on both sides and returns true if the left-hand side operand is less than or equal to the right-hand side:

5. Logical Operators

We have two logical operators in Java: the logical AND and OR operators. Basically, their function is pretty similar to the AND gate and the OR gate in digital electronics.

Usually, we use a logical operator with two operands, which are variables or expressions that can be evaluated as boolean .

Next, let’s take a closer look at them.

5.1. The Logical AND Operator

The logical AND operator ( && ) returns true only if both operands are true :

5.2. The Logical OR Operator

Unlike the ‘ && ‘ operator, the logical OR operator ( || ) returns true if at least one operand is  true :

We should note that the logical OR operator has the short-circuiting effect : It returns true as soon as one of the operands is evaluated as true, without evaluating the remaining operands.

6. Ternary Operator

A ternary operator is a short form of the if-then-else statement. It has the name ternary as it has three operands. First, let’s have a look at the standard if-then-else statement syntax:

We can convert the above if-then-else statement into a compact version using the ternary operator:

Let’s look at its syntax:

Next, let’s understand how the ternary operator works through a simple example:

7. Bitwise and Bit Shift Operators

As the article “ Java bitwise operators ” covers the details of bitwise and bit shift operators, we’ll briefly summarize these operators in this tutorial.

7.1. The Bitwise AND Operator

The bitwise AND operator (&) returns the bit-by-bit AND of input values:

7.2. The Bitwise OR Operator

The bitwise OR operator (|) returns the bit-by-bit OR of input values:

7.3. The Bitwise XOR Operator

The bitwise XOR (exclusive OR) operator (^) returns the bit-by-bit XOR of input values:

7.4. The Bitwise Complement Operator

The bitwise complement operator (~) is a unary operator. It returns the value’s complement representation, which inverts all bits from the input value:

7.5. The Left Shift Operator

Shift operators shift the bits to the left or right by the given number of times.

The left shift operator (<<) shifts the bits to the left by the number of times defined by the right-hand side operand. After the left shift, the empty space in the right is filled with 0.

Next, let’s left shift the number 12 twice:

n << x has the same effect of multiplying the number  n  with x power of two.

7.6. The Signed Right Shift Operator

The signed right shift operator (>>) shifts the bits to the right by the number of times defined by the right-hand side operand and fills 0 on voids left as a result.

We should note that the leftmost position after the shifting depends on the sign extension .

Next, let’s do “signed right shift” twice on the numbers 12 and -12 to see the difference:

As the second example above shows, if the number is negative, the leftmost position after each shift will be set by the sign extension.

n >> x has the same effect of dividing the number n by x power of two.

7.7. The Unsigned Right Shift Operator

The unsigned right shift operator (>>>) works in a similar way as the ‘>>’ operator. The only difference is that after a shift, the leftmost bit is set to 0 .

Next, let’s unsigned right shift twice on the numbers 12 and -12 to see the difference:

As we can see in the second example above, the >>> operator fills voids on the left with 0 irrespective of whether the number is positive or negative .

8. The “ instanceof ” Operator

Sometimes, when we have an object, we would like to test if it’s an instance of a given type . The “ instanceof ” operator can help us to do it:

9. Assignment Operators

We use assignment operators to assign values to variables. Next, let’s see which assignment operators we can use in Java.

9.1. The Simple Assignment Operator

The simple assignment operator (=) is a straightforward but important operator in Java. Actually, we’ve used it many times in previous examples. It assigns the value on its right to the operand on its left:

9.2. Compound Assignments

We’ve learned arithmetic operators. We can combine the arithmetic operators with the simple assignment operator to create compound assignments.

For example, we can write “ a = a + 5 ” in a compound way: “ a += 5 “.

Finally, let’s walk through all supported compound assignments in Java through examples:

10. Conclusion

Java provides many groups of operators for different functionalities. In this article, we’ve passed through the operators in Java.

Slow MySQL query performance is all too common. Of course it is.

The Jet Profiler was built entirely for MySQL , so it's fine-tuned for it and does advanced everything with relaly minimal impact and no server changes.

>> Try out the Profiler

Looking for the ideal Linux distro for running modern Spring apps in the cloud?

Meet Alpaquita Linux : lightweight, secure, and powerful enough to handle heavy workloads.

This distro is specifically designed for running Java apps . It builds upon Alpine and features significant enhancements to excel in high-density container environments while meeting enterprise-grade security standards.

Specifically, the container image size is ~30% smaller than standard options, and it consumes up to 30% less RAM:

>> Try Alpaquita Containers now.

Just published a new writeup on how to run a standard Java/Boot application as a Docker container, using the Liberica JDK on top of Alpaquita Linux:

>> Spring Boot Application on Liberica Runtime Container.

Explore the secure, reliable, and high-performance Test Execution Cloud built for scale. Right in your IDE:

Basically, write code that works the way you meant it to.

AI is all the rage these days, but for very good reason. The highly practical coding companion, you'll get the power of AI-assisted coding and automated unit test generation . Machinet's Unit Test AI Agent utilizes your own project context to create meaningful unit tests that intelligently aligns with the behavior of the code.

JavaScript disabled. A lot of the features of the site won't work. Find out how to turn on JavaScript  HERE .

• Fundamentals
• Objects & Classes
• OO Concepts
• API Contents
• Input & Output
• Collections
• Concurrency
• Swing & RMI
• Certification

Assignment Operators J8 Home   «   Assignment Operators

• <<    Relational & Logical Operators
• Bitwise Logical Operators     >>

Symbols used for mathematical and logical manipulation that are recognized by the compiler are commonly known as operators in Java. In the third of five lessons on operators we look at the assignment operators available in Java.

Assignment Operators Overview  Top

The single equal sign = is used for assignment in Java and we have been using this throughout the lessons so far. This operator is fairly self explanatory and takes the form variable = expression; . A point to note here is that the type of variable must be compatible with the type of expression .

Shorthand Assignment Operators

The shorthand assignment operators allow us to write compact code that is implemented more efficiently.

Automatic Type Conversion, Assignment Rules  Top

The following table shows which types can be assigned to which other types, of course we can assign to the same type so these boxes are greyed out.

When using the table use a row for the left assignment and a column for the right assignment. So in the highlighted permutations byte = int won't convert and int = byte will convert.

Casting Incompatible Types  Top

The above table isn't the end of the story though as Java allows us to cast incompatible types. A cast instructs the compiler to convert one type to another enforcing an explicit type conversion.

A cast takes the form     target = (target-type) expression .

There are a couple of things to consider when casting incompatible types:

• With narrowing conversions such as an int to a short there may be a loss of precision if the range of the int exceeds the range of a short as the high order bits will be removed.
• When casting a floating-point type to an integer type the fractional component is lost through truncation.
• The target-type can be the same type as the target or a narrowing conversion type.
• The boolean type is not only incompatible but also inconvertible with other types.

Lets look at some code to see how casting works and the affect it has on values:

Running the Casting class produces the following output:

The first thing to note is we got a clean compile because of the casts, all the type conversions would fail otherwise. You might be suprised by some of the results shown in the screenshot above, for instance some of the values have become negative. Because we are truncating everything to a byte we are losing not only any fractional components and bits outside the range of a byte , but in some cases the signed bit as well. Casting can be very useful but just be aware of the implications to values when you enforce explicit type conversion.

Related Quiz

Fundamentals Quiz 8 - Assignment Operators Quiz

Lesson 9 Complete

In this lesson we looked at the assignment operators used in Java.

What's Next?

In the next lesson we look at the bitwise logical operators used in Java.

Getting Started

Code structure & syntax, java variables, primitives - boolean & char data types, primitives - numeric data types, method scope, arithmetic operators, relational & logical operators, assignment operators, assignment operators overview, automatic type conversion, casting incompatible types, bitwise logical operators, bitwise shift operators, if construct, switch construct, for construct, while construct.

Java 8 Tutorials

• Basics of Java
• ➤ Java Introduction
• ➤ History of Java
• ➤ Getting started with Java
• ➤ What is Path and Classpath
• ➤ Checking Java installation and Version
• ➤ Syntax in Java
• ➤ My First Java Program
• ➤ Basic terms in Java Program
• ➤ Runtime and Compile time
• ➤ What is Bytecode
• ➤ Features of Java
• ➤ What is JDK JRE and JVM
• ➤ Basic Program Examples
• Variables and Data Types
• ➤ What is Variable
• ➤ Types of Java Variables
• ➤ Naming conventions for Identifiers
• ➤ Data Type in Java
• ➤ Mathematical operators in Java
• ➤ Assignment operator in Java
• ➤ Arithmetic operators in Java
• ➤ Unary operators in Java
• ➤ Conditional and Relational Operators
• ➤ Bitwise and Bit Shift Operators
• ➤ Operator Precedence
• ➤ Overflow Underflow Widening Narrowing
• ➤ Variable and Data Type Programs
• Control flow Statements
• ➤ Java if and if else Statement
• ➤ else if and nested if else Statement
• ➤ Java for Loop
• ➤ Java while and do-while Loop
• ➤ Nested loops
• ➤ Java break Statement
• ➤ Java continue and return Statement
• ➤ Java switch Statement
• ➤ Control Flow Program Examples
• Array and String in Java
• ➤ Array in Java
• ➤ Multi-Dimensional Arrays
• ➤ for-each loop in java
• ➤ Java String
• ➤ Useful Methods of String Class
• ➤ StringBuffer and StringBuilder
• ➤ Array and String Program Examples
• Classes and Objects
• ➤ Classes in Java
• ➤ Objects in Java
• ➤ Methods in Java
• ➤ Constructors in Java
• ➤ static keyword in Java
• ➤ Call By Value
• ➤ Inner/nested classes in Java
• ➤ Wrapper Classes
• ➤ Enum in Java
• ➤ Initializer blocks
• ➤ Method Chaining and Recursion
• Packages and Interfaces
• ➤ What is package
• ➤ Sub packages in java
• ➤ built-in packages in java
• ➤ Import packages
• ➤ Access modifiers
• ➤ Interfaces in Java
• ➤ Key points about Interfaces
• ➤ New features in Interfaces
• ➤ Nested Interfaces
• ➤ Structure of Java Program
• OOPS Concepts
• ➤ What is OOPS
• ➤ Inheritance in Java
• ➤ Inheritance types in Java
• ➤ Abstraction in Java
• ➤ Encapsulation in Java
• ➤ Polymorphism in Java
• ➤ Runtime and Compile-time Polymorphism
• ➤ Method Overloading
• ➤ Method Overriding
• ➤ Overloading and Overriding Differences
• ➤ Overriding using Covariant Return Type
• ➤ this keyword in Java
• ➤ super keyword in Java
• ➤ final keyword in Java

Assignment Operator in Java with Example

Assignment operator is one of the simplest and most used operator in java programming language. As the name itself suggests, the assignment operator is used to assign value inside a variable. In java we can divide assignment operator in two types :

• Assignment operator or simple assignment operator
• Compound assignment operators

What is assignment operator in java

The = operator in java is known as assignment or simple assignment operator. It assigns the value on its right side to the operand(variable) on its left side. For example :

The left-hand side of an assignment operator must be a variable while the right side of it should be a value which can be in the form of a constant value, a variable name, an expression, a method call returning a compatible value or a combination of these.

The value at right side of assignment operator must be compatible with the data type of left side variable, otherwise compiler will throw compilation error. Following are incorrect assignment :

Another important thing about assignment operator is that, it is evaluated from right to left . If there is an expression at right side of assignment operator, it is evaluated first then the resulted value is assigned in left side variable.

Here in statement int x = a + b + c; the expression a + b + c is evaluated first, then the resulted value( 60 ) is assigned into x . Similarly in statement a = b = c , first the value of c which is 30 is assigned into b and then the value of b which is now 30 is assigned into a .

The variable at left side of an assignment operator can also be a non-primitive variable. For example if we have a class MyFirstProgram , we can assign object of MyFirstProgram class using = operator in MyFirstProgram type variable.

Is == an assignment operator ?

No , it's not an assignment operator, it's a relational operator used to compare two values.

Is assignment operator a binary operator

Yes , as it requires two operands.

Assignment operator program in Java

a = 2 b = 2 c = 4 d = 4 e = false

Java compound assignment operators

The assignment operator can be mixed or compound with other operators like addition, subtraction, multiplication etc. We call such assignment operators as compound assignment operator. For example :

Here the statement a += 10; is the short version of a = a + 10; the operator += is basically addition compound assignment operator. Similarly b *= 5; is short version of b = b * 5; the operator *= is multiplication compound assignment operator. The compound assignment can be in more complex form as well, like below :

List of all assignment operators in Java

The table below shows the list of all possible assignment(simple and compound) operators in java. Consider a is an integer variable for this table.

How many assignment operators are there in Java ?

Including simple and compound assignment we have total 12 assignment operators in java as given in above table.

What is shorthand operator in Java ?

Shorthand operators are nothing new they are just a shorter way to write something that is already available in java language. For example the code a += 5 is shorter way to write a = a + 5 , so += is a shorthand operator. In java all the compound assignment operator(given above) and the increment/decrement operators are basically shorthand operators.

Compound assignment operator program in Java

a = 20 b = 80 c = 30 s = 64 s2 = 110 b2 = 15

What is the difference between += and =+ in Java?

An expression a += 1 will result as a = a + 1 while the expression a =+ 1 will result as a = +1 . The correct compound statement is += , not =+ , so do not use the later one.

Learn Java practically and Get Certified .

Popular Tutorials

Popular examples, reference materials, learn java interactively, java introduction.

• Get Started With Java
• Your First Java Program
• Java Comments

Java Fundamentals

• Java Variables and Literals
• Java Data Types (Primitive)

Java Operators

• Java Basic Input and Output
• Java Expressions, Statements and Blocks

Java Flow Control

• Java if...else Statement

Java Ternary Operator

• Java for Loop
• Java for-each Loop
• Java while and do...while Loop
• Java break Statement
• Java continue Statement
• Java switch Statement
• Java Arrays
• Java Multidimensional Arrays
• Java Copy Arrays

Java OOP(I)

• Java Class and Objects
• Java Methods
• Java Method Overloading
• Java Constructors
• Java Static Keyword
• Java Strings
• Java Access Modifiers
• Java this Keyword
• Java final keyword
• Java Recursion

Java instanceof Operator

Java OOP(II)

• Java Inheritance
• Java Method Overriding
• Java Abstract Class and Abstract Methods
• Java Interface
• Java Polymorphism
• Java Encapsulation

Java OOP(III)

• Java Nested and Inner Class
• Java Nested Static Class
• Java Anonymous Class
• Java Singleton Class
• Java enum Constructor
• Java enum Strings
• Java Reflection
• Java Package
• Java Exception Handling
• Java Exceptions
• Java try...catch
• Java throw and throws
• Java catch Multiple Exceptions
• Java try-with-resources
• Java Annotations
• Java Annotation Types
• Java Logging
• Java Assertions
• Java Collections Framework
• Java Collection Interface
• Java ArrayList
• Java Vector
• Java Stack Class
• Java Queue Interface
• Java PriorityQueue
• Java Deque Interface
• Java LinkedList
• Java ArrayDeque
• Java BlockingQueue
• Java ArrayBlockingQueue
• Java LinkedBlockingQueue
• Java Map Interface
• Java HashMap
• Java LinkedHashMap
• Java WeakHashMap
• Java EnumMap
• Java SortedMap Interface
• Java NavigableMap Interface
• Java TreeMap
• Java ConcurrentMap Interface
• Java ConcurrentHashMap
• Java Set Interface
• Java HashSet Class
• Java EnumSet
• Java LinkedHashSet
• Java SortedSet Interface
• Java NavigableSet Interface
• Java TreeSet
• Java Algorithms
• Java Iterator Interface
• Java ListIterator Interface

Java I/o Streams

• Java I/O Streams
• Java InputStream Class
• Java OutputStream Class
• Java FileInputStream Class
• Java FileOutputStream Class
• Java ByteArrayInputStream Class
• Java ByteArrayOutputStream Class
• Java ObjectInputStream Class
• Java ObjectOutputStream Class
• Java BufferedInputStream Class
• Java BufferedOutputStream Class
• Java PrintStream Class

Java Reader/Writer

• Java File Class
• Java Reader Class
• Java Writer Class
• Java InputStreamReader Class
• Java OutputStreamWriter Class
• Java FileReader Class
• Java FileWriter Class
• Java BufferedReader
• Java BufferedWriter Class
• Java StringReader Class
• Java StringWriter Class
• Java PrintWriter Class

Additional Topics

• Java Keywords and Identifiers

Java Operator Precedence

Java Bitwise and Shift Operators

• Java Scanner Class
• Java Type Casting
• Java Wrapper Class
• Java autoboxing and unboxing
• Java Lambda Expressions
• Java Generics
• Nested Loop in Java
• Java Command-Line Arguments

Java Tutorials

• Java Math IEEEremainder()

Operators are symbols that perform operations on variables and values. For example, + is an operator used for addition, while * is also an operator used for multiplication.

Operators in Java can be classified into 5 types:

• Arithmetic Operators
• Assignment Operators
• Relational Operators
• Logical Operators
• Unary Operators
• Bitwise Operators

1. Java Arithmetic Operators

Arithmetic operators are used to perform arithmetic operations on variables and data. For example,

Here, the + operator is used to add two variables a and b . Similarly, there are various other arithmetic operators in Java.

Example 1: Arithmetic Operators

In the above example, we have used + , - , and * operators to compute addition, subtraction, and multiplication operations.

/ Division Operator

Note the operation, a / b in our program. The / operator is the division operator.

If we use the division operator with two integers, then the resulting quotient will also be an integer. And, if one of the operands is a floating-point number, we will get the result will also be in floating-point.

% Modulo Operator

The modulo operator % computes the remainder. When a = 7 is divided by b = 4 , the remainder is 3 .

Note : The % operator is mainly used with integers.

2. Java Assignment Operators

Assignment operators are used in Java to assign values to variables. For example,

Here, = is the assignment operator. It assigns the value on its right to the variable on its left. That is, 5 is assigned to the variable age .

Let's see some more assignment operators available in Java.

Example 2: Assignment Operators

3. java relational operators.

Relational operators are used to check the relationship between two operands. For example,

Here, < operator is the relational operator. It checks if a is less than b or not.

It returns either true or false .

Example 3: Relational Operators

Note : Relational operators are used in decision making and loops.

4. Java Logical Operators

Logical operators are used to check whether an expression is true or false . They are used in decision making.

Example 4: Logical Operators

Working of Program

• (5 > 3) && (8 > 5) returns true because both (5 > 3) and (8 > 5) are true .
• (5 > 3) && (8 < 5) returns false because the expression (8 < 5) is false .
• (5 < 3) || (8 > 5) returns true because the expression (8 > 5) is true .
• (5 > 3) || (8 < 5) returns true because the expression (5 > 3) is true .
• (5 < 3) || (8 < 5) returns false because both (5 < 3) and (8 < 5) are false .
• !(5 == 3) returns true because 5 == 3 is false .
• !(5 > 3) returns false because 5 > 3 is true .

5. Java Unary Operators

Unary operators are used with only one operand. For example, ++ is a unary operator that increases the value of a variable by 1 . That is, ++5 will return 6 .

Different types of unary operators are:

• Increment and Decrement Operators

Java also provides increment and decrement operators: ++ and -- respectively. ++ increases the value of the operand by 1 , while -- decrease it by 1 . For example,

Here, the value of num gets increased to 6 from its initial value of 5 .

Example 5: Increment and Decrement Operators

In the above program, we have used the ++ and -- operator as prefixes (++a, --b) . We can also use these operators as postfix (a++, b++) .

There is a slight difference when these operators are used as prefix versus when they are used as a postfix.

To learn more about these operators, visit increment and decrement operators .

6. Java Bitwise Operators

Bitwise operators in Java are used to perform operations on individual bits. For example,

Here, ~ is a bitwise operator. It inverts the value of each bit ( 0 to 1 and 1 to 0 ).

The various bitwise operators present in Java are:

These operators are not generally used in Java. To learn more, visit Java Bitwise and Bit Shift Operators .

Other operators

Besides these operators, there are other additional operators in Java.

The instanceof operator checks whether an object is an instanceof a particular class. For example,

Here, str is an instance of the String class. Hence, the instanceof operator returns true . To learn more, visit Java instanceof .

The ternary operator (conditional operator) is shorthand for the if-then-else statement. For example,

Here's how it works.

• If the Expression is true , expression1 is assigned to the variable .
• If the Expression is false , expression2 is assigned to the variable .

Let's see an example of a ternary operator.

In the above example, we have used the ternary operator to check if the year is a leap year or not. To learn more, visit the Java ternary operator .

Now that you know about Java operators, it's time to know about the order in which operators are evaluated. To learn more, visit Java Operator Precedence .

Table of Contents

• Introduction
• Java Arithmetic Operators
• Java Assignment Operators
• Java Relational Operators
• Java Logical Operators
• Java Unary Operators
• Java Bitwise Operators

Sorry about that.

Related Tutorials

Java Tutorial

• ▼Java Tutorial
• Introduction
• Java Program Structure
• Java Primitive data type
• ▼Development environment setup
• Download and Install JDK, Eclipse (IDE)
• Compiling, running and debugging Java programs
• ▼Declaration and Access control
• Class, methods, instance variables
• Java Packages
• ▼OOPS Concepts
• Java Object Oriented Programming concepts
• Is-A and Has-A relationship
• ▼Assignments
• Arrays - 2D array and Multi dimension array
• Wrapper classes
• ▼Operators
• Assignment Operator
• Arithmetic Operator
• Conditional Operator
• Logical Operator
• ▼Flow Control
• Switch Satement
• While and Do loop
• Java Branching Statements
• ▼Exceptions
• Handling Exceptions
• Checked and unchecked
• Custom Exception
• Try with resource feature of Java 7
• ▼String Class
• String Class
• Important methods of String class with example
• String buffer class and string builder class
• ▼File I/O and serialization
• File Input and Output
• Reading file
• Writing file
• Java Property File Processing
• Java Serialization
• ▼Java Collection
• Java Collection Framework
• Java ArrayList and Vector
• Java LinkedList Class
• Java HashSet
• Java TreeSet
• Java Linked HashSet
• Java Utility Class
• ▼Java Thread
• Java Defining, Instantiating and Starting Thread
• Java Thread States and Transitions
• Java Thread Interaction
• Java Code Synchronization
• ▼Java Package
• ▼Miscellaneous
• Garbage Collection in Java
• BigDecimal Method

Java Assignment Operators

Description.

Assigning a value to a variable seems straightforward enough; you simply assign the stuff on the right side of the '= 'to the variable on the left. Below statement 1 assigning value 10 to variable x and statement 2 is creating String object called name and assigning value "Amit" to it.

Assignment can be of various types. Let’s discuss each in detail.

Primitive Assignment:

The equal (=) sign is used for assigning a value to a variable. We can assign a primitive variable using a literal or the result of an expression.

Primitive Casting

Casting lets you convert primitive values from one type to another. We need to provide casting when we are trying to assign higher precision primitive to lower precision primitive for example If we try to assign int variable (which is in the range of byte variable) to byte variable then the compiler will throw an exception called "possible loss of precision". Eclipse IDE will suggest the solution as well as shown below. To avoid such problem we should use type casting which will instruct compiler for type conversion.

For cases where we try to assign smaller container variable to larger container variables we do not need of explicit casting. The compiler will take care of those type conversions. For example, we can assign byte variable or short variable to an int without any explicit casting.

Assigning Literal that is too large for a variable

When we try to assign a variable value which is too large (or out of range ) for a primitive variable then the compiler will throw exception “possible loss of precision” if we try to provide explicit cast then the compiler will accept it but narrowed down the value using two’s complement method. Let’s take an example of the byte which has 8-bit storage space and range -128 to 127. In below program we are trying to assign 129 literal value to byte primitive type which is out of range for byte so compiler converted it to -127 using two’s complement method. Refer link for two’s complement calculation (http://en.wikipedia.org/wiki/Two's_complement)

Java Code: Go to the editor

Reference variable assignment

We can assign newly created object to object reference variable as below

First line will do following things,

• Makes a reference variable named s of type String
• Creates a new String object on the heap memory
• Assigns the newly created String object to the reference variables

You can also assign null to an object reference variable, which simply means the variable is not referring to any object. The below statement creates space for the Employee reference variable (the bit holder for a reference value) but doesn't create an actual Employee object.

Compound Assignment Operators

Sometime we need to modify the same variable value and reassigned it to a same reference variable. Java allows you to combine assignment and addition operators using a shorthand operator. For example, the preceding statement can be written as:

The += is called the addition assignment operator. Other shorthand operators are shown below table

Below is the sample program explaining assignment operators:

• Assigning a value to can be straight forward or casting.
• If we assign the value which is out of range of variable type then 2’s complement is assigned.
• Java supports shortcut/compound assignment operator.

Java Code Editor:

Previous: Wrapper classes Next: Arithmetic Operator

Follow us on Facebook and Twitter for latest update.

• Weekly Trends and Language Statistics

• Java Arrays
• Java Strings
• Java Collection
• Java 8 Tutorial
• Java Multithreading
• Java Exception Handling
• Java Programs
• Java Project
• Java Collections Interview
• Java Interview Questions
• Spring Boot
• Java Tutorial

Overview of Java

• Introduction to Java
• The Complete History of Java Programming Language
• C++ vs Java vs Python
• How to Download and Install Java for 64 bit machine?
• Setting up the environment in Java
• How to Download and Install Eclipse on Windows?
• JDK in Java
• How JVM Works - JVM Architecture?
• Differences between JDK, JRE and JVM
• Just In Time Compiler
• Difference between JIT and JVM in Java
• Difference between Byte Code and Machine Code
• How is Java platform independent?

Basics of Java

• Java Basic Syntax
• Java Hello World Program
• Java Data Types
• Primitive data type vs. Object data type in Java with Examples
• Java Identifiers

Operators in Java

• Java Variables
• Scope of Variables In Java

Wrapper Classes in Java

Input/output in java.

• How to Take Input From User in Java?
• Scanner Class in Java
• Java.io.BufferedReader Class in Java
• Difference Between Scanner and BufferedReader Class in Java
• Ways to read input from console in Java
• System.out.println in Java
• Difference between print() and println() in Java
• Formatted Output in Java using printf()
• Fast I/O in Java in Competitive Programming

Flow Control in Java

• Decision Making in Java (if, if-else, switch, break, continue, jump)
• Java if statement with Examples
• Java if-else
• Java if-else-if ladder with Examples
• Loops in Java
• For Loop in Java
• Java while loop with Examples
• Java do-while loop with Examples
• For-each loop in Java
• Continue Statement in Java
• Break statement in Java
• Usage of Break keyword in Java
• return keyword in Java
• Java Arithmetic Operators with Examples
• Java Unary Operator with Examples
• Java Assignment Operators with Examples
• Java Relational Operators with Examples
• Java Logical Operators with Examples
• Java Ternary Operator with Examples
• Bitwise Operators in Java
• Strings in Java
• String class in Java
• Java.lang.String class in Java | Set 2
• Why Java Strings are Immutable?
• StringBuffer class in Java
• StringBuilder Class in Java with Examples
• String vs StringBuilder vs StringBuffer in Java
• StringTokenizer Class in Java
• StringTokenizer Methods in Java with Examples | Set 2
• StringJoiner Class in Java
• Arrays in Java
• Arrays class in Java
• Multidimensional Arrays in Java
• Different Ways To Declare And Initialize 2-D Array in Java
• Jagged Array in Java
• Final Arrays in Java
• Reflection Array Class in Java
• util.Arrays vs reflect.Array in Java with Examples

OOPS in Java

• Object Oriented Programming (OOPs) Concept in Java
• Why Java is not a purely Object-Oriented Language?
• Classes and Objects in Java
• Naming Conventions in Java
• Java Methods

Access Modifiers in Java

• Java Constructors
• Four Main Object Oriented Programming Concepts of Java

Inheritance in Java

Abstraction in java, encapsulation in java, polymorphism in java, interfaces in java.

• 'this' reference in Java
• Inheritance and Constructors in Java
• Java and Multiple Inheritance
• Interfaces and Inheritance in Java
• Association, Composition and Aggregation in Java
• Comparison of Inheritance in C++ and Java
• abstract keyword in java
• Abstract Class in Java
• Difference between Abstract Class and Interface in Java
• Control Abstraction in Java with Examples
• Difference Between Data Hiding and Abstraction in Java
• Difference between Abstraction and Encapsulation in Java with Examples
• Difference between Inheritance and Polymorphism
• Dynamic Method Dispatch or Runtime Polymorphism in Java
• Difference between Compile-time and Run-time Polymorphism in Java

Constructors in Java

• Copy Constructor in Java
• Constructor Overloading in Java
• Constructor Chaining In Java with Examples
• Private Constructors and Singleton Classes in Java

Methods in Java

• Static methods vs Instance methods in Java
• Abstract Method in Java with Examples
• Overriding in Java
• Method Overloading in Java
• Difference Between Method Overloading and Method Overriding in Java
• Differences between Interface and Class in Java
• Functional Interfaces in Java
• Nested Interface in Java
• Marker interface in Java
• Comparator Interface in Java with Examples
• Need of Wrapper Classes in Java
• Different Ways to Create the Instances of Wrapper Classes in Java
• Character Class in Java
• Java.Lang.Byte class in Java
• Java.Lang.Short class in Java
• Java.lang.Integer class in Java
• Java.Lang.Long class in Java
• Java.Lang.Float class in Java
• Java.Lang.Double Class in Java
• Java.lang.Boolean Class in Java
• Autoboxing and Unboxing in Java
• Type conversion in Java with Examples

Keywords in Java

• Java Keywords
• Important Keywords in Java
• Super Keyword in Java
• final Keyword in Java
• static Keyword in Java
• enum in Java
• transient keyword in Java
• volatile Keyword in Java
• final, finally and finalize in Java
• Public vs Protected vs Package vs Private Access Modifier in Java
• Access and Non Access Modifiers in Java

Memory Allocation in Java

• Java Memory Management
• How are Java objects stored in memory?
• Stack vs Heap Memory Allocation
• How many types of memory areas are allocated by JVM?
• Garbage Collection in Java
• Types of JVM Garbage Collectors in Java with implementation details
• Memory leaks in Java
• Java Virtual Machine (JVM) Stack Area

Classes of Java

• Understanding Classes and Objects in Java
• Singleton Method Design Pattern in Java
• Object Class in Java
• Inner Class in Java
• Throwable Class in Java with Examples

Packages in Java

• Packages In Java
• How to Create a Package in Java?
• Java.util Package in Java
• Java.lang package in Java
• Java.io Package in Java
• Java Collection Tutorial

Exception Handling in Java

• Exceptions in Java
• Types of Exception in Java with Examples
• Checked vs Unchecked Exceptions in Java
• Java Try Catch Block
• Flow control in try catch finally in Java
• throw and throws in Java
• User-defined Custom Exception in Java
• Chained Exceptions in Java
• Null Pointer Exception In Java
• Exception Handling with Method Overriding in Java
• Multithreading in Java
• Lifecycle and States of a Thread in Java
• Java Thread Priority in Multithreading
• Main thread in Java
• Java.lang.Thread Class in Java
• Runnable interface in Java
• Naming a thread and fetching name of current thread in Java
• What does start() function do in multithreading in Java?
• Difference between Thread.start() and Thread.run() in Java
• Thread.sleep() Method in Java With Examples
• Synchronization in Java
• Importance of Thread Synchronization in Java
• Method and Block Synchronization in Java
• Lock framework vs Thread synchronization in Java
• Difference Between Atomic, Volatile and Synchronized in Java
• Deadlock in Java Multithreading
• Deadlock Prevention And Avoidance
• Difference Between Lock and Monitor in Java Concurrency
• Reentrant Lock in Java

File Handling in Java

• Java.io.File Class in Java
• Java Program to Create a New File
• Different ways of Reading a text file in Java
• Java Program to Write into a File
• Delete a File Using Java
• File Permissions in Java
• FileWriter Class in Java
• Java.io.FileDescriptor in Java
• Java.io.RandomAccessFile Class Method | Set 1
• Regular Expressions in Java
• Regex Tutorial - How to write Regular Expressions?
• Matcher pattern() method in Java with Examples
• Pattern pattern() method in Java with Examples
• Quantifiers in Java
• java.lang.Character class methods | Set 1
• Java IO : Input-output in Java with Examples
• Java.io.Reader class in Java
• Java.io.Writer Class in Java
• Java.io.FileInputStream Class in Java
• FileOutputStream in Java
• Java.io.BufferedOutputStream class in Java
• Java Networking
• TCP/IP Model
• User Datagram Protocol (UDP)
• Difference Between IPv4 and IPv6
• Difference between Connection-oriented and Connection-less Services
• Socket Programming in Java
• java.net.ServerSocket Class in Java
• URL Class in Java with Examples

JDBC - Java Database Connectivity

• Introduction to JDBC (Java Database Connectivity)
• JDBC Drivers
• Establishing JDBC Connection in Java
• Types of Statements in JDBC
• JDBC Tutorial
• Java 8 Features - Complete Tutorial

Java provides many types of operators which can be used according to the need. They are classified based on the functionality they provide. In this article, we will learn about Java Operators and learn all their types.

What are the Java Operators?

Operators in Java are the symbols used for performing specific operations in Java. Operators make tasks like addition, multiplication, etc which look easy although the implementation of these tasks is quite complex.

Types of Operators in Java

There are multiple types of operators in Java all are mentioned below:

• Arithmetic Operators
• Unary Operators
• Assignment Operator
• Relational Operators
• Logical Operators
• Ternary Operator
• Bitwise Operators
• Shift Operators
• instance of operator

1. Arithmetic Operators

They are used to perform simple arithmetic operations on primitive data types. 

• * : Multiplication
• / : Division
• + : Addition
• – : Subtraction

2. Unary Operators

Unary operators need only one operand. They are used to increment, decrement, or negate a value. 

• – : Unary minus , used for negating the values.
• + : Unary plus indicates the positive value (numbers are positive without this, however). It performs an automatic conversion to int when the type of its operand is the byte, char, or short. This is called unary numeric promotion.
• Post-Increment: Value is first used for computing the result and then incremented.
• Pre-Increment: Value is incremented first, and then the result is computed.
• Post-decrement: Value is first used for computing the result and then decremented.
• Pre-Decrement: The value is decremented first, and then the result is computed.
• ! : Logical not operator , used for inverting a boolean value.

3. Assignment Operator

 ‘=’ Assignment operator is used to assign a value to any variable. It has right-to-left associativity, i.e. value given on the right-hand side of the operator is assigned to the variable on the left, and therefore right-hand side value must be declared before using it or should be a constant. 

The general format of the assignment operator is:

In many cases, the assignment operator can be combined with other operators to build a shorter version of the statement called a Compound Statement . For example, instead of a = a+5, we can write a += 5. 

• += , for adding the left operand with the right operand and then assigning it to the variable on the left.
• -= , for subtracting the right operand from the left operand and then assigning it to the variable on the left.
• *= , for multiplying the left operand with the right operand and then assigning it to the variable on the left.
• /= , for dividing the left operand by the right operand and then assigning it to the variable on the left.
• %= , for assigning the modulo of the left operand by the right operand and then assigning it to the variable on the left.

4. Relational Operators

These operators are used to check for relations like equality, greater than, and less than. They return boolean results after the comparison and are extensively used in looping statements as well as conditional if-else statements. The general format is, 

Some of the relational operators are- 

• ==, Equal to returns true if the left-hand side is equal to the right-hand side.
• !=, Not Equal to returns true if the left-hand side is not equal to the right-hand side.
• <, less than: returns true if the left-hand side is less than the right-hand side.
• <=, less than or equal to returns true if the left-hand side is less than or equal to the right-hand side.
• >, Greater than: returns true if the left-hand side is greater than the right-hand side.
• >=, Greater than or equal to returns true if the left-hand side is greater than or equal to the right-hand side.

5. Logical Operators

These operators are used to perform “logical AND” and “logical OR” operations, i.e., a function similar to AND gate and OR gate in digital electronics. One thing to keep in mind is the second condition is not evaluated if the first one is false, i.e., it has a short-circuiting effect. Used extensively to test for several conditions for making a decision. Java also has “Logical NOT”, which returns true when the condition is false and vice-versa

Conditional operators are:

• &&, Logical AND: returns true when both conditions are true.
• ||, Logical OR: returns true if at least one condition is true.
• !, Logical NOT: returns true when a condition is false and vice-versa

6. Ternary operator

The ternary operator is a shorthand version of the if-else statement. It has three operands and hence the name Ternary.

The general format is:

The above statement means that if the condition evaluates to true, then execute the statements after the ‘?’ else execute the statements after the ‘:’.  

7. Bitwise Operators

These operators are used to perform the manipulation of individual bits of a number. They can be used with any of the integer types. They are used when performing update and query operations of the Binary indexed trees. 

• &, Bitwise AND operator: returns bit by bit AND of input values.
• |, Bitwise OR operator: returns bit by bit OR of input values.
• ^, Bitwise XOR operator: returns bit-by-bit XOR of input values.
• ~, Bitwise Complement Operator: This is a unary operator which returns the one’s complement representation of the input value, i.e., with all bits inverted.

8. Shift Operators

These operators are used to shift the bits of a number left or right, thereby multiplying or dividing the number by two, respectively. They can be used when we have to multiply or divide a number by two. General format- 

• <<, Left shift operator: shifts the bits of the number to the left and fills 0 on voids left as a result. Similar effect as multiplying the number with some power of two.
• >>, Signed Right shift operator: shifts the bits of the number to the right and fills 0 on voids left as a result. The leftmost bit depends on the sign of the initial number. Similar effect to dividing the number with some power of two.
• >>>, Unsigned Right shift operator: shifts the bits of the number to the right and fills 0 on voids left as a result. The leftmost bit is set to 0.

9. instanceof operator

The instance of the operator is used for type checking. It can be used to test if an object is an instance of a class, a subclass, or an interface. General format- 

Precedence and Associativity of Java Operators

Precedence and associative rules are used when dealing with hybrid equations involving more than one type of operator. In such cases, these rules determine which part of the equation to consider first, as there can be many different valuations for the same equation. The below table depicts the precedence of operators in decreasing order as magnitude, with the top representing the highest precedence and the bottom showing the lowest precedence.

Interesting Questions about Java Operators 

1. precedence and associativity:.

 There is often confusion when it comes to hybrid equations which are equations having multiple operators. The problem is which part to solve first. There is a golden rule to follow in these situations. If the operators have different precedence, solve the higher precedence first. If they have the same precedence, solve according to associativity, that is, either from right to left or from left to right. The explanation of the below program is well written in comments within the program itself.

2. Be a Compiler: 

The compiler in our systems uses a lex tool to match the greatest match when generating tokens. This creates a bit of a problem if overlooked. For example, consider the statement a=b+++c ; too many of the readers might seem to create a compiler error. But this statement is absolutely correct as the token created by lex is a, =, b, ++, +, c. Therefore, this statement has a similar effect of first assigning b+c to a and then incrementing b. Similarly, a=b+++++c; would generate an error as the tokens generated are a, =, b, ++, ++, +, c. which is actually an error as there is no operand after the second unary operand.

3. Using + over (): 

When using the + operator inside system.out.println() make sure to do addition using parenthesis. If we write something before doing addition, then string addition takes place, that is, associativity of addition is left to right, and hence integers are added to a string first producing a string, and string objects concatenate when using +. Therefore it can create unwanted results.

Advantages of Operators in Java

The advantages of using operators in Java are mentioned below:

• Expressiveness : Operators in Java provide a concise and readable way to perform complex calculations and logical operations.
• Time-Saving: Operators in Java save time by reducing the amount of code required to perform certain tasks.
• Improved Performance : Using operators can improve performance because they are often implemented at the hardware level, making them faster than equivalent Java code.

Disadvantages of Operators in Java

The disadvantages of Operators in Java are mentioned below:

• Operator Precedence: Operators in Java have a defined precedence, which can lead to unexpected results if not used properly.
• Type Coercion : Java performs implicit type conversions when using operators, which can lead to unexpected results or errors if not used properly.

FAQs in Java Operators

1. what is operators in java with example.

Operators are the special symbols that are used for performing certain operations. For example, ‘+’ is used for addition where 5+4 will return the value 9.

Please Login to comment...

Similar reads, improve your coding skills with practice.

What kind of Experience do you want to share?

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

Assignment Operators in java

We can write the same statement in two different ways as follows. I have a question with providing two outputs for the value of x as follows.

It is clear that this is because, 1. In the first statemnt x is multiplied by 2 then add 5. 2. In the second statemnt add 5 to 2 together then multiplied by x. But why is it acting like this?

• 1 See also JLS §15.26 Assignment Operators . –  trashgod Commented Feb 13, 2012 at 6:15

5 Answers 5

Because your sec statement will be evaluated as x = x * (2+5);

While in the first case, its normal left to right precedence.Java guarantees that all operands of an operator are fully evaluated before the operator is applied.

A compound assignment operator has the following syntax:

and the following semantics:

The type of the "variable" is "type", and the "variable" is evaluated only once. Note the cast and the parentheses implied in the semantics. Here "op" can be any of the compound assignment operators(*,%, / etc). The compound assignment operators have the lowest precedence of all the operators in Java, allowing the expression on the right-hand side to be evaluated before the assignment.

• As I mentioned above, It is clear that this is because, 1. In the first statemnt x is multiplied by 2 then add 5. 2. In the second statemnt add 5 to 2 together then multiplied by x. But my question is why is it acting like this? What's the rule behind this? –  namalfernandolk Commented Feb 13, 2012 at 6:14
• That is because the right hand side of the statement is always executed first –  Sunil Kumar B M Commented Feb 13, 2012 at 6:17
• @NamalFernando: See trashgod's comment on your question -- that's how the operator is defined. (Also this is how it works in C, from which most languages borrow this operator.) –  casablanca Commented Feb 13, 2012 at 6:18
• @ casablanca : Yep, I got it now. –  namalfernandolk Commented Feb 13, 2012 at 6:20

See: Operator precedence in Java . * binds tighter than + which both are tighter than = or *= .

In your first statement x=x*2+5 it gives x=25 because * has higher priority compare to +. so It evaulates like

In your second statement you can see it has bracket.So openinng bracket ( has higer priority compare to *.So it first calculate the bracket data and then it multiply with x.

For the case 2 The operator '=' has lowest priory so operand 2 + 5 evaluated then operator '*=' evaluated (because operator = has lowest priory than '+'). Only in that time the operator ' ' come in to the scene. So 10 * 7 is assigned to X

This is an example of combining an arithmetic operator with the simple assignment operator to create compound assignments . With a simple assignment operator, the value on the right of the operator is calculated and assigned to the operand on its left. For example:

obviously gives a value for x of 7.

The compound assignment operator follows the same basic idea: the value on the right of the operator is calculated, modified by the compound assignment operator (in this case multiplying the existing value of x by the final calculated value 7, and assigned to the operand on the left.

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged java or ask your own question .

• Featured on Meta
• Upcoming initiatives on Stack Overflow and across the Stack Exchange network...
• Announcing a change to the data-dump process

Hot Network Questions

• All QFTs are Finite
• Differential vs. Single-Ended amplification for sensor sampling
• Submitting paper to lower tier journal instead of doing major revision at higher tier journal
• How to address imbalanced work assignments to new boss?
• If every definable class admits a group structure, must global choice hold?
• Integer solutions for a simple cubic
• bootstrapping a confidence interval with unbalanced data
• Photographing human iris without reflections
• Can true ever be false?
• What is the maximum number of real roots in the interval (0,1) of a monic polynomial with integer coefficients and has degree 2022.
• Reduce a string up to idempotency
• How is Agile model more flexible than the Waterfall model?
• How to calculate baker's percentages for indirect doughs?
• Publishing a paper written in your free time as an unaffiliated author when you are affiliated
• Why exactly do we need the learning rate in gradient descent?
• AmE: I never found the right one
• When solving eigenvalues, what does the factor in front of the Root[] mean?
• My newspaper was stolen
• What do I do if my professor doesn't give me an extra credit assignment that he promised?
• Was there an Easter egg in the Electrologica X1 QUINIO (GO-MOKU) game?
• Simple CLI based Mastermind clone in C
• Take screenshot of rendered HTML from Linux without GUI
• Is it possible to express any multi-qubit quantum unitary operation as a rotation about a specific unit vector?
• What are the safe assumptions I can make when installing a wall oven without model/serial?

An official website of the United States government

Here’s how you know

Official websites use .gov A .gov website belongs to an official government organization in the United States.

Secure .gov websites use HTTPS A lock ( Lock A locked padlock ) or https:// means you’ve safely connected to the .gov website. Share sensitive information only on official, secure websites.

Free Cyber Services #protect2024 Secure Our World Shields Up Report A Cyber Issue

Vulnerability Summary for the Week of July 15, 2024

The CISA Vulnerability Bulletin provides a summary of new vulnerabilities that have been recorded by the  National Institute of Standards and Technology  (NIST)  National Vulnerability Database  (NVD) in the past week. In some cases, the vulnerabilities in the bulletin may not yet have assigned CVSS scores. Please visit NVD for updated vulnerability entries, which include CVSS scores once they are available.

Vulnerabilities are based on the  Common Vulnerabilities and Exposures  (CVE) vulnerability naming standard and are organized according to severity, determined by the  Common Vulnerability Scoring System  (CVSS) standard. The division of high, medium, and low severities correspond to the following scores:

• High : vulnerabilities with a CVSS base score of 7.0–10.0
• Medium : vulnerabilities with a CVSS base score of 4.0–6.9
• Low : vulnerabilities with a CVSS base score of 0.0–3.9

Entries may include additional information provided by organizations and efforts sponsored by CISA. This information may include identifying information, values, definitions, and related links. Patch information is provided when available. Please note that some of the information in the bulletin is compiled from external, open-source reports and is not a direct result of CISA analysis.  

High Vulnerabilities

Back to top

Medium Vulnerabilities

Low Vulnerabilities

Severity Not Yet Assigned