DEV Community: Rajesh Bhola

Relational Operators in Java

Rajesh Bhola — Sat, 11 Jul 2026 15:51:59 +0000

Relational operators are used to compare two values in Java. They help determine whether one value is greater than, less than, or equal to another value.

These operators are commonly used in if statements, loops, conditional expressions, and decision-making logic.

Although they look simple, relational operators have a few important rules that every Java developer should know—especially for interviews.

Let's explore them with simple explanations and practical examples.

What Are Relational Operators?

Java provides four relational operators.

Operator	Description
`<`	Less than
`<=`	Less than or equal to
`>`	Greater than
`>=`	Greater than or equal to

Each relational operator compares two operands and always returns a boolean value (true or false).

Example

System.out.println(10 < 20);
System.out.println(20 >= 20);
System.out.println(50 > 100);

Output

true
true
false

Rule 1: Relational Operators Work on All Primitive Types Except `boolean`

Relational operators can be applied to every primitive data type except boolean.

Supported primitive types include:

byte
short
int
long
float
double
char

Valid Examples

System.out.println(10 < 10.5);

Output

true

System.out.println('a' > 100.5);

Output

false

Explanation

'a' = 97

97 > 100.5

↓

false

System.out.println('b' > 'a');

Output

true

Explanation

'b' = 98
'a' = 97

98 > 97

↓

true

System.out.println('A' < 'a');

Output

true

Explanation

'A' = 65
'a' = 97

65 < 97

↓

true

Invalid Example

System.out.println(true > false);

Compile-time error

bad operand types for binary operator '>'

Why?

The values true and false are logical values, not numeric values.

Since there is no mathematical concept of greater than or less than between boolean values, Java does not allow relational operators on boolean.

Rule 2: Relational Operators Cannot Be Applied to Objects

Relational operators work only on primitive numeric values.

They cannot be used with objects such as:

String
Integer
Employee
Any user-defined class

Example

System.out.println("rajesh123" > "rajesh");

Compile-time error

bad operand types for binary operator '>'

Why?

Although "rajesh123" is longer than "rajesh", Java does not compare objects using relational operators.

For strings, use the compareTo() method instead.

Example

System.out.println("apple".compareTo("banana"));

Output

-1

Similarly,

System.out.println("banana".compareTo("apple"));

Output

And,

System.out.println("java".compareTo("java"));

Output

Rule 3: Nesting Relational Operators Is Not Allowed

Many beginners try to write mathematical expressions like this:

System.out.println(10 > 20 > 30);

This results in a compile-time error.

Why?

Java evaluates relational operators from left to right.

So the expression becomes

(10 > 20) > 30

The first comparison is

10 > 20

↓

false

Now Java tries to evaluate

false > 30

which is equivalent to

boolean > int

This is invalid.

Compile-time error

bad operand types for binary operator '>'

Correct Way to Write Multiple Comparisons

Instead of

10 < 20 < 30

write

(10 < 20) && (20 < 30)

Output

true

This is the correct way to express mathematical chain comparisons in Java.

Character Comparisons

Since the char data type stores Unicode values internally, characters can be compared using relational operators.

Example

System.out.println('b' > 'a');

Output

true

because

98 > 97

System.out.println('A' < 'a');

Output

true

because

65 < 97

System.out.println('z' > 'm');

Output

true

because

122 > 109

Common Beginner Mistakes

Comparing Strings Using `>`

Incorrect

String s1 = "apple";
String s2 = "banana";

System.out.println(s1 > s2);

Compile-time error

Always use

s1.compareTo(s2)

s1.equals(s2)

depending on your requirement.

Using Relational Operators with `boolean`

Incorrect

true > false

Compile-time error

Boolean values cannot be compared using relational operators.

Writing Mathematical Chains

Incorrect

10 < 20 < 30

Correct

(10 < 20) && (20 < 30)

Summary Table

Scenario	Allowed?	Example
Numeric types	✅ Yes	`10 < 20.5`
Character comparison	✅ Yes	`'b' > 'a'`
`boolean` values	❌ No	`true > false`
Objects (`String`, etc.)	❌ No	`"abc" > "ab"`
Nested comparisons	❌ No	`10 < 20 < 30`

Best Practices

Use relational operators only with primitive numeric types.
Never compare strings using <, <=, >, or >=.
Use compareTo() for ordering strings.
Use equals() when checking whether two strings have the same content.
Use logical operators (&&, ||) to combine multiple relational expressions.

Quick Memory Trick 🧠

Relational operators work only on numeric primitive values.

Remember:

✅ Numbers → Allowed
✅ Characters → Allowed
❌ Booleans → Not Allowed
❌ Objects → Not Allowed
❌ Chain comparisons → Not Allowed

Key Takeaways

Java provides four relational operators: <, <=, >, and >=.
Every relational operator returns a boolean value.
They work with all primitive numeric data types, including char.
They cannot be applied to boolean.
They cannot be applied to object types like String.
Nested comparisons such as 10 < 20 < 30 are not valid Java syntax.
Use compareTo() for ordering strings and equals() for equality checks.
Combine relational expressions using logical operators when multiple conditions are required.

Happy Coding!

String Concatenation Operator (`+`)

Rajesh Bhola — Sat, 11 Jul 2026 14:35:06 +0000

The + operator is one of the most interesting operators in Java because it serves two different purposes.

It performs arithmetic addition when both operands are numeric.
It performs String concatenation when at least one operand is a String.

This makes it the only overloaded operator in Java, making it a popular topic in Java interviews.

Let's understand how it works with simple examples.

What Is the String Concatenation Operator?

Concatenation means joining two or more strings together.

Example

String firstName = "John";
String lastName = "Doe";

System.out.println(firstName + " " + lastName);

Output

John Doe

Here, the + operator joins multiple strings into a single string.

The Only Overloaded Operator in Java

In Java, the + operator has two meanings.

Condition	Behavior
Both operands are numeric	Performs arithmetic addition
At least one operand is a `String`	Performs string concatenation

Examples

System.out.println(10 + 20);

Output

System.out.println("Java" + " Programming");

Output

Java Programming

System.out.println("Version " + 21);

Output

Version 21

Since one operand is a String, Java converts the other operand into a string and performs concatenation.

Rule: Evaluation Happens from Left to Right

One of the most important rules is that the + operator is evaluated from left to right.

Once a String appears in the expression, every remaining + operation becomes string concatenation.

This is one of the most frequently asked Java interview concepts.

Famous Interview Example

String a = "rajesh";
int b = 10;
int c = 20;
int d = 30;

System.out.println(a + b + c + d);
System.out.println(b + c + d + a);
System.out.println(b + c + a + d);
System.out.println(b + a + c + d);

Output

rajesh102030
60rajesh
30rajesh30
10rajesh2030

Expression 1

a + b + c + d

Evaluation

"rajesh" + 10
↓

"rajesh10"

↓

"rajesh1020"

↓

"rajesh102030"

Output

rajesh102030

Since the first operand is a String, the remaining operations are concatenations.

Expression 2

b + c + d + a

Evaluation

10 + 20
↓

30

↓

30 + 30

↓

60

↓

60 + "rajesh"

↓

"60rajesh"

Output

60rajesh

All numeric additions happen first because no String has appeared yet.

Expression 3

b + c + a + d

Evaluation

10 + 20
↓

30

↓

30 + "rajesh"

↓

"30rajesh"

↓

"30rajesh30"

Output

30rajesh30

The first String changes all remaining operations into concatenation.

Expression 4

b + a + c + d

Evaluation

10 + "rajesh"

↓

"10rajesh"

↓

"10rajesh20"

↓

"10rajesh2030"

Output

10rajesh2030

Since the second operand is a String, concatenation begins immediately.

Assignment Examples

Given

String a = "rajesh";

int b = 10;
int c = 20;
int d = 30;

Statement	Result	Reason
`a = b + c + d;`	❌ Compile-time error	RHS is `int`, cannot assign to `String`
`a = a + b + c;`	✅ Valid	RHS is `String`
`b = a + c + d;`	❌ Compile-time error	RHS is `String`, cannot assign to `int`
`b = b + c + d;`	✅ Valid	RHS is `int`

Typical compile-time error

incompatible types
found: java.lang.String
required: int

Command-Line Arguments Example

Command-line arguments are always received as strings.

Example

class Test {

    public static void main(String[] args) {

        System.out.println(args[0] + args[1]);

    }

}

Run

java Test 10 20

Output

Many beginners expect the answer to be 30, but the output is 1020 because both command-line arguments are strings.

To perform arithmetic addition, convert them into integers.

int a = Integer.parseInt(args[0]);
int b = Integer.parseInt(args[1]);

System.out.println(a + b);

Output

The `+=` Operator Is Also Overloaded

The += operator can also perform string concatenation.

Example

String s = "rajesh";

s = s.concat("software");

System.out.println(s);

Output

rajeshsoftware

The same result can be achieved using the + operator.

String s = "rajesh";

s = s + "software";

System.out.println(s);

Or more simply,

String s = "rajesh";

s += "software";

System.out.println(s);

Output

rajeshsoftware

Common Beginner Mistakes

Expecting Addition Instead of Concatenation

System.out.println("10" + 20);

Output

Not

Forgetting Left-to-Right Evaluation

System.out.println(10 + 20 + "30");

Output

Explanation

10 + 20 = 30

30 + "30"

↓

"3030"

System.out.println("10" + 20 + 30);

Output

Best Practices

Remember that the + operator is evaluated from left to right.
If any operand is a String, the remaining operations become concatenation.
Convert numeric strings using Integer.parseInt() when arithmetic is required.
Use parentheses to make complex expressions easier to read.

Example

System.out.println("Total = " + (10 + 20));

Output

Total = 30

Without parentheses

System.out.println("Total = " + 10 + 20);

Output

Total = 1020

Quick Memory Trick 🧠

Once a String enters the expression (left to right), every remaining + becomes concatenation.

Remember:

Number + Number → Addition
String + Anything → Concatenation

Key Takeaways

The + operator is the only overloaded operator in Java.
It performs addition when both operands are numeric.
It performs concatenation when at least one operand is a String.
Java evaluates + expressions from left to right.
Once a String appears, every remaining + performs concatenation.
Command-line arguments are always strings.
The += operator also supports string concatenation.
Use parentheses whenever you want arithmetic to happen before concatenation.

Happy Coding!

Arithmetic Operators in Java

Rajesh Bhola — Sat, 11 Jul 2026 13:56:12 +0000

Arithmetic operators are among the most frequently used operators in Java. They allow you to perform mathematical calculations such as addition, subtraction, multiplication, division, and finding the remainder.

Whether you're calculating a total, iterating through loops, or solving programming problems, you'll use arithmetic operators almost every day.

Let's understand how they work, the rules Java follows, and some important interview concepts.

What Are Arithmetic Operators?

Java provides the following arithmetic operators:

Operator	Description	Example
`+`	Addition	`10 + 5` → `15`
`-`	Subtraction	`10 - 5` → `5`
`*`	Multiplication	`10 * 5` → `50`
`/`	Division	`10 / 5` → `2`
`%`	Modulus (Remainder)	`10 % 3` → `1`

Example

int a = 20;
int b = 6;

System.out.println(a + b);   // 26
System.out.println(a - b);   // 14
System.out.println(a * b);   // 120
System.out.println(a / b);   // 3
System.out.println(a % b);   // 2

Rule 1: Result Type Formula (Type Promotion)

One of the most important rules in Java is:

The result type of an arithmetic operation is always the maximum of int, the type of the first operand, and the type of the second operand.

In simple words:

byte, short, and char are automatically promoted to int before arithmetic operations.
The result is never smaller than int.

Type Promotion Table

Expression	Result Type
`byte + byte`	`int`
`byte + short`	`int`
`short + short`	`int`
`char + char`	`int`
`char + int`	`int`
`short + long`	`long`
`int + double`	`double`
`float + double`	`double`

Examples

System.out.println('a' + 'b');

Output

Explanation

'a' = 97
'b' = 98

97 + 98 = 195

System.out.println('a' + 1);

Output

System.out.println('a' + 1.2);

Output

98.2

Since one operand is double, the final result is also a double.

Why Does This Cause a Compile-Time Error?

Consider the following code:

byte a = 10;
byte b = 20;

byte c = a + b;

Compile-time error

possible lossy conversion from int to byte

Why?

Even though both operands are byte, Java promotes them to int.

byte + byte
↓

int

So,

a + b

produces an int, not a byte.

To assign the result back to a byte, an explicit cast is required.

byte c = (byte)(a + b);

Rule 2: Integral Arithmetic Has No Infinity

Integral data types include:

byte
short
int
long

These types cannot represent Infinity.

Therefore, dividing by zero throws an exception.

System.out.println(10 / 0);

Output

Exception in thread "main"
java.lang.ArithmeticException: / by zero

Rule 3: Floating-Point Arithmetic Supports Infinity

Floating-point types are:

float
double

Unlike integral types, they support special IEEE 754 values.

Positive Infinity
Negative Infinity

Example

System.out.println(10 / 0.0);

Output

Infinity

System.out.println(-10 / 0.0);

Output

-Infinity

No ArithmeticException is thrown.

Rule 4: Floating-Point Arithmetic Supports NaN

NaN stands for Not a Number.

It represents an undefined mathematical result.

Example

System.out.println(0.0 / 0.0);

Output

NaN

Another example

System.out.println(-0.0 / 0.0);

Output

NaN

Compare with Integral Arithmetic

System.out.println(0 / 0);

Output

ArithmeticException

Integral types cannot represent undefined values.

Rule 5: NaN Comparison Behavior (Interview Question)

One of the most surprising behaviors in Java is that NaN is not equal to itself.

Example

System.out.println(Float.NaN == Float.NaN);

Output

false

Similarly,

System.out.println(10 == Float.NaN);

Output

false

All comparison operators return false.

System.out.println(10 < Float.NaN);   // false
System.out.println(10 <= Float.NaN);  // false
System.out.println(10 > Float.NaN);   // false
System.out.println(10 >= Float.NaN);  // false
System.out.println(10 == Float.NaN);  // false
System.out.println(Float.NaN == Float.NaN); // false

Only != returns true.

System.out.println(10 != Float.NaN);         // true
System.out.println(Float.NaN != Float.NaN);  // true

Why?

This behavior follows the IEEE 754 Floating-Point Standard, which Java implements.

Summary: ArithmeticException

Property	Detail
Exception Type	`ArithmeticException`
Category	Runtime Exception
Occurs In	Integral arithmetic only
Never Occurs In	Floating-point arithmetic
Caused By	`/` and `%` with zero divisor

Quick Memory Trick

Scenario	Integral (`int`, `byte`, `long`)	Floating (`float`, `double`)
`10 / 0`	❌ `ArithmeticException`	✅ `Infinity`
`-10 / 0`	❌ `ArithmeticException`	✅ `-Infinity`
`0 / 0`	❌ `ArithmeticException`	✅ `NaN`
Supports Infinity	❌ No	✅ Yes
Supports NaN	❌ No	✅ Yes

Best Practices

Remember that byte, short, and char are promoted to int during arithmetic operations.
Don't assume the result type is the same as the operand type.
Use explicit casting when assigning arithmetic results back to smaller data types.
Avoid comparing floating-point values with NaN using ==. Instead, use Float.isNaN() or Double.isNaN().
Be careful when dividing integers by zero, as it throws an ArithmeticException.

Key Takeaways

Java provides five arithmetic operators: +, -, *, /, and %.
Arithmetic operations on byte, short, and char are automatically promoted to int.
Integral division by zero throws an ArithmeticException.
Floating-point division by zero produces Infinity or -Infinity.
0.0 / 0.0 produces NaN instead of an exception.
NaN is not equal to itself, making it a popular Java interview question.
Understanding Java's type promotion rules helps avoid many common compile-time errors.

Happy Coding!

Increment and Decrement Operators in Java

Rajesh Bhola — Sat, 11 Jul 2026 07:57:18 +0000

Increment (++) and decrement (--) operators are among the most commonly used operators in Java.

They allow you to increase or decrease the value of a variable by 1 with a single operator.

Although they look simple, understanding how they work—especially the difference between prefix and postfix forms—is essential for writing correct Java programs and performing well in interviews.

Let's learn them with simple explanations and practical examples.

What Are Increment and Decrement Operators?

Java provides two unary operators:

Increment (++) increases a variable's value by 1.
Decrement (--) decreases a variable's value by 1.

Example

int count = 10;

count++;

System.out.println(count);

Output

Similarly,

count--;

reduces the value by one.

Types of Increment Operator

The increment operator has two forms.

Prefix Increment (++x)
Postfix Increment (x++)

Although both increase the value by 1, the order of execution is different.

Prefix Increment (`++x`)

The variable is incremented first, and then its updated value is used.

Example

int score = 10;

int updatedScore = ++score;

System.out.println(score);
System.out.println(updatedScore);

Output

11
11

What happened?

score became 11.
The updated value (11) was assigned to updatedScore.

Postfix Increment (`x++`)

The current value is used first, and then the variable is incremented.

Example

int score = 10;

int previousScore = score++;

System.out.println(score);
System.out.println(previousScore);

Output

11
10

What happened?

The current value (10) was assigned to previousScore.
After the assignment, score became 11.

Prefix Decrement (`--x`)

The variable is decreased first, and then the updated value is used.

Example

int items = 5;

int remainingItems = --items;

System.out.println(items);
System.out.println(remainingItems);

Output

4
4

Postfix Decrement (`x--`)

The current value is used first, and then it is decreased.

Example

int items = 5;

int previousItems = items--;

System.out.println(items);
System.out.println(previousItems);

Output

4
5

Prefix vs Postfix

Assume the initial value is:

int x = 10;

Prefix Increment

int y = ++x;

Result

x = 11
y = 11

Postfix Increment

int y = x++;

Result

x = 11
y = 10

Prefix Decrement

int y = --x;

Result

x = 9
y = 9

Postfix Decrement

int y = x--;

Result

x = 9
y = 10

Rule 1: Increment and Decrement Work Only on Variables

Valid

int number = 5;

number++;

Invalid

++5;

Compile-time error

unexpected type
required: variable
found: value

Why?

The ++ operator changes a value.

Only variables can store a new value.

A constant like 5 cannot be modified.

Rule 2: Nested Increment Is Not Allowed

Invalid

int value = 5;

++(++value);

Compile-time error

unexpected type
required: variable
found: value

Why?

The result of ++value is a value, not another variable.

Rule 3: Cannot Be Used with `final` Variables

final int MAX = 100;

MAX++;

Compile-time error

cannot assign a value to final variable

A final variable cannot be modified after initialization.

Rule 4: Cannot Be Applied to `boolean`

Valid

int number = 10;

number++;

char grade = 'A';

grade++;

double price = 99.99;

price++;

Invalid

boolean active = true;

active++;

Compile-time error

bad operand type boolean for unary operator '++'

Java allows increment and decrement for every primitive type except boolean.

Incrementing Characters

Characters are internally represented using Unicode values.

Example

char grade = 'A';

grade++;

System.out.println(grade);

Output

Similarly,

char letter = 'z';

letter--;

System.out.println(letter);

Output

Why Does `byte++` Work but `b = b + 1` Doesn't?

This is one of the most popular Java interview questions.

Consider this code.

byte value = 10;

value = value + 1;

Compile-time error

possible lossy conversion from int to byte

Why?

In Java, arithmetic operations on byte, short, and char are automatically promoted to int.

So,

value + 1

produces an int.

Assigning an int back to a byte requires an explicit cast.

Correct version

byte value = 10;

value = (byte)(value + 1);

Now look at this.

byte value = 10;

value++;

System.out.println(value);

Output

Why does this work?

The compiler automatically performs the required cast internally.

Conceptually, Java treats it like this:

value = (byte)(value + 1);

This automatic conversion is built into the increment and decrement operators.

A Common Interview Question

Consider the following program.

int x = 10;

x = x++;

System.out.println(x);

What will be the output?

Output

Step-by-step explanation

Initially,

x = 10

The postfix increment works as follows:

Save the current value (10) for the assignment.
Increment x to 11.
Assign the saved value (10) back to x.

Final result

x = 10

This surprises many beginners because they expect the answer to be 11.

Common Beginner Mistakes

Forgetting the Difference Between Prefix and Postfix

int x = 5;

System.out.println(++x);

Output

Whereas

int x = 5;

System.out.println(x++);

Output

After printing,

x = 6

Trying to Increment a Constant

Invalid

++100;

Only variables can be incremented.

Using Multiple Increment Operators in One Expression

Avoid code like this.

int i = 1;

int result = ++i + i++;

Although Java defines the evaluation order, such expressions are difficult to read and maintain.

Professional Java developers prefer simple, readable code.

Instead, write

i++;

int result = i;

i++;

This is much easier to understand and debug.

Best Practices

Use increment and decrement only on variables.
Prefer writing one increment or decrement operation per statement.
Avoid modifying the same variable multiple times in a single expression.
Use meaningful variable names instead of x, i, or a in business applications.
Focus on writing readable code rather than clever one-line expressions.

Key Takeaways

++ increases a variable by 1, while -- decreases it by 1.
Prefix operators (++x, --x) modify the variable before using its value.
Postfix operators (x++, x--) use the current value first and then modify it.
Increment and decrement operators work only with variables, not constants.
They cannot be applied to boolean values.
They cannot be used with final variables.
Java automatically handles type conversion for ++ and --, which is why byte++ works even though byte = byte + 1 does not.
Avoid complex expressions that modify the same variable multiple times. Clear and readable code is always a better choice.

Happy Coding!

DEV Community: Rajesh Bhola

Relational Operators in Java

What Are Relational Operators?

Rule 1: Relational Operators Work on All Primitive Types Except boolean

Valid Examples

Invalid Example

Why?

Rule 2: Relational Operators Cannot Be Applied to Objects

Why?

Rule 3: Nesting Relational Operators Is Not Allowed

Why?

Correct Way to Write Multiple Comparisons

Character Comparisons

Common Beginner Mistakes

Comparing Strings Using >

Using Relational Operators with boolean

Writing Mathematical Chains

Summary Table

Best Practices

Quick Memory Trick 🧠

Key Takeaways

String Concatenation Operator (`+`)

What Is the String Concatenation Operator?

The Only Overloaded Operator in Java

Rule: Evaluation Happens from Left to Right

Famous Interview Example

Expression 1

Expression 2

Expression 3

Expression 4

Assignment Examples

Command-Line Arguments Example

The += Operator Is Also Overloaded

Common Beginner Mistakes

Expecting Addition Instead of Concatenation

Forgetting Left-to-Right Evaluation

Best Practices

Quick Memory Trick 🧠

Key Takeaways

Arithmetic Operators in Java

What Are Arithmetic Operators?

Rule 1: Result Type Formula (Type Promotion)

Type Promotion Table

Examples

Why Does This Cause a Compile-Time Error?

Why?

Rule 2: Integral Arithmetic Has No Infinity

Rule 3: Floating-Point Arithmetic Supports Infinity

Rule 4: Floating-Point Arithmetic Supports NaN

Compare with Integral Arithmetic

Rule 5: NaN Comparison Behavior (Interview Question)

Why?

Summary: ArithmeticException

Quick Memory Trick

Best Practices

Key Takeaways

Increment and Decrement Operators in Java

What Are Increment and Decrement Operators?

Types of Increment Operator

Prefix Increment (++x)

What happened?

Postfix Increment (x++)

What happened?

Prefix Decrement (--x)

Postfix Decrement (x--)

Prefix vs Postfix

Prefix Increment

Postfix Increment

Prefix Decrement

Postfix Decrement

Rule 1: Increment and Decrement Work Only on Variables

Why?

Rule 2: Nested Increment Is Not Allowed

Why?

Rule 3: Cannot Be Used with final Variables

Rule 4: Cannot Be Applied to boolean

Incrementing Characters

Why Does byte++ Work but b = b + 1 Doesn't?

Why?

Why does this work?

Rule 1: Relational Operators Work on All Primitive Types Except `boolean`

Comparing Strings Using `>`

Using Relational Operators with `boolean`

The `+=` Operator Is Also Overloaded

Prefix Increment (`++x`)

Postfix Increment (`x++`)

Prefix Decrement (`--x`)

Postfix Decrement (`x--`)

Rule 3: Cannot Be Used with `final` Variables

Rule 4: Cannot Be Applied to `boolean`

Why Does `byte++` Work but `b = b + 1` Doesn't?