java assignment and comparison

Arithmetic, Assignment, Comparison, and Logical Operators in Java

Java is a powerful programming language that provides various operators to perform arithmetic calculations, assign values to variables, compare different values, and evaluate logical expressions. Understanding these operators is essential for writing efficient and effective Java code. In this article, we will explore the commonly used arithmetic, assignment, comparison, and logical operators in Java.

Arithmetic Operators

Arithmetic operators are used to perform basic mathematical operations such as addition (+), subtraction (-), multiplication (*), division (/), and modulus (%). These operators work on numeric data types like integers (int) or floating-point numbers (float or double).

Here's an example of using arithmetic operators:

The output of the above code will be: Sum: 15 Difference: 5 Product: 50 Quotient: 2 Remainder: 0

Assignment Operators

Assignment operators are used to assign values to variables. The most common assignment operator is the equals sign (=). However, there are also compound assignment operators that combine an arithmetic operation with an assignment.

Here's an example of using assignment and compound assignment operators:

Comparison Operators

Comparison operators are used to compare two values and return a boolean result (true or false). These operators are often used in conditional statements or loops.

Here's an example of using comparison operators:

The output of the above code will be: Is Equal? false Is Not Equal? true Is Greater? true Is Lesser ? false Is greater Or equal ? true Is lesser Or equal ?false

Logical Operators

Logical operators are used for combining multiple conditions and evaluating logical expressions. The three main logical operators in Java are AND (&&), OR (||), and NOT (!).

Here's an example of using logical operators:

The output of the above code will be: You are eligible for a student discount. You can apply for the job. Is Valid? false

In conclusion, understanding arithmetic, assignment, comparison, and logical operators in Java is crucial for performing calculations, assigning values to variables, comparing different values, and evaluating logical expressions. By utilizing these operators effectively in your code, you can enhance its functionality and efficiency.

noob to master © copyleft

Explore All Categories

• EmployeeComparator class implements Comparator inteface and overrides the compare() method to compare Employee objects passed to it based on the natural ordering of their names of String type.
• ComparatorOldWay class sorts a static list of Employee objects using an instance of EmployeeComparator and the Collections.sort() method.
• Output shows that the employeeList gets sorted alphabetically based on the names of the employees.
• ComparatorsInJava8 class uses the same list of Employee objects as that used for the previous example for Java 7 style of Comparator .
• An instance of the Comparator , empNameComparator , is created using a lambda expression.
• The lambda expression takes 2 Employee instances, emp1 and emp2 , as input and outputs the comparison of their names using the natural comparison order of Strings.
• Using empNameComparator for sorting results in a correctly sorted Employee list by name.
• An instance of the Comparator , comparatorObj , is created using the static method Comparator.comparing() .
• The comparing() is passed a lambda expression, which corresponds to a Function<T,R> instance accepting an Employee object as input and returns an employee name - the sort key .
• Using comparatorObj for sorting results in a correctly sorted Employee list by name.
• NOTE - Instead of the lambda expression, you can also use an equivalent method reference as well. The comparing() method with a method reference will then be written like this - [su_note note_color="#ffffcc" text_color="#ffffff"] Comparator empNameComparator = Comparator.comparing(Employee::getName); [/su_note]
• First comparing() method is invoked with method reference for Employee 's getName() method. This returns a Comparator instance with the first level sort based on Employee name as we saw in previous section.
• We append .thenComparing(Employee::getAge) to the Comparator instance returned using comparing() method, which adds a second level sort based on Employee 's getAge() method.
• The output is as expected with the employee named ‘Harry Major’ with the lesser age placed earlier in the sorted employeeList than his elder namesake employee.
• Employee names are extracted into an empNames List as explained before the code snippet.
• empNames List is then sorted using the Comparator.naturalOrder() method which returns a Comparator instance of String ’s natural comparison order based on the empName ’s generic type of String .
• Employee names are sorted in natural comparison order, i.e. alphabetical order, and printed.
• Instead of invoking the Comparator.naturalOrder() method to the empNames.sort() method, you can invoke the Comparator.reverseOrder() method in order to sort the empNames List in reverse of natural comparison order or reverse alphabetical order.
• Using nullsFirst() , the comparator places the two Employee objects with the sort key null (employee name null) before the other Employee objects in the list.
• Likewise, nullsLast() , the comparator places these two Employee objects after the other Employee objects in the list.
• Comparator's default method reversed() is applied to the empNameComparator which has been initially defined to sort in alphabetical order of Employee names.
• Due to reversed() being applied to it, the Employee objects are printed in reverse alphabetical order of their names.

Click on a category to view all articles

• Algorithms & DS in Java  (7)
• Core Java  (24)
• Design Patterns  (17)
• Error Handling  (6)
• General Java Programs  (9)
• JPA  (6)
• Java 8  (60)
• Java 9 & beyond...  (4)
• JavaScript and HTML  (2)
• Node.js  (1)
• Programming & Design Principles  (9)
• Quick Coding Tips  (19)
• Reviews  (1)

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

• Enterprise Java
• Web-based Java
• Data & Java
• Project Management
• Visual Basic
• Ruby / Rails
• Java Mobile
• Architecture & Design
• Open Source
• Web Services

Java provides many types of operators to perform a variety of calculations and functions, such as logical , arithmetic , relational , and others. With so many operators to choose from, it helps to group them based on the type of functionality they provide. This programming tutorial will focus on Java’s numerous a ssignment operators.

Before we begin, however, you may want to bookmark our other tutorials on Java operators, which include:

• Arithmetic Operators
• Comparison Operators
• Conditional Operators
• Logical Operators
• Bitwise and Shift Operators

Assignment Operators in Java

As the name conveys, assignment operators are used to assign values to a variable using the following syntax:

The left side operand of the assignment operator must be a variable, whereas the right side operand of the assignment operator may be a literal value or another variable. Moreover, the value or variable on the right side must be of the same data type of the operand on the left side. Otherwise, the compiler will raise an error. Assignment operators have a right to left associativity in that the value given on the right-hand side of the operator is assigned to the variable on the left. Therefore, the right-hand side variable must be declared before assignment.

You can learn more about variables in our programming tutorial: Working with Java Variables .

Types of Assignment Operators in Java

Java assignment operators are classified into two types: simple and compound .

The Simple assignment operator is the equals ( = ) sign, which is the most straightforward of the bunch. It simply assigns the value or variable on the right to the variable on the left.

Compound operators are comprised of both an arithmetic, bitwise, or shift operator in addition to the equals ( = ) sign.

Equals Operator (=) Java Example

First, let’s learn to use the one-and-only simple assignment operator – the Equals ( = ) operator – with the help of a Java program. It includes two assignments: a literal value to num1 and the num1 variable to num2 , after which both are printed to the console to show that the values have been assigned to the numbers:

The += Operator Java Example

A compound of the + and = operators, the += adds the current value of the variable on the left to the value on the right before assigning the result to the operand on the left. Here is some sample code to demonstrate how to use the += operator in Java:

The -= Operator Java Example

Made up of the – and = operators, the -= first subtracts the variable’s value on the right from the current value of the variable on the left before assigning the result to the operand on the left. We can see it at work below in the following code example showing how to decrement in Java using the -= operator:

The *= Operator Java Example

This Java operator is comprised of the * and = operators. It operates by multiplying the current value of the variable on the left to the value on the right and then assigning the result to the operand on the left. Here’s a program that shows the *= operator in action:

The /= Operator Java Example

A combination of the / and = operators, the /= Operator divides the current value of the variable on the left by the value on the right and then assigns the quotient to the operand on the left. Here is some example code showing how to use the  /= operator in Java:

%= Operator Java Example

The %= operator includes both the % and = operators. As seen in the program below, it divides the current value of the variable on the left by the value on the right and then assigns the remainder to the operand on the left:

Compound Bitwise and Shift Operators in Java

The Bitwise and Shift Operators that we just recently covered can also be utilized in compound form as seen in the list below:

• &= – Compound bitwise Assignment operator.
• ^= – Compound bitwise ^ assignment operator.
• >>= – Compound right shift assignment operator.
• >>>= – Compound right shift filled 0 assignment operator.
• <<= – Compound left shift assignment operator.

The following program demonstrates the working of all the Compound Bitwise and Shift Operators :

Final Thoughts on Java Assignment Operators

This programming tutorial presented an overview of Java’s simple and compound assignment Operators. An essential building block to any programming language, developers would be unable to store any data in their programs without them. Though not quite as indispensable as the equals operator, compound operators are great time savers, allowing you to perform arithmetic and bitwise operations and assignment in a single line of code.

Read more Java programming tutorials and guides to software development .

Get the Free Newsletter!

Subscribe to Developer Insider for top news, trends & analysis

Latest Posts

What is the role of a project manager in software development, how to use optional in java, overview of the jad methodology, microsoft project tips and tricks, how to become a project manager in 2023, related stories, understanding types of thread synchronization errors in java, understanding memory consistency in java threads.

Java Tutorial

Control statements, java object class, java inheritance, java polymorphism, java abstraction, java encapsulation, java oops misc.

• Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Transact-SQL

Reinforcement Learning

R Programming

React Native

Python Design Patterns

Python Pillow

Python Turtle

Preparation

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

Cloud Computing

Data Science

Machine Learning

B.Tech / MCA

Data Structures

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

C Programming

Control System

Data Mining

Data Warehouse

• 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?

We’ve opened a new Java/Spring Course Team Lead position. Part-time and entirely remote, of course: Read More

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:

>> The New “REST With Spring Boot”

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

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.

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.

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.

• Trending Now
• Foundational Courses
• Data Science
• Practice Problem
• Machine Learning
• System Design
• DevOps Tutorial

Comparison Operators in Programming

Comparison Operators in programming are used to compare values and determine their relationship, such as equality, inequality, greater than, less than, etc. They evaluate expressions and return a Boolean value (true or false) based on the comparison result, crucial for decision-making in conditional statements and loops.

Table of Content

What is a Comparison Operator?

• Common Comparison Operators
• Equal to (==) Comparison Operator
• Not equal to (!=) Comparison Operator
• Greater than (>) Comparison Operator
• Greater than or equal to (>=) Comparison Operator
• Less than (<) Comparison Operator
• Less than or equal to (<=) Comparison Operator

Comparison Operator is an operator that compares two operands and return true if the comparison evaluates to true otherwise, it returns false. They are important in programming, as they help us to compare values and expressions. The return value of a comparison is either true or false. 

Common Comparison Operators:

• Equality Operator (==) .
• Inequality Operator (!=)
• Greater Than Operator (>)
• Less Than Operator (<)
• Greater Than or Equal To Operator (>=)
• Less Than or Equal To Operator (<=)

Equal to (==) Comparison Operator:

The “equal to” (==) operator is a comparison operator widely used in programming languages to determine whether two values or expressions are equal .

Example of Equal to (==) Comparison Operator:

Here are the example of Equal to (==) Operator in different language:

Not equal to (!=) Comparison Operator:

The “not equal to” (!=) operator is a comparison operator used in programming languages to determine whether two values or expressions are not equal.

Example of Not equal to (!=) Comparison Operator:

Here are the example of Not equal to (!=) Operator in different language:

Greater than (>) Comparison Operator:

The “greater than” (>) operator is a comparison operator used in programming languages to determine whether the value or expression on the left of the operand is greater than the value or expression on the right.

Example of Greater than (>) Comparison Operator:

Here are the example of Greater than (>) Operator in different language:

Greater than or equal to (>=) Comparison Operator:

The “greater than or equal to” (>=) operator is a comparison operator used in programming languages to determine whether the value or expression on the left of the operand is greater than or equal to the value or expression on the right.

Example of Greater than or equal to (>=) Comparison Operator:

Here are the example of Greater than or equal to (>=) Operator in different language:

Less than (<) Comparison Operator:

The “less than” (<) operator is a comparison operator used in programming languages to determine whether the value or expression on the left of the operand is less than the value or expression on the right.

Example of Less than (<) Comparison Operator:

Here are the example of Less than (<) Operator in different language:

Less than or equal to (<=) Comparison Operator:

The “less than or equal to” (<=) operator is a comparison operator used in programming languages to determine whether the value or expression on the left of the operand is less than or equal to the value or expression on the right.

Example of Less than or equal to (<=) Comparison Operator:

Here are the example of Less than or equal to (<=) Operator in different language:

Conclusion:

Comparison operators are like tools that programmers use to compare things in their code. They help decide if something is true or false, which is super important for making decisions in programs. By knowing how to use these comparison operators properly, programmers can write code that works better and is easier to manage, no matter what kind of programming they’re doing.

Please Login to comment...

Similar reads.

• Programming

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Java Tutorial

Java methods, java classes, java file handling, java how to's, java reference, java examples, java advanced sorting (comparator and comparable), java advanced sorting.

In the List Sorting Chapter , you learned how to sort lists alphabetically and numerically, but what if the list has objects in it?

To sort objects you need to specify a rule that decides how objects should be sorted. For example, if you have a list of cars you might want to sort them by year, the rule could be that cars with an earlier year go first.

The Comparator and Comparable interfaces allow you to specify what rule is used to sort objects.

Being able to specify a sorting rule also allows you to change how strings and numbers are sorted.

Comparators

An object that implements the Comparator interface is called a comparator.

The Comparator interface allows you to create a class with a compare() method that compares two objects to decide which one should go first in a list.

The compare() method should return a number which is:

• Negative if the first object should go first in a list.
• Positive if the second object should go first in a list.
• Zero if the order does not matter.

A class that implements the Comparator interface might look something like this:

To use the comparator, pass it as an argument into a sorting method:

Here is a complete example using a comparator to sort a list of cars by year:

Using a Lambda Expression

To make the code shorter, the comparator can be replaced with a lambda expression which has the same arguments and return value as the compare() method:

Use a lambda expression as a comparator:

Special Sorting Rules

Comparators can also be used to make special sorting rules for strings and numbers. In this example we use a comparator to list all of the even numbers before the odd ones:

The Comparable Interface

The Comparable interface allows an object to specify its own sorting rule with a compareTo() method.

The compareTo() method takes an object as an argument and compares the comparable with the argument to decide which one should go first in a list.

Like the comparator, the compareTo() method returns a number which is:

• Negative if the comparable should go first in a list.
• Positive if the other object should go first in a list.

Many native Java classes implement the Comparable interface, such as String and Integer .

This is why strings and numbers do not need a comparator to be sorted.

An object that implements the Comparable interface might look something like this:

Here is the same example as before but using the Comparable interface instead of a comparator:

A Common Sorting Trick

The most obvious way to sort two numbers naturally is to write something like this:

But it can actually be done with just a single line:

This trick can also be used to easily sort things in reverse:

Comparator vs. Comparable

A comparator is an object with one method that is used to compare two different objects.

A comparable is an object which can compare itself with other objects.

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.

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.

Now that you've learned how to declare and initialize variables, you probably want to know how to do something with them. Learning the operators of the Java programming language is a good place to start. Operators are special symbols that perform specific operations on one, two, or three operands , and then return a result.

As we explore the operators of the Java programming language, it may be helpful for you to know ahead of time which operators have the highest precedence. The operators in the following table are listed according to precedence order. The closer to the top of the table an operator appears, the higher its precedence. Operators with higher precedence are evaluated before operators with relatively lower precedence. Operators on the same line have equal precedence. When operators of equal precedence appear in the same expression, a rule must govern which is evaluated first. All binary operators except for the assignment operators are evaluated from left to right; assignment operators are evaluated right to left.

In general-purpose programming, certain operators tend to appear more frequently than others; for example, the assignment operator " = " is far more common than the unsigned right shift operator " >>> ". With that in mind, the following discussion focuses first on the operators that you're most likely to use on a regular basis, and ends focusing on those that are less common. Each discussion is accompanied by sample code that you can compile and run. Studying its output will help reinforce what you've just learned.

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

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

• 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.

Which is faster? Comparison or assignment?

I'm doing a bit of coding, where I have to write this sort of code:

I wonder if it should be re-written as

This raises the question: are comparisions faster than assignments?

What about differences from language to language? (contrast between java & cpp, eg.)

NOTE: I've heard that "premature optimization is the root of all evil." I don't think that applies here :)

• performance
• optimization
• refactoring

• 2 unless you are writing a program for an embedded system with a very slow processor then you needn't worry. Even at that point you would be reluctant to hand-optimize –  Aiden Bell Commented May 26, 2009 at 12:35
• 2 Can array[i] be anything other than a bool? if not then the rewrite is correct. –  Aiden Bell Commented May 26, 2009 at 12:36
• Yes, the array is a boolean array. –  jrharshath Commented May 26, 2009 at 12:42
• 21 To everyone posting "opinions" on what is faster and why, please stop. The ONLY way to know what's faster for a given compiler on a given processor is to benchmark it. Opinions don't count where something can be measured and tested. To the asker, this isn't something to worry about, but if you must, then test it over 1,000,000 iterations, get average times for several runs, change it, and see what the difference is. Theoretically one may be faster than the other, but for a primitive data type, they'll be practically identical. –  Binary Worrier Commented May 26, 2009 at 12:49
• @Binary Worrier: How do you know that 1000000 iterations is correct size for the array? With modern processors avoiding cache misses is the important part, not counting instruction cycles. Thus the benchmark should run with realistic data size. –  John Smith Commented May 27, 2009 at 15:00

12 Answers 12

This isn't just premature optimization , this is micro-optimization , which is an irrelevant distraction.

Assuming your array is of boolean type then your comparison is unnecessary, which is the only relevant observation.

• 1 I agree..may be it will be good from readability point of view, but certainly not if the change is being done to 'impreove' the performance. –  Naveen Commented May 26, 2009 at 12:35
• @cletus, If it's just one call , it's micro-optimization. If it's one zillion calls, it's macro-optimization. Anyway related thread at stackoverflow.com/q/23228359/632951 –  Pacerier Commented Apr 20, 2016 at 14:58
• 2 I tested the bool assignment and comparison. The result showed that comparison is faster although I agree to your logic. Tested in .Net 4.6.1 –  k4yaman Commented Nov 8, 2018 at 11:37

Well, since you say you're sure that this matters you should just write a test program and measure to find the difference.

Comparison can be faster if this code is executed on multiple variables allocated at scattered addresses in memory. With comparison you will only read data from memory to the processor cache, and if you don't change the variable value when the cache decides to to flush the line it will see that the line was not changed and there's no need to write it back to the memory. This can speed up execution.

• 1 Agreed, on the other hand some architectures also have a penalty for branching... Only true answer can be found by measuring. Or looking at the generated assembly code, to see if it changes at all (my guess is no). –  Johan Kotlinski Commented May 26, 2009 at 12:46
• 2 Don't caches do this automatically? i.e. check if the data that's written is the same as the data that's there. –  Jules Commented May 27, 2009 at 16:34
• @julesjacobs: Not sure if it checks for equality. It surely checks whether or not it has been updated, but I've never heard of it checking for the update to be an actual change. That's a good point to keep in mind. –  sharptooth Commented May 28, 2009 at 6:58

Edit: I wrote a script in PHP. I just noticed that there was a glaring error in it meaning the best-case runtime was being calculated incorrectly (scary that nobody else noticed!)

Best case just beats outright assignment but worst case is a lot worse than plain assignment. Assignment is likely fastest in terms of real-world data.

• assignment in 0.0119960308075 seconds
• worst case comparison in 0.0188510417938 seconds
• best case comparison in 0.0116770267487 seconds

• Thats interesting: assignment is actually faster! –  jrharshath Commented May 27, 2009 at 3:47
• Ad by a significant margin, too: 14 ms versus 22 to 39 ms. That's about a factor of 2! –  MSalters Commented May 27, 2009 at 15:29
• Yes yes! Thank you so much for finally checking this. Every time I would have a situation like this, I would have a mental breakdown because I never know what to choose from. My logic was: Assignment is just setting every time the code is run. But comparison, is reading, comparing, then setting if necessary. So thank God I always went with assigning, this really helps my OCD xD –  TheMatrixAgent22 Commented Jul 20, 2021 at 19:42

I believe if comparison and assignment statements are both atomic(ie one processor instruction) and the loop executes n times, then in the worst-case comparing then assigning would require n+1(comparing on every iteration plus setting the assignement) executions whereas constantly asssigning the bool would require n executions. Therefore the second one is more efficient.

Depends on the language. However looping through arrays can be costly as well. If the array is in consecutive memory, the fastest is to write 1 bits (255s) across the entire array with memcpy assuming your language/compiler can do this.

Thus performing 0 reads-1 write total, no reading/writing the loop variable/array variable (2 reads/2 writes each loop) several hundred times.

I really wouldn't expect there to be any kind of noticeable performance difference for something as trivial as this so surely it comes down to what gives you clear, more readable code. I my opinion that would be always assigning true.

• Neither would I expect a performance difference. Its a matter of knowing the better choice from performance POV. –  jrharshath Commented May 26, 2009 at 12:44

Might give this a try:

But really the only way to know for sure is to profile, I'm sure pretty much any compiler would see the comparison to false as unnecessary and optimize it out.

• 2 If your compiler is any good this will produce identical machine code. –  Jules Commented May 27, 2009 at 16:36

It all depends on the data type. Assigning booleans is faster than first comparing them. But that may not be true for larger value-based datatypes.

As others have noted, this is micro-optimization.

(In politics or journalism, this is known as navel-gazing ;-)

Is the program large enough to have more than a couple layers of function/method/subroutine calls?

If so, it probably had some avoidable calls, and those can waste hundreds as much time as low-level inefficiencies.

On the assumption that you have removed those (which few people do), then by all means run it 10^9 times under a stopwatch, and see which is faster.

Why would you even write the first version? What's the benefit of checking to see if something is false before setting it true. If you always are going to set it true, then always set it true.

When you have a performance bottleneck that you've traced back to setting a single boolean value unnecessarily, come back and talk to us.

I remember in one book about assembly language the author claimed that if condition should be avoided, if possible. It is much slower if the condition is false and execution has to jump to another line, considerably slowing down performance. Also since programs are executed in machine code, I think 'if' is slower in every (compiled) language, unless its condition is true almost all the time.

• 1 This approach is referred to as non-branching code, and it is a viable approach for highly optimized code, or when consistent and reliable timing is important, as is often the case in embedded systems. –  Leedan Johnson Commented Oct 4, 2021 at 18:38

If you just want to flip the values, then do:

Performance using this is actually worse though, as instead of only having to do a single check for a true false value then setting, it checks twice.

If you declare a 1000000 element array of true,false, true,false pattern comparision is slower. (var b = !b) essentially does a check twice instead of once

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 performance optimization refactoring or ask your own question .

• Featured on Meta
• We've made changes to our Terms of Service & Privacy Policy - July 2024
• Introducing an accessibility dashboard and some upcoming changes to display...
• Tag hover experiment wrap-up and next steps

Hot Network Questions

• How do I rigorously compute probabilities over infinite sequences of coin flips?
• When can a citizen's arrest of an Interpol fugitive be legal in Washington D.C.?
• Intuitive reason for periods of 2 and 8 in Bott periodicity?
• Generating a mesh with fine elements around certain areas
• What was the first science fiction story set in the future?
• Can the Bible be the word of God, when there are multiple versions of it?
• Lightning protection for steel tower
• Which Boolean Math mode should I use?
• Simple CMOS not gate in Proteus
• Statistically, which is more of a severe penalty on a d20 roll, Disadvantage or a -10 penalty?
• Reference for homotopy groups of filtered homotopy colimits
• Refereeing papers by people you are very close to
• Does full erase create all 0s or all 1s on the CD-RW?
• Conservation of energy in a mechanical system with a discontinuous potential function
• How to find a simplified sinogram in a paper dictionary
• If pressure is caused by the weight of water above you, why is pressure said to act in all direction, not just down?
• What does it mean to echo multiple strings into a UNIX pipe?
• Why don't programming languages or IDEs support attaching descriptive metadata to variables?
• How can electrons hop large distances if they are connected to the atom which is stationary in an lattice?
• How to make a case based on factual evidence that my colleague's writing style for submitted manuscripts has got to be overhauled?
• Possible bug in DateList, DateObject etc returning negative years in 14.1
• What tool has a ring on the end of a threaded handle shaft?
• Can I continue using technology after it is patented
• How do I resolve license terms conflict when forking?

Count comparisons and assignments in three sorting algorithms

Mike Stein wrote: In the swap method I should have labeled the swaps++ as moves++ because that is a more accurate description of what is going on.

Mike Stein wrote: Just one swap would be needed.

Those code lines from your quick sort algorithm does 1 swap. Changing places of numbers 2 and 1. But you are counting as 3 swaps. So you have to fix it.

Mike Stein wrote: for my particular project I have to count every assignment (e.g. temp = array[index]) and every single comparison (array[index] < value or something like that).

Mike Stein wrote: int moves = 0; int compares = 0; ... firstValue = array[index]; moves++; scan = index;

Mike Stein wrote: Since I need it to count when both true and false it is redundant to have the counter in the if statement!

You don't need to increment the number of comparisons when something is true or false. You need to increment the number of comparisons when a comparison takes place.