Codectionary / Developer documentation / Java

Comparison & Logical Operators

Comparison operators (==, !=, <, >, <=, >=) compare two values and evaluate to a boolean. Logical operators (&&, ||, !) combine or invert boolean expressions, with && and || short-circuiting - meaning the second operand is skipped entirely if the first already determines the result. Importantly, == compares object references for non-primitive types like String, so .equals() should be used to compare their actual content.

Syntax

==  !=  <  >  <=  >=   &&  ||  !

Examples

Comparison Operators

Comparing primitive values to produce a boolean result.

int a = 5, b = 3;

System.out.println(a == b);  // false
System.out.println(a != b);  // true
System.out.println(a > b);   // true
System.out.println(a <= b);  // false

Logical Operators

Combining boolean expressions with &&, ||, and !.

int age = 25;
boolean hasId = true;

if (age >= 18 && hasId) {
    System.out.println("Entry allowed");
}

boolean isWeekend = false;
boolean isHoliday = true;

if (isWeekend || isHoliday) {
    System.out.println("No work today");
}

boolean isBanned = false;
if (!isBanned) {
    System.out.println("Access granted");
}

Comparing Strings: == vs .equals()

A very common Java pitfall - == compares references, not content, for objects like String.

String a = new String("hello");
String b = new String("hello");

System.out.println(a == b);        // false - different objects in memory
System.out.println(a.equals(b));   // true  - same content

String c = "hello";
String d = "hello";
System.out.println(c == d);        // true - string literals are pooled/interned

Best practices

  • Always use .equals() to compare the content of objects like String - only use == to check if two references point to the exact same object
  • Take advantage of short-circuit evaluation: put cheaper or null-checking conditions first in && expressions to avoid unnecessary work or NullPointerExceptions
  • Wrap multi-condition logical expressions in parentheses for clarity, even when not strictly required by operator precedence
  • Never rely on string literal pooling (== happening to work for literals) - it's an implementation detail, not a guarantee for all String objects

At a glance

Purpose
General-purpose application development
File extension
.java
Runs in
Java Virtual Machine
Usually used with
JDK and Java libraries

Specifications & further reading

Related Java documentation

Variables & Primitive Data Types
Java is a statically-typed language, meaning every variable must be declared with an explicit type before use, and that type cannot change afterward. Java has eight primitive types - byte, short, int, long, float, double, char, and boolean - which store simple values directly rather than references, making them fast and memory-efficient. Anything beyond primitives (String, arrays, custom classes) is a reference type instead.
System.out.println / print / printf
System.out is Java's standard output stream, and it exposes three main methods for writing text to the console. println() prints its argument followed by a newline, print() prints without adding a newline, and printf() gives C-style formatted output using format specifiers like %d, %s, and %.2f for precise control over how values are displayed.
Comments & Javadoc
Java supports single-line comments with //, multi-line comments with /* */, and a special documentation format called Javadoc, written as /** */. Javadoc comments support tags like @param, @return, and @throws, and can be processed by the javadoc tool to automatically generate HTML API documentation - the same format used for Java's own official standard library docs.
Arithmetic & Assignment Operators
Java provides the standard arithmetic operators for numeric computation: +, -, *, / for division, and % for the remainder (modulus). It also has compound assignment operators (+=, -=, etc.) that combine an operation with assignment, along with increment (++) and decrement (--) operators in both prefix and postfix forms, which subtly differ in when the value is updated relative to being used.