what is an assignment operator expression in java

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.

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.

1.7 Java | Assignment Statements & Expressions

An assignment statement designates a value for a variable. An assignment statement can be used as an expression in Java.

After a variable is declared, you can assign a value to it by using an assignment statement . In Java, the equal sign = is used as the assignment operator . The syntax for assignment statements is as follows:

An expression represents a computation involving values, variables, and operators that, when taking them together, evaluates to a value. For example, consider the following code:

You can use a variable in an expression. A variable can also be used on both sides of the =  operator. For example:

In the above assignment statement, the result of x + 1  is assigned to the variable x . Let’s say that x is 1 before the statement is executed, and so becomes 2 after the statement execution.

To assign a value to a variable, you must place the variable name to the left of the assignment operator. Thus the following statement is wrong:

Note that the math equation  x = 2 * x + 1  ≠ the Java expression x = 2 * x + 1

Which is equivalent to:

And this statement

is equivalent to:

Note: The data type of a variable on the left must be compatible with the data type of a value on the right. For example, int x = 1.0 would be illegal, because the data type of x is int (integer) and does not accept the double value 1.0 without Type Casting .

◄◄◄BACK | NEXT►►►

What's Your Opinion? Cancel reply

Enhance your Brain

Subscribe to Receive Free Bio Hacking, Nootropic, and Health Information

HTML for Simple Website Customization My Personal Web Customization Personal Insights

DISCLAIMER | Sitemap | ◘

HTML for Simple Website Customization My Personal Web Customization Personal Insights SEO Checklist Publishing Checklist My Tools

Top Posts & Pages

01 Career Opportunities

• Top 50 Java Interview Questions and Answers
• Java Developer Salary Guide in India – For Freshers & Experienced

02 Beginner

• Best Java Developer Roadmap 2024
• Hierarchical Inheritance in Java
• Arithmetic operators in Java
• Unary operator in Java
• Ternary Operator in Java
• Relational operators in Java

Assignment operator in Java

• Logical operators in Java
• Single Inheritance in Java
• Primitive Data Types in Java
• Multiple Inheritance in Java
• Hybrid Inheritance in Java
• Parameterized Constructor in Java
• Constructor Chaining in Java
• Constructor Overloading in Java
• What are Copy Constructors In Java? Explore Types,Examples & Use
• What is a Bitwise Operator in Java? Type, Example and More
• Top 10 Reasons to know why Java is Important?
• What is Java? A Beginners Guide to Java
• Differences between JDK, JRE, and JVM: Java Toolkit
• Variables in Java: Local, Instance and Static Variables
• Data Types in Java - Primitive and Non-Primitive Data Types
• Conditional Statements in Java: If, If-Else and Switch Statement
• What are Operators in Java - Types of Operators in Java ( With Examples )
• Looping Statements in Java - For, While, Do-While Loop in Java
• Java VS Python
• Jump Statements in JAVA - Types of Statements in JAVA (With Examples)
• Java Arrays: Single Dimensional and Multi-Dimensional Arrays
• What is String in Java - Java String Types and Methods (With Examples)

03 Intermediate

• OOPs Concepts in Java: Encapsulation, Abstraction, Inheritance, Polymorphism
• Access Modifiers in Java: Default, Private, Public, Protected
• What is Class in Java? - Objects and Classes in Java {Explained}
• Constructors in Java: Types of Constructors with Examples
• Polymorphism in Java: Compile time and Runtime Polymorphism
• Abstraction in Java: Concepts, Examples, and Usage
• What is Inheritance in Java: Types of Inheritance in Java
• Exception handling in Java: Try, Catch, Finally, Throw and Throws

04 Training Programs

• Java Programming Course
• C++ Programming Course
• MERN: Full-Stack Web Developer Certification Training
• Data Structures and Algorithms Training
• Assignment Operator In Ja..

Java Programming For Beginners Free Course

Assignment operators in java: an overview.

We already discussed the Types of Operators in the previous tutorial Java. In this Java tutorial , we will delve into the different types of assignment operators in Java, and their syntax, and provide examples for better understanding. Because Java is a flexible and widely used programming language. Assignment operators play a crucial role in manipulating and assigning values to variables. To further enhance your understanding and application of Java assignment operator's concepts, consider enrolling in the best Java Certification Course .

What are the Assignment Operators in Java?

Assignment operators in Java are used to assign values to variables . They are classified into two main types: simple assignment operator and compound assignment operator.

The general syntax for a simple assignment statement is:

And for a compound assignment statement:

Read More - Advanced Java Interview Questions

Types of Assignment Operators in Java

• Simple Assignment Operator: The Simple Assignment Operator is used with the "=" sign, where the operand is on the left side and the value is on the right. The right-side value must be of the same data type as that defined on the left side.
• Compound Assignment Operator:  Compound assignment operators combine arithmetic operations with assignments. They provide a concise way to perform an operation and assign the result to the variable in one step. The Compound Operator is utilized when +,-,*, and / are used in conjunction with the = operator.

1. Simple Assignment Operator (=):

The equal sign (=) is the basic assignment operator in Java. It is used to assign the value on the right-hand side to the variable on the left-hand side.

Explanation

2. addition assignment operator (+=) :, 3. subtraction operator (-=):, 4. multiplication operator (*=):.

Read More - Java Developer Salary

5. Division Operator (/=):

6. modulus assignment operator (%=):, example of assignment operator in java.

Let's look at a few examples in our Java Playground to illustrate the usage of assignment operators in Java:

• Unary Operator in Java
• Arithmetic Operators in Java
• Relational Operators in Java
• Logical Operators in Java

Q1. Can I use multiple assignment operators in a single statement?

Q2. are there any other compound assignment operators in java, q3. how many types of assignment operators.

• 1. (=) operator
• 1. (+=) operator
• 2. (-=) operator
• 3. (*=) operator
• 4. (/=) operator
• 5. (%=) operator

About Author

We use cookies to make interactions with our websites and services easy and meaningful. Please read our Privacy Policy for more details.

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

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

Developer.com content and product recommendations are editorially independent. We may make money when you click on links to our partners. Learn More .

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 Tutorial

Java methods, java classes, java file handling, java how to, 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.

• PyQt5 ebook
• Tkinter ebook
• SQLite Python
• wxPython ebook
• Windows API ebook
• Java Swing ebook
• Java games ebook
• MySQL Java ebook

Java operator

last modified January 27, 2024

In this article we show how to work with operators in Java.

An operator is a special symbol which indicates a certain process is carried out. Operators in programming languages are taken from mathematics. Programmers work with data. The operators are used to process data. An operand is one of the inputs (arguments) of an operator.

Expressions are constructed from operands and operators. The operators of an expression indicate which operations to apply to the operands. The order of evaluation of operators in an expression is determined by the precedence and associativity of the operators.

An operator usually has one or two operands. Those operators that work with only one operand are called unary operators . Those who work with two operands are called binary operators . There is also one ternary operator ?: which works with three operands.

Certain operators may be used in different contexts. For example the + operator. It can be used in different cases. It adds numbers, concatenates strings, or indicates the sign of a number. We say that the operator is overloaded .

Java sign operators

There are two sign operators: + and - . They are used to indicate or change the sign of a value.

The + and - signs indicate the sign of a value. The plus sign can be used to signal that we have a positive number. It can be omitted and it is mostly done so.

The minus sign changes the sign of a value.

Java assignment operator

The assignment operator = assigns a value to a variable. A variable is a placeholder for a value. In mathematics, the = operator has a different meaning. In an equation, the = operator is an equality operator. The left side of the equation is equal to the right one.

Here we assign a number to the x variable.

This expression does not make sense in mathematics, but it is legal in programming. The expression adds 1 to the x variable. The right side is equal to 2 and 2 is assigned to x.

This code line results in syntax error. We cannot assign a value to a literal.

Java concatenating strings

In Java the + operator is also used to concatenate strings.

We join three strings together.

Strings are joined with the + operator.

An alternative method for concatenating strings is the concat method.

Java increment and decrement operators

Incrementing or decrementing a value by one is a common task in programming. Java has two convenient operators for this: ++ and -- .

The above two pairs of expressions do the same.

In the above example, we demonstrate the usage of both operators.

We initiate the x variable to 6. Then we increment x two times. Now the variable equals to 8.

We use the decrement operator. Now the variable equals to 7.

And here is the output of the example.

Java arithmetic operators

The following is a table of arithmetic operators in Java.

The following example shows arithmetic operations.

In the preceding example, we use addition, subtraction, multiplication, division, and remainder operations. This is all familiar from the mathematics.

The % operator is called the remainder or the modulo operator. It finds the remainder of division of one number by another. For example, 9 % 4 , 9 modulo 4 is 1, because 4 goes into 9 twice with a remainder of 1.

Next we show the distinction between integer and floating point division.

In the preceding example, we divide two numbers.

In this code, we have done integer division. The returned value of the division operation is an integer. When we divide two integers the result is an integer.

If one of the values is a double or a float, we perform a floating point division. In our case, the second operand is a double so the result is a double.

We see the result of the program.

Java Boolean operators

In Java we have three logical operators. The boolean keyword is used to declare a Boolean value.

Boolean operators are also called logical.

Many expressions result in a boolean value. For instance, boolean values are used in conditional statements.

Relational operators always result in a boolean value. These two lines print false and true.

The body of the if statement is executed only if the condition inside the parentheses is met. The y > x returns true, so the message "y is greater than x" is printed to the terminal.

The true and false keywords represent boolean literals in Java.

The code example shows the logical and (&&) operator. It evaluates to true only if both operands are true.

Only one expression results in true .

The logical or ( || ) operator evaluates to true if either of the operands is true.

If one of the sides of the operator is true, the outcome of the operation is true.

Three of four expressions result in true .

The negation operator ! makes true false and false true.

The example shows the negation operator in action.

The || , and && operators are short circuit evaluated. Short circuit evaluation means that the second argument is only evaluated if the first argument does not suffice to determine the value of the expression: when the first argument of the logical and evaluates to false, the overall value must be false; and when the first argument of logical or evaluates to true, the overall value must be true. Short circuit evaluation is used mainly to improve performance.

An example may clarify this a bit more.

We have two methods in the example. They are used as operands in boolean expressions. We will see if they are called.

The One method returns false. The short circuit && does not evaluate the second method. It is not necessary. Once an operand is false, the result of the logical conclusion is always false. Only "Inside one" is only printed to the console.

In the second case, we use the || operator and use the Two method as the first operand. In this case, "Inside two" and "Pass" strings are printed to the terminal. It is again not necessary to evaluate the second operand, since once the first operand evaluates to true, the logical or is always true.

Java relational operators

Relational operators are used to compare values. These operators always result in a boolean value.

Relational operators are also called comparison operators.

In the code example, we have four expressions. These expressions compare integer values. The result of each of the expressions is either true or false. In Java we use the == to compare numbers. (Some languages like Ada, Visual Basic, or Pascal use = for comparing numbers.)

Java bitwise operators

Decimal numbers are natural to humans. Binary numbers are native to computers. Binary, octal, decimal, or hexadecimal symbols are only notations of a number. Bitwise operators work with bits of a binary number. Bitwise operators are seldom used in higher level languages like Java.

The bitwise negation operator changes each 1 to 0 and 0 to 1.

The operator reverts all bits of a number 7. One of the bits also determines whether the number is negative or not. If we negate all the bits one more time, we get number 7 again.

The bitwise and operator performs bit-by-bit comparison between two numbers. The result for a bit position is 1 only if both corresponding bits in the operands are 1.

The first number is a binary notation of 6, the second is 3 and the result is 2.

The bitwise or operator performs bit-by-bit comparison between two numbers. The result for a bit position is 1 if either of the corresponding bits in the operands is 1.

The result is 00110 or decimal 7.

The bitwise exclusive or operator performs bit-by-bit comparison between two numbers. The result for a bit position is 1 if one or the other (but not both) of the corresponding bits in the operands is 1.

The result is 00101 or decimal 5.

Java compound assignment operators

Compound assignment operators are shorthand operators which consist of two operators.

The += compound operator is one of these shorthand operators. The above two expressions are equal. Value 3 is added to the a variable.

Other compound operators are:

The following example uses two compound operators.

We use the += and *= compound operators.

The a variable is initiated to one. Value 1 is added to the variable using the non-shorthand notation.

Using a += compound operator, we add 5 to the a variable. The statement is equal to a = a + 5; .

Using the *= operator, the a is multiplied by 3. The statement is equal to a = a * 3; .

Java instanceof operator

The instanceof operator compares an object to a specified type.

In the example, we have two classes: one base and one derived from the base.

This line checks if the variable d points to the class that is an instance of the Base class. Since the Derived class inherits from the Base class, it is also an instance of the Base class too. The line prints true.

The b object is not an instance of the Derived class. This line prints false.

Every class has Object as a superclass. Therefore, the d object is also an instance of the Object class.

Java lambda operator

Java 8 introduced the lambda operator ( -> ).

This is the basic syntax for a lambda expression in Java. Lambda expression allow to create more concise code in Java.

The declaration of the type of the parameter is optional; the compiler can infer the type from the value of the parameter. For a single parameter the parentheses are optional; for multiple parameters, they are required.

The curly braces are optional if there is only one statement in an expression body. Finally, the return keyword is optional if the body has a single expression to return a value; curly braces are required to indicate that the expression returns a value.

In the example, we define an array of strings. The array is sorted using the Arrays.sort method and a lambda expression.

Lambda expressions are used primarily to define an inline implementation of a functional interface, i.e., an interface with a single method only. Interfaces are abstract types that are used to enforce a contract.

In the example, we create a greeting service with the help of a lambda expression.

Interface GreetingService is created. All objects implementing this interface must implement the greet method.

We create an object that implements GreetingService with a lambda expression. The object has a method that prints a message to the console.

We call the object's greet method, which prints a give message to the console.

There are some common functional interfaces, such as Function , Consumer , or Supplier .

The example uses a lambda expression to compute squares of integers.

Function is a function that accepts one argument and produces a result. The operation of the lamda expression produces a square of the given integer.

Java double colon operator

The double colon operator (::) is used to create a reference to a method.

In the code example, we create a reference to a static method with the double colon operator.

We have a static method that prints a greeting to the console.

Consumer is a functional interface that represents an operation that accepts a single input argument and returns no result. With the double colon operator, we create a reference to the greet method.

We perform the functional operation with the accept method.

Java operator precedence

The operator precedence tells us which operators are evaluated first. The precedence level is necessary to avoid ambiguity in expressions.

What is the outcome of the following expression, 28 or 40?

Like in mathematics, the multiplication operator has a higher precedence than addition operator. So the outcome is 28.

To change the order of evaluation, we can use parentheses. Expressions inside parentheses are always evaluated first. The result of the above expression is 40.

Java operators precedence list

The following table shows common Java operators ordered by precedence (highest precedence first):

Operators on the same row of the table have the same precedence. If we use operators with the same precedence, then the associativity rule is applied.

In this code example, we show a few expressions. The outcome of each expression is dependent on the precedence level.

This line prints 28. The multiplication operator has a higher precedence than addition. First, the product of 5*5 is calculated, then 3 is added.

In this case, the negation operator has a higher precedence than the bitwise OR. First, the initial true value is negated to false, then the | operator combines false and true, which gives true in the end.

Java associativity rule

Sometimes the precedence is not satisfactory to determine the outcome of an expression. There is another rule called associativity . The associativity of operators determines the order of evaluation of operators with the same precedence level.

What is the outcome of this expression, 9 or 1? The multiplication, deletion, and the modulo operator are left to right associated. So the expression is evaluated this way: (9 / 3) * 3 and the result is 9.

Arithmetic, boolean, relational, and bitwise operators are all left to right associated. The assignment operators, ternary operator, increment, decrement, unary plus and minus, negation, bitwise NOT, type cast, object creation operators are right to left associated.

In the example, we have two cases where the associativity rule determines the expression.

The assignment operator is right to left associated. If the associativity was left to right, the previous expression would not be possible.

The compound assignment operators are right to left associated. We might expect the result to be 1. But the actual result is 0. Because of the associativity. The expression on the right is evaluated first and then the compound assignment operator is applied.

Java ternary operator

The ternary operator ?: is a conditional operator. It is a convenient operator for cases where we want to pick up one of two values, depending on the conditional expression.

If cond-exp is true, exp1 is evaluated and the result is returned. If the cond-exp is false, exp2 is evaluated and its result is returned.

In most countries the adulthood is based on the age. You are adult if you are older than a certain age. This is a situation for a ternary operator.

First the expression on the right side of the assignment operator is evaluated. The first phase of the ternary operator is the condition expression evaluation. So if the age is greater or equal to 18, the value following the ? character is returned. If not, the value following the : character is returned. The returned value is then assigned to the adult variable.

A 31 years old person is adult.

Calculating prime numbers

In the following example, we are going to calculate prime numbers.

In the above example, we deal with several operators. A prime number (or a prime) is a natural number that has exactly two distinct natural number divisors: 1 and itself. We pick up a number and divide it by numbers from 1 to the selected number. Actually, we do not have to try all smaller numbers; we can divide by numbers up to the square root of the chosen number. The formula will work. We use the remainder division operator.

We will calculate primes from these numbers.

Values 0 and 1 are not considered to be primes.

We skip the calculations for 2 and 3. They are primes. Note the usage of the equality and conditional or operators. The == has a higher precedence than the || operator. So we do not need to use parentheses.

We are OK if we only try numbers smaller than the square root of a number in question.

This is a while loop. The i is the calculated square root of the number. We use the decrement operator to decrease i by one each loop cycle. When i is smaller than 1, we terminate the loop. For example, we have number 9. The square root of 9 is 3. We will divide the 9 number by 3 and 2. This is sufficient for our calculation.

If the remainder division operator returns 0 for any of the i values, then the number in question is not a prime.

In this article we covered Java expressions. We mentioned various types of operators and described precedence and associativity rules in expressions.

Java operators - tutorial

My name is Jan Bodnar and I am a passionate programmer with many years of programming experience. I have been writing programming articles since 2007. So far, I have written over 1400 articles and 8 e-books. I have over eight years of experience in teaching programming.

List all Java tutorials .

What Is Java Boolean And How To Use It

Java boolean, a fundamental data type, holds the key to decision-making in programming. This article elucidates the essentials of boolean in Java, from basic operations to best practices, tailored for developers aiming for clarity and efficiency in their code.

KEY INSIGHTS

• Boolean expressions are central to Java's control flow, serving as conditions in loops and conditional statements.
• Utilizing Java's boolean methods like `Boolean.valueOf()`, `Boolean.parseBoolean()`, enhances code functionality.
• Best practices in Java boolean include avoiding redundant checks and preferring `.equals()` over `==`.
• Common mistakes include overcomplicating boolean expressions and not initializing variables properly.

Java boolean is a fundamental data type that represents true or false values. It plays a crucial role in decision-making processes within your code. Grasping its concept and application is essential for efficient programming in Java. Let's explore its nuances and best practices together.

Basics Of Java Boolean

Declaring and initializing boolean variables, boolean operators and expressions, using boolean in conditional statements, boolean methods in java, common mistakes and best practices, frequently asked questions.

In Java, the boolean data type has only two possible values: true or false . It's not the same as an integer or a string. Instead, it's used primarily for flags that indicate whether a condition is true or not.

Declaring A Boolean Variable

Boolean expressions, truth tables.

For instance, when you compare two numbers, the result is a boolean value. This makes it a fundamental part of decision-making in Java.

To declare a boolean variable, you use the boolean keyword. Here's a simple example:

Boolean expressions are conditions that return a boolean value, either true or false . Commonly used in loops and conditional statements, they form the backbone of control flow in Java.

To understand boolean operations better, it's useful to refer to truth tables. Here's a basic truth table for the AND ( && ) operator:

Boolean data types and expressions form the foundation of logic in Java. By understanding them, you can create more efficient and readable code.

In Java, boolean variables are straightforward to declare and initialize. They are designed to hold one of two values: true or false . These values are not strings or numbers; they are distinct values that represent truthiness in Java.

Declaration

Initialization, default value, multiple declarations.

To declare a boolean variable, you use the boolean keyword followed by the variable name. At this point, the variable is declared but not initialized.

After declaring a boolean variable, you can initialize it by assigning a value to it. The value can either be true or false .

If you declare a boolean variable without initializing it, it will have a default value. For boolean data type, the default value is false .

You can declare and initialize multiple boolean variables in a single line. This can make your code more concise, especially when initializing multiple variables with the same value.

Understanding the declaration and initialization of boolean variables is crucial. It ensures that you're using them correctly in your code, leading to fewer bugs and clearer logic.

Boolean operators, often termed as logical operators , are used to perform operations on boolean values ( true and false ). They are essential tools in crafting conditions and making decisions in your Java programs.

Basic Operators

Logical and (&&), logical or (||), logical not (), complex expressions.

There are three primary boolean operators in Java:

• && - Logical AND
• || - Logical OR
• ! - Logical NOT

This operator returns true if both operands are true. Otherwise, it returns false .

The OR operator returns true if at least one of the operands is true. If both are false, it returns false .

The NOT operator inverts the value of a boolean. If the operand is true , it returns false and vice versa.

Understanding the outcomes of these operators can be simplified using truth tables:

| A | B | A && B | A || B | |-------|-------|--------|--------| | true | true | true | true | | true | false | false | true | | false | true | false | true | | false | false | false | false |

You can combine multiple boolean expressions using these operators to form more complex conditions.

Boolean operators and expressions are the building blocks of logic in Java. By mastering them, you can craft intricate conditions and enhance the decision-making capabilities of your programs.

Boolean values play a pivotal role in conditional statements in Java. These statements allow your program to make decisions and execute different code blocks based on the outcome of a boolean expression.

The if Statement

The if-else statement, the switch statement, ternary operator.

The most basic conditional statement is the if statement. It evaluates a boolean expression, and if that expression is true , the code inside the statement block is executed.

To handle both true and false outcomes, you can use the if-else statement.

While not exclusively for booleans, the switch statement can be used with boolean values, especially in more complex scenarios.

Another way to use booleans in conditional logic is the ternary operator. It's a shorthand for if-else and returns a value based on a boolean expression.

Using boolean values in conditional statements is fundamental in Java. It allows your program to react dynamically to different situations, making your applications more flexible and responsive.

Java provides a set of built-in methods specifically designed for boolean data types. These methods can be extremely useful when working with boolean values, allowing for more advanced operations and manipulations.

Boolean.valueOf()

Boolean.parseboolean(), boolean.tostring(), boolean.compare(), boolean.logicalxor().

This method returns a Boolean instance representing the specified boolean value. It can accept a string argument as well.

This method parses the string argument as a boolean. It's case-insensitive and only returns true if the string argument is not null and is equal, ignoring case, to the string "true".

Converts the boolean value to its string representation.

Compares two boolean values. It's useful for sorting or comparison operations.

Performs a logical XOR on two boolean values. It returns true if exactly one of the arguments is true .

Working with boolean values in Java is generally straightforward, but there are some common pitfalls that developers might encounter. Being aware of these mistakes and adhering to best practices can save time and reduce bugs in your code.

Using == Instead of .equals()

Avoiding redundant checks, not initializing boolean variables, overcomplicating boolean expressions, best practices.

For Boolean objects, always use .equals() for comparison instead of == .

Sometimes, developers write redundant boolean checks. For instance:

Always initialize boolean variables. Uninitialized local boolean variables can lead to compilation errors.

Keep boolean expressions simple and readable. Avoid nesting too many conditions.

• Descriptive Variable Names : Always use descriptive names for boolean variables, like isAvailable , hasPermission , etc.
• Use Ternary Operators Sparingly : While they can make code concise, overuse can reduce readability.
• Group Conditions with Parentheses : When combining multiple conditions, use parentheses to clarify the order of evaluation.

Can I use numbers like 0 or 1 instead of true and false for boolean values in Java?

No, Java strictly uses true and false for boolean values. Unlike some languages, 0 and 1 are not substitutes for false and true, respectively.

How can I convert a string to a boolean in Java?

You can use the Boolean.parseBoolean(String s) method. It's case-insensitive and will return true only if the string is "true".

Can I use boolean values in switch statements?

No, switch statements in Java do not support boolean values. They work with byte, short, char, int, and their respective wrapper classes, along with enums and strings.

Why is my Boolean object comparison using '==' not working as expected?

The '==' operator compares object references, not the content. For Boolean objects, always use the .equals() method for content comparison.

What is short-circuit evaluation in the context of boolean operations?

Short-circuit evaluation means that the second operand in a boolean operation ( && or || ) is evaluated only if necessary. For example, in the expression (false && x) , x is never evaluated because the result is false regardless of x .

Let’s test your knowledge!

Which of the following is NOT a valid boolean value in Java?

Continue learning with these java guides.

• How To Make A Game With Java: Step-By-Step Instructions
• What Is The Modulo Operator (%) In Java And How To Use It
• How To Make A GUI In Java: Step-By-Step Approach
• How To Import A Class In Java: Straightforward Steps
• How To Parse String In Java

Subscribe to our newsletter

Subscribe to be notified of new content on marketsplash..

• Blogs by Topic

The IntelliJ IDEA Blog

IntelliJ IDEA – the Leading Java and Kotlin IDE, by JetBrains

• Twitter Twitter
• Facebook Facebook
• Youtube Youtube

Java 22 and IntelliJ IDEA

Java 22 is here, fully supported by IntelliJ IDEA 2024.1 , allowing you to use these features now!

Java 22 has something for all – from new developers to Java experts, features related to performance and security for big organizations to those who like working with bleeding edge technology, from additions to the Java language to improvements in the JVM platform, and more.

It is also great to see how all these Java features, release after release, work together to create more possibilities and have a bigger impact on how developers create their applications that address existing pain points, perform better and are more secure.

This blog post doesn’t include a comprehensive coverage of all the Java 22 features. If you are interested in that, I’d recommend you to check out this link to know everything about what’s new and changing in Java 22, including the bugs.

In this blog post, I’ll cover how IntelliJ IDEA helps you get started, up and running with some of the Java 22 features, such as, String Templates , Implicitly Declared Classes and Instance Main Methods , Statements before super() , and Unnamed variables and patterns .

Over the past month, I published separate blog posts to cover each of these topics in detail. If you are new to these topics, I’d highly recommend you check out those detailed blog posts (I’ve included their links in the relevant subsections in this blog post). In this blog post, I’ll cover some sections from those blog posts, especially how IntelliJ IDEA supports them. Let’s start by configuring IntelliJ IDEA to work with the Java 22 features.

IntelliJ IDEA Configuration

Java 22 support is available in IntelliJ IDEA 2024.1 Beta . The final version will release soon in March 2024.

In your Project Settings, set the SDK to Java 22. For the language level, select ‘22 (Preview) – Statements before super(), string templates (2nd preview etc.)’ on both the Project and Modules tab, as shown in the below settings screenshot:

If you do not have Java 22 downloaded to your system yet, don’t worry; IntelliJ IDEA has your back! You could use the same Project settings window, select ‘Download JDK’, after you click on the drop down next to SDK. You’ll see the below popup that would enable you to choose from a list of vendors (such as Oracle OpenJDK, GraalVM, Azul Zulu and others):

With the configuration under our belt, let’s get started with covering one of my favorite new features, that is, String Templates.

String Templates (Preview Language feature) The existing String concatenation options are difficult to work with and could be error prone; String templates offer a better alternative, that is, String interpolation with additional benefits such as validation, security and transformations via template processors.

Please check out my detailed blog post on this topic: String Templates in Java – why should you care? if you are new to this topic. It covers all the basics, including why you need String Templates, with multiple hands-on examples on built-in and user defined String processors.

IntelliJ IDEA can highlight code that could be replaced with String Templates Let’s assume you defined the following code to log a message that combines string literals and variable values using the concatenation operator:

The output from the preceding code could be an issue if you miss adding spaces in the String literals. The code isn’t quite easy to read or understand due to multiple opening and closing double quotes, that is, " and the + operator, and it would get worse if you add more literals, or variable values to it.

You could replace the preceding code with either StringBuilder.append() , String.format() or String.formatted() method or by using the class MessageFormat (as shown in my detailed blog post on this topic), but each of these methods have their own issues.

Don’t worry; IntelliJ IDEA could detect such code, suggest that you could replace it with String template, and do that for you, as shown below. It doesn’t matter if you are not even aware of the syntax of the String templates, IntelliJ IDEA has your back 🙂

Embedded expressions in String Templates and IntelliJ IDEA The syntax to embed a remplate expression (variable, expressible or a method call) is still new to what Java developers are used to and could be challenging to use without help. Don’t worry, IntelliJ IDEA has your back!

Each embedded expression must be enclosed within \{}. When you type \{, IntelliJ IDEA adds the closing ‘}’ for you. It also offers code completion to help you select a variable in scope, or any methods on it. If the code that you insert doesn’t compile, IntelliJ IDEA will highlight that too (as a compilation error), as shown in the following gif:

Using String Templates with Text Blocks Text blocks are quite helpful when working with string values that span multiple lines, such as, JSON, XML, HTML, SQL or other values that are usually processed by external environments. It is common for us Java developers to create such string values using a combination of string literals and variable values (variables, expressions or method calls).

The example below shows how IntelliJ IDEA could detect and create a text block using String templates for multiline string values that concatenates string literals with variable values. It also shows how IntelliJ IDEA provides code completion for variable names within such blocks. When you type in \{ , IntelliJ IDEA adds } . As you start typing the variable name countryName , it shows the available variables in that context:

Language injection and String Templates You could also inject a language or a reference in string values that spans single line or multiple lines, such as, a text block. By doing so, you get comprehensive coding assistance to edit the literal value. You could avail of this feature temporarily or permanently by using the @Language annotation, as shown below:

You can check out this link for detailed information on the benefits and usage of injecting language or reference in IntelliJ IDEA.

Predefined Template Processors With the String templates, you get access to predefined processors like the STR , FMT and RAW . I’d highly recommend you to check out my detailed blog post on String templates for multiple hands-on examples on it.

Custom Template Processor

Let’s work with a custom String template that isn’t covered in my previous blog post.

Imagine you’d like to create an instance of a record, say, WeatherData , that stores the details of the JSON we used in the previous section. Assume you define the following records to store this weather data represented by the JSON in the previous section:

You could create a method to return a custom String template that would process interpolated string, accept a class name ( WeatherData for this example) and return its instance:

Depending on the logic of your application, you might want to escape, delete or throw errors for the special characters that you encounter in the the JSON values interpolated via template expressions, as follows (the following method chooses to escape the special characters and include them as part of the JSON value):

You could initialize and use this custom JSON template processor as below. Note how elegant and concise the solution is with a combination of textblocks and String templates. The JSON is easy to read, write and understand (thanks to text blocks). The template expressions make it clear and obvious about the sections that are not constants and would be injected by the variables. At the end, the custom template processor WEATHER_JSON would ensure the resultant JSON is validated according to the logic you defined and returns an instance of WeatherData (doesn’t it sound magical?) :

Do not miss to check out my detailed blog post on this topic: String Templates in Java – why should you care? to discover how you could use the predefined String templates like FMT , to generate properly formatted receipts for, say, your neighborhood stationery store, or, say encode and decode combinations like :) or :( to emojis like 🙂 or ☹️. Does that sound fun to you?

Implicitly Declared Classes and Instance Main Methods (Preview language feature)

Introduced as a preview language feature in Java 21, this feature is in its second preview in Java 22.

It would revolutionize how new Java developers would get started learning Java. It simplifies the initial steps for students when they start learning basics, such as variable assignment, sequence, conditions and iteration. Students no longer need to declare an explicit class to develop their code, or write their main() method using this signature – public static void main(String []) . With this feature, classes could be declared implicitly and the main() method can be created with a shorter list of keywords.

If you are new to this feature, I’d highly recommend you to check out my detailed blog post: ‘HelloWorld’ and ‘main()’ meet minimalistic on this feature. In this blog post, I’ll include a few of the sections from it.

Class ‘HelloWorld’ before and after Java 21

Before Java 21, you would need to define a class, say, HelloWorld , that defined a main() method with a specific list of keywords, to print any text, say, ‘Hello World’ to the console, as follows:

With Java 21, this initial step has been shortened. You can define a source code file, say, HelloWorld.java, with the following code, to print a message to the console (it doesn’t need to define a class; it has a shorter signature for method main() ):

The preceding code is simpler than what was required earlier. Let’s see how this change could help you focus on what you need, rather than what you don’t.

Compiling and executing your code

Once you are done writing your code, the next step is to execute it.

On the command prompt, you could use the javac and java commands to compile and execute your code. Assuming you have defined your code in a source code file HelloWorld.java, you could use the following commands to run and execute it:

Since Java 11, it is possible to skip the compilation process for code defined in a single source code file, so you could use just the second command (by specifying the name of the source code file, as follows):

However, since instance main methods and implicit classes is a preview language feature, you should add the flag --enable-preview with --source 22 with these commands, as follows:

Sooner or later, you might switch to using an IDE to write your code. If you wish to use IntelliJ IDEA for creating instance main methods, here’s a quick list of steps to follow. Create a new Java project, select the build system as IntelliJ (so you could use Java compiler and runtime tools), create a new file, say, HelloWorld.java with your instance main method and set the properties to use Java 22, before you run your code, as shown in the following gif (It could save you from typing out the compilation/ execution commands on the command prompt each time you want to execute your code):

Are you wondering if it would be better to create a ‘Java class’ instead of a ‘File’ in the ‘src’ folder? The option of selecting a Java class would generate the body of a bare minimum class, say, public class HelloWorld { } . Since we are trying to avoid unnecessary keywords in the beginning, I recommended creating a new ‘File’ which wouldn’t include any code.

What else can main() do apart from printing messages to the console?

As included in my detailed post on this topic , I included multiple hand-on examples to show what you could achieve via just the main() method:

• Example 1. Variable declarations, assignments and simple calculations
• Example 2. Print patterns, such as, big letters using a specified character
• Example 3. Animating multiline text – one word at a time
• Example 4. Data structure problems
• Example 5. Text based Hangman game

The idea to include multiple examples as listed above is to demonstrate the power of sequence, condition and iteration all of which can be included in the main() method, to build good programming foundations with problem solving skills. By using the run command or the icon to run and execute their code in IntelliJ IDEA, new programmers reduce another step when getting started.

Changing an implicit class to a regular class

When you are ready to level up and work with other concepts like user defined classes, you could also covert the implicit classes and code that we used in the previous examples, to regular classes, as shown below:

What happens when you create a source code file with method main(), but no class declaration?

Behind the scenes, the Java compiler creates an implicit top level class, with a no-argument constructor, so that these classes don’t need to be treated in a way that is different to the regular classes.

Here’s a gif that shows a decompiled class for you for the source code file AnimateText.java:

Variations of the main method in the implicit class

As we are aware, a method can be overloaded. Does that imply an implicit class can define multiple main methods? If yes, which one of them qualifies as the ‘main’ method? This is an interesting question. First of all, know that you can’t define a static and non-static main method with the same signature, that is, with the same method parameters. The following method are considered valid main() methods in an implicit class:

If there is no valid main method detected, IntelliJ IDEA could add one for you, as shown in the following gif:

Educators could use this feature to introduce other concepts to the students in an incremental way

If you are an educator, you could introduce your students to other commonly used programming practices, such as creating methods- that is delegating part of your code to another method and calling it from the main method. You could also talk about passing values vs. variables to these methods.

The following gif shows how to do it:

Statements before super() – a preview language feature

Typically, we create alternative solutions for tasks that are necessary, but not officially permitted. For instance, executing statements before super() in a derived class constructor was not officially allowed, even though it was important for, say, validating values being passed to the base class constructor. A popular workaround involved creating static methods to validate values and then calling these methods on the arguments of super() . Though this approach worked well, it could make the code look complicated. This is changing with Statements before super() , a preview language feature in Java 22.

By using this feature, you can opt for a more direct approach, that is, drop the workaround of creating static methods, and execute code that validates arguments, just before calling super() . Terms and conditions still apply, such as, not accessing instance members of a derived class before execution of super() completes.

An example – Validating values passed to super() in a derived class constructor Imagine you need to create a class, say, IndustryElement , that extends class Element , which is defined as follows:

The constructor of the class Element misses checking if the atomicNumber is in the range of 1-118 (all known elements have atomic numbers between 1 to 118). Often the source code of a base class is not accessible or open for modification. How would you validate the values passed to atomicNumber in the constructor of class IndustryElement ?

Until Java 21, no statements were allowed to execute before super() . Here’s one of the ways we developers found a workaround by defining and calling static methods (static methods belong to a class and not to instances and can be executed before any instance of a class exists):

Starting Java 22, you could inline the contents of your static method in the constructor for your derived class, as shown in the following gif:

Here’s the resultant code for your reference:

Where else would you use this feature? If you are new to this feature, I’d recommend that you check out my detailed blog post, Constructor Makeover in Java 22 , in which I’ve covered this feature in detail using the following examples:

• Example 2 – base class constructor parameters that use annotations for validations
• Example 3 – Transforming variable values received in a derived class constructor, before calling a base class constructor.
• Example 4 – Executing statements before this() in constructor of Records
• Example 5 – Executing statements before this() in Enum constructors
• Example 6 – Executing statements before this() in classes

How does it work behind the scenes? The language syntax has been relaxed but it doesn’t change or impact the internal JVM instructions. There are no changes to the JVM instructions for this new feature because the order of execution of the constructors still remains unchanged – from base class to a derived class. Also, this feature still doesn’t allow you to use members of a derived class instance, until super() executes.

Let’s access and compare the instruction set of the constructor of class IndustryElement , before and after its modification – one that can execute statements before super() and the one that doesn’t. To do so, use the following command:

Here’s the instruction set for the constructor that doesn’t explicitly execute statements before super() and calls static methods to validate range of atomic number:

Here’s instruction set for the constructor that explicitly executes statements before super() to validate range of atomic number:

The most important point to note here is that in both the cases, the constructor of the base class, that is, Element is called, after the execution of all other statements. Essentially, it means, you are still doing the same thing, it is just packaged in a way that makes things easier for you.

I understand it is difficult to remember what each of these instruction codes means. Access the following link and search for the instruction code and following the above instructions set would be a breeze:

https://docs.oracle.com/javase/specs/jvms/se21/html/jvms-6.html#jvms-6.5.aload_n

Can you execute ‘any’ statements before calling super()?

No. If the statements before super() try to access instance variables or execute methods of your derived class, your code won’t compile. For example, if you change the static checkRange() method to an instance method, your code won’t compile, as shown below:

Unnamed Variables and Patterns

Starting Java 22, using Unnamed Variables & Patterns you can mark unused local variables, patterns and pattern variables to be ignored, by replacing their names (or their types and names) with an underscore, that is, _ . Since such variables and patterns no longer have a name, they are referred to as Unnamed variables and patterns. Ignoring unused variables would reduce the time and energy anyone would need to understand a code snippet. In the future, this could prevent errors :-). This language feature doesn’t apply to instance or class variables.

Are you wondering if replacing unused variables with _ is always a good idea, or do they imply code smells and should you consider refactoring your codebase to remove them? Those are good questions to ask. If you are new to this topic, I’d recommend you to check out my detailed blog post: Drop the Baggage: Use ‘_’ for Unnamed Local Variables and Patterns in Java 22 to find out answer to this question.

Since this is not a preview language feature, set Language Level in your Project Settings to ‘22 – Unnamed variables and patterns’ on both the Project and Modules tab, as shown in the below settings screenshot:

A quick example

The following gif gives a sneak peek into how an unused local variable, connection, is detected by IntelliJ IDEA, and could be replaced with an underscore, that is, _ .

The modified code shown in the preceding gif makes it clear that the local variable defined in the try-with-resources statement is unused, making it concise and easier to understand.

Unused Patterns and Pattern variables in switch constructs

Imagine you defined a sealed interface, say, GeometricShape , and records to represent shapes, such as, Point , Line , Triangle , Square , as shown in the following code:

Now assume you need a method that accepts an instance of GeometricShape and returns its area. Since Point and a Line are considered one-dimensional shapes, they wouldn’t have an area. Following is one of the ways to define such method that calculates and returns area:

In the previous example, the patterns int x , int y , Point a and Point B (for case label Line) remain unused as detected by IntelliJ IDEA. These could be replaced by an _ . Also, since all the record components of the case Point remain unused, it could be replaced as Point _ . This could also allow us to merge the first and second case labels. All of these steps are shown in the following gif:

Here’s the modified code for your reference:

In the preceding example, you can’t delete the pattern variables even if they are unused. The code must include the cases when the instance passed to the method calcArea() is of type Point and Line , so that it could return 0 for them.

Unused Patterns or variables with nested records

This feature also comes in quite handy for nested records with multiple unused patterns or pattern variables, as demonstrated using the following example code:

In the preceding code, since the if condition in the method checkFirstNameAndCountryCodeAgain uses only two pattern variables, others could be replaced using _ ; it reduced the noise in the code too.

Where else can you use this feature? Checkout my detailed detailed blog post: Drop the Baggage: Use ‘_’ for Unnamed Local Variables and Patterns in Java 22 to learn more about other use cases where this feature can be used:

• Requirements change, but you need side effects of constructs like an enhanced for-loop
• Unused parameters in exception handlers; whose signature can’t be modified
• Unused auto-closeable resources in try-with-resources statements

It isn’t advisable to use this feature without realising if an unused variable or pattern is a code smell or not. I used these examples to show that at times it might be better to refactor your code to get rid of the unused variable instead of just replacing it with an underscore, that is, _ .

• Unused lambda parameter
• Methods with multiple responsibilities

Preview Features

‘String Templates’, ‘Implicitly Declared Classes and Instance Main Methods’ and ‘Statements before super()’ are preview language features in Java 22. With Java’s new release cadence of six months, new language features are released as preview features. They may be reintroduced in later Java versions in the second or more preview, with or without changes. Once they are stable enough, they may be added to Java as a standard language feature.

Preview language features are complete but not permanent, which essentially means that these features are ready to be used by developers, although their finer details could change in future Java releases depending on developer feedback. Unlike an API, language features can’t be deprecated in the future. So, if you have feedback about any of the preview language features, feel free to share it on the JDK mailing list (free registration required).

Because of how these features work, IntelliJ IDEA is committed to only supporting preview features for the current JDK. Preview language features can change across Java versions, until they are dropped or added as a standard language feature. Code that uses a preview language feature from an older release of the Java SE Platform might not compile or run on a newer release.

In this blog post, I covered four Java 22 features – String Templates , Implicitly Declared Classes and Instance Main Methods , Statements before super() , and Unnamed variable and patterns .

String Templates is a great addition to Java. Apart from helping developers to work with strings that combine string constants and variables, they provide a layer of security. Custom String templates can be created with ease to accomplish multiple tasks, such as, to decipher letter combinations, either ignoring them or replacing them for added security.

Java language designers are reducing the ceremony that is required to write the first HelloWorld code for Java students, by introducing implicitly declared classes and instance main methods. New students can start with bare minimum main() method, such as, void main() and build strong programming foundation by polishing their skills with basics like sequence, selection and iteration.

In Java 22, the feature Statements before super() lets you execute code before calling super() in your derived class constructors, this() in your records or enums, so that you could validate the method parameters, or transform values, as required. This avoids creating workarounds like creating static methods and makes your code easier to read and understand. This feature doesn’t change how constructors would operate now vs. how they operated earlier – the JVM instructions remain the same.

Unnamed variables are local to a code construct, they don’t have a name, and they are represented by using an underscore, that is, _ . They can’t be passed to methods, or used in expressions. By replacing unused local variables in a code base with _ their intention is conveyed very clearly. It clearly communicates to anyone reading a code snippet that the variable is not used elsewhere. Until now, this intention could only be communicated via comments, which, unfortunately, all developers don’t write.

Happy Coding!

Subscribe to IntelliJ IDEA Blog updates

By submitting this form, I agree that JetBrains s.r.o. ("JetBrains") may use my name, email address, and location data to send me newsletters, including commercial communications, and to process my personal data for this purpose. I agree that JetBrains may process said data using third-party services for this purpose in accordance with the JetBrains Privacy Policy . I understand that I can revoke this consent at any time in my profile . In addition, an unsubscribe link is included in each email.

Thanks, we've got you!

Discover more

Java Frameworks You Must Know in 2024

Many developers trust Java worldwide because it is adaptable, secure, and versatile, making it perfect for developing various applications across multiple platforms. It also stands out for its readability and scalability. What are frameworks? Why do you need them? Since Java has a long history…

Java Annotated Monthly – April 2024

Welcome to this month’s Java Annotated Monthly, where we’ll cover the most prominent updates, news, and releases in March. This edition is truly special because it introduces a new section – Featured content, where we invite influential people from the industry to share a personal selection of inter…

Getting Started with Databases in IntelliJ IDEA 

Have you ever wondered how IntelliJ IDEA handles databases? Well, today is the perfect opportunity to find out in our database tutorial on initial setups and first steps.   All of the features you’ll need when working with databases are available out of the box in IntelliJ IDEA Ultimate…

Easy Hacks: How to Throw Java Exceptions

Exceptions in Java are used to indicate that an event occurred during the execution of a program and disrupted the normal flow of instructions. When an exception occurs, the Java runtime automatically stops the execution of the current method. It passes an exception object with information about the…

Java Operators MCQs (Multiple Choice Questions)

Java, one of the most widely used programming languages, offers a rich set of operators to perform various operations, from basic arithmetic to complex logical evaluations. Understanding these operators and their precedence is crucial for anyone looking to master Java programming. To aid in this journey, we have compiled a meticulously curated set of multiple-choice questions (MCQs) focusing on Java Operators. This collection spans from the foundational arithmetic and relational operators to the more nuanced conditional and bitwise operators. Whether you’re a novice programmer aiming to solidify your Java fundamentals or an experienced developer looking to brush up on the intricacies of Java operators, this guide is tailored to enhance your knowledge and test your skills.

Q1 Which operator is used to compare two values for equality in Java?

A = B == C === D <>

Q2 What is the output of the expression ’10 % 3′?

A 3 B 1 C 0 D 10

Q3 Which operator is used for string concatenation in Java?

A + B & C && D .

Q4 What does the ‘++’ operator do to a variable?

A Decreases its value by 1 B Increases its value by 1 C Doubles its value D Squares its value

Q5 Which of the following is the correct way to use the ternary operator?

A var result = (condition) ? valueIfTrue : valueIfFalse; B var result = (condition, valueIfTrue, valueIfFalse); C var result = ?(condition) valueIfTrue : valueIfFalse; D var result = if(condition) ? valueIfTrue : valueIfFalse;

Q6 What is the result of the expression ‘5 == 5’?

A true B false C 1 D 0

Q7 Which operator checks if two variables refer to the same object instance?

A == B === C equals() D instanceof

Q8 What is the result of the expression ‘!true’?

Q9 What is the precedence order of the operators: *, +, and ()?

A +, *, () B *, +, () C (), *, + D (), +, *

Q10 Which operator is used to invert the value of a boolean variable?

A ~ B ! C – D ^

Q11 Which of the following operators has the highest precedence in Java?

A && B + C / D ++

Q12 What does the expression ‘x &= y’ do?

A Sets x to the result of x AND y B Sets x to the result of x OR y C Sets x to the result of x XOR y D Compares x and y for equality

Q13 Which of the following is true about the ‘instanceof’ operator?

A It is used to compare numerical values B It is used for arithmetic operations C It checks if an object is an instance of a specific class or interface D It concatenates strings

Q14 Which of the following is a unary operator in Java?

A + B – C / D *

Q15 What is the output of ‘1 << 2'?

A 1 B 2 C 3 D 4

Q16 What is the output of the following code snippet?

A 15 B 16 C 17 D 18

Q17 How do you perform a bitwise OR operation between two integers x and y?

A x || y B x | y C x OR y D x + y

Q18 Which operator is used for type casting in Java?

A cast B instanceof C () D typeof

Q19 What is the result of the expression ‘null instanceof Object’?

A true B false C NullPointerException D Compilation error

Q20 What does the expression ‘var a = 20; var b = a << 2;' set 'b' to?

A 5 B 40 C 80 D 100

Q21 Which of the following is NOT a relational operator in Java?

A B >= C == D =>

Q22 What is the use of the operator ‘?:’ in Java?

A To perform logical operations B To perform exponential calculations C To assign a value based on a condition D To concatenate strings

Q23 What does the ‘>>>=’ assignment operator do?

A Performs a right shift and assigns the result B Performs a left shift and assigns the result C Performs an unsigned right shift and assigns the result D Performs an unsigned left shift and assigns the result

Q24 Which operator is used to determine if an object is of a certain type (class) at runtime?

A == B != C instanceof D getClass()

Q25 What does the expression ‘true || false’ evaluate to in Java?

A true B false C 0 D 1

Q26 Which of the following is the correct use of the bitwise XOR operator in Java?

A int result = x ~ y; B int result = x ^ y; C int result = x | y; D int result = x && y;

Q27 What is the result of the following operation: ‘4 | 3’?

A 0 B 7 C 1 D 12

Q28 In Java, what does the ‘>>>=’ operator do?

A Performs a right arithmetic shift and assigns the result B Performs a left arithmetic shift and assigns the result C Performs an unsigned right shift and assigns the result D Performs an unsigned left shift and assigns the result

Navigating through the realm of Java operators is a fundamental step towards mastering Java programming. The provided MCQs offer a panoramic view of Java’s operator capabilities, from manipulating numbers and strings to making complex decisions based on various conditions. Engaging with these questions not only reinforces theoretical concepts but also sharpens practical problem-solving skills. As you progress, remember that the understanding of operators extends beyond their individual functionality; it’s about recognizing their role in the broader context of Java programming paradigms. We encourage learners to delve deeper into each topic, experiment with code examples, and continuously challenge their understanding. This exploration is not just about passing a test; it’s about laying a solid foundation for your Java programming journey.

Related Posts

Mastering Linux Challenge 001 – Is the execution time of crontab correct?

The Role of Linux in the Internet of Things (IoT): Opportunities and Challenges

Linux system administration basics mcq (module 1).

Save my name, email, and website in this browser for the next time I comment.

Type above and press Enter to search. Press Esc to cancel.

• SQL Cheat Sheet
• SQL Interview Questions
• MySQL Interview Questions
• PL/SQL Interview Questions
• Learn SQL and Database
• Aggregation Pipeline Stages in MongoDB - Set 1
• Aggregation Pipeline Stages in MongoDB - Set 2
• PyMongoArrow: Export and Import MongoDB data to Pandas DataFrame and NumPy
• MongoDB Queries Document
• How to Enable Authentication on MongoDB ?
• MongoDB - dropIndexes() Method
• How to Use Go With MongoDB?
• MongoDB - sort() Method
• $substrCP (aggregation) operator in MongoDB
• MongoDB $arrayElemAt Operator
• MongoDB $concatArrays Operator
• MongoDB $isArray Operator
• MongoDB $strcasecmp Operator
• MongoDB $toUpper Operator
• MongoDB $toLower Operator
• MongoDB $divide Operator
• MongoDB $ln Operator
• Indexing in MongoDB
• MongoDB Tutorial in Java

How to Query MongoDB Documents with Regex in Python?

MongoDB is a popular NoSQL database known for its flexibility and scalability . One of its powerful features is the ability to query documents using regular expressions (regex) in Python. Regex allows you to perform pattern-based searches within your MongoDB collections, providing a flexible and efficient way to retrieve data. In this article, we’ll explore how to leverage regex queries in Python to harness the full potential of MongoDB.

What is Regex?

Before diving into MongoDB’s regex queries, let’s briefly understand what regex is. Regex, short for regular expression, is a sequence of characters that define a search pattern. It’s commonly used for string manipulation tasks like searching , matching , and replacing patterns within text.

Setting Up MongoDB and Python

Before we start querying MongoDB with regex in Python, ensure you have MongoDB installed on your system and the PyMongo library for Python . You can install PyMongo using a pip .

Make sure your MongoDB server is up and running, and you have a collection of documents to query.

Connecting to MongoDB

First, let’s establish a connection to our MongoDB database using PyMongo.

Replace “your_database” with the name of your MongoDB database .

Basic Querying with Regex

Now, let’s say we have a collection named “ users ” containing documents with a “ name ” field. We want to retrieve all documents where the name starts with “ J “. Here’s how we can do it using regex:

In this example, ^J is our regex pattern, which matches strings that start with the letter “ J “. We use re.compile() to compile the regex pattern, and then we pass it to the find() method of the collection to perform the query.

Advanced Regex Queries

Regex offers a wide range of pattern-matching capabilities. Here are a few examples of more advanced regex queries:

Using the $regex Operator

In PyMongo , you can use the $regex operator to perform regex queries. This operator allows you to specify a regex pattern within your query.

Creating a Case-Sensitive Regex Pattern

To create a case-sensitive regex pattern in PyMongo , you can use the re.compile() function and specify the re.IGNORECASE flag.

Creating a Regex Query for an Exact Match

If you want to perform a regex query for an exact match, you can specify the complete pattern within the $regex operator.

Creating a Case-Insensitive Regex Query Using $options

In PyMongo, you can use the $options modifier within the $regex operator to perform a case-insensitive regex query.

Creating a Regex Query Without Using the $regex Operator

Alternatively, you can use Python’s built-in regex functionality without directly using the $regex operator in PyMongo .

By incorporating these advanced regex querying techniques into your PyMongo code, you can perform a wide range of pattern-based searches within your MongoDB collections, catering to various use cases and requirements. Whether you need case-sensitive or case-insensitive matching, exact matches, or complex pattern searches, PyMongo’s regex capabilities enable you to efficiently retrieve the data you need from your MongoDB databases.

Regular expressions provide a powerful way to query MongoDB documents in Python . By leveraging regex patterns, you can perform complex searches and retrieve specific data from your collections efficiently. Whether you’re looking for exact matches or patterns within strings , regex offers the flexibility you need to handle diverse querying requirements in MongoDB . With the examples provided in this article, you’re well-equipped to harness the full potential of regex queries in MongoDB with Python.

Please Login to comment...

Similar reads.

• What are Tiktok AI Avatars?
• Poe Introduces A Price-per-message Revenue Model For AI Bot Creators
• Truecaller For Web Now Available For Android Users In India
• Google Introduces New AI-powered Vids App
• 30 OOPs Interview Questions and Answers (2024)

Improve your Coding Skills with Practice

What kind of Experience do you want to share?