Lesson 2.2: Boolean Expressions

What Is a Boolean Expression?

A boolean expression is any expression that evaluates to exactly one of two values: true or false. This is the most important concept in all of Unit 2 because every selection statement and every loop depends on a boolean expression to determine what runs next. Without boolean expressions, programs cannot make decisions or repeat work.

The boolean data type in Java has exactly two possible values: true and false. These are keywords, not strings — they have no quotes. A boolean variable stores one of these values the same way an int stores a number.

The Six Relational Operators

Java provides exactly six relational operators. Every AP CSA exam that tests Topic 2.2 uses one or more of these. You need to evaluate them instantly for any numeric values.

Equality and Inequality: == and != (EK 2.2.A.1)

The == operator answers the question: "do these two things have the same value?" The != operator answers: "are these two things different?" For primitive types, both operators compare the actual stored values directly and produce an unambiguous result.

int a = 5;
int b = 5;
int c = 8;

System.out.println(a == b);   // true  — same value
System.out.println(a == c);   // false — different values
System.out.println(a != c);   // true  — they differ
System.out.println(a != b);   // false — they are the same

boolean sameAge = (a == b);   // boolean variable stores the result
System.out.println(sameAge);  // true

The critical distinction: primitives vs. reference types (EK 2.2.A.1)

EK 2.2.A.1 explicitly covers both cases. With primitive types (int, double, boolean, char), == compares the actual stored values. With reference types (objects like String, ArrayList), == compares memory addresses — whether two variables point to the same object in memory, not whether their contents are equal.

String s1 = new String("hello");
String s2 = new String("hello");
String s3 = s1;

System.out.println(s1 == s2);       // false — different objects in memory
System.out.println(s1 == s3);       // true  — same object (same address)
System.out.println(s1.equals(s2));  // true  — same content

Numeric Comparisons: <, >, <=, >= (EK 2.2.A.2)

These four operators establish ordering relationships between numeric values. They apply to int and double variables, literal numbers, and any arithmetic expression that produces a number. The result is always a boolean.

int score = 85;

System.out.println(score == 85);  // true
System.out.println(score != 85);  // false
System.out.println(score < 90);   // true
System.out.println(score > 90);   // false
System.out.println(score <= 85);  // true  — equal to boundary
System.out.println(score >= 90);  // false — not equal or above 90
System.out.println(score >= 85);  // true  — exactly at boundary

English-to-operator translation

AP exam questions describe conditions in plain English. You must instantly translate to the correct Java operator. The most frequently confused pairs are > vs. >= and < vs. <=:

Operator Precedence with Relational Operators

Relational operators have lower precedence than arithmetic operators. This means Java always finishes all arithmetic first, then evaluates the comparison. You do not need parentheses to make a + b > c * 2 work correctly — arithmetic happens first automatically. However, using parentheses for clarity is considered good style.

int a = 3, b = 4;

// Arithmetic runs BEFORE relational:
System.out.println(a + b > 6);    // 3+4=7, then 7>6 = true
System.out.println(a * b == 12);   // 3*4=12, then 12==12 = true
System.out.println(b - a != 0);    // 4-3=1, then 1!=0 = true
System.out.println(a * 2 <= b);   // 3*2=6, then 6<=4 = false

// Storing the result:
boolean result = a + b >= 7;      // 7 >= 7 is true
System.out.println(result);        // true

Storing and Using Boolean Results

A relational expression produces a boolean value that can be used in three ways: directly inside an if or loop, stored in a boolean variable for reuse, or passed as a method argument. Storing boolean results in named variables often makes code more readable and is a pattern you will use throughout FRQ solutions.

int score = 75;

// 1. Directly in an if:
if (score >= 60) {
    System.out.println("Passed");
}

// 2. Stored in a variable:
boolean passed = score >= 60;
boolean excellent = score >= 90;
if (passed) {
    System.out.println("Passed");
}

// 3. In a while loop condition:
int countdown = 5;
while (countdown > 0) {
    System.out.println(countdown);
    countdown--;
}

Real-World Connection

Boolean expressions are the decision engine behind everything a computer does. A credit card processor checks balance >= chargeAmount before approving a transaction. A game engine checks playerHealth > 0 to determine if the game continues. A sensor system checks temperature >= threshold to trigger an alert. Every conditional in software — from a mobile app to a space shuttle controller — is ultimately a boolean expression evaluated to true or false. Topic 2.2 gives you the foundation for writing every condition you will ever use in AP CSA.

Summary

• Boolean expressions evaluate to true or false. They are the input to every if statement and loop.
• Six relational operators: ==, !=, <, >, <=, >=. All produce boolean results. (EK 2.2.A.2, 2.2.A.3)
• Primitives: == and != compare actual values. (EK 2.2.A.1)
• Reference types (objects): == compares memory addresses, not content. Use .equals() for content. (EK 2.2.A.1)
• Precedence: arithmetic operators evaluate before relational operators. a + b > c computes a + b first.
• Boundary trap: < excludes the boundary; <= includes it. Test boundary values explicitly.
• Chained comparisons like 0 < x < 10 do not work in Java. Use && instead.

int temp = 98;
boolean isFever = temp > 100;
System.out.println(isFever);

int p = 4;
int q = 8;
System.out.println(p * 2 == q);

int n = 15;
System.out.println(n % 2 == 0);
System.out.println(n > 10);

int x = 10;
int y = 20;
boolean result = x + 5 > y - 3;
System.out.println(result);

int a = 6;
int b = 3;
System.out.println(a / b == 2);
System.out.println(a % b == 0);