Equivalent Boolean Expressions (EK 2.6.A.1)

Two boolean expressions are equivalent if and only if they produce the same result for every possible combination of input values — not just the inputs you happen to test. Proving equivalence requires checking all cases, which is exactly what a truth table does. Finding a single case where two expressions differ is sufficient to prove they are NOT equivalent.

De Morgan's Law (EK 2.6.A.2)

De Morgan's Law is one of the highest-frequency topics on the AP CSA exam. It provides two transformation rules for distributing NOT across AND and OR. The CED states both rules explicitly:

!(a && b)  is equivalent to  !a || !b    // AND becomes OR
!(a || b)  is equivalent to  !a && !b    // OR becomes AND

// Original condition: not (raining AND cold)
if (!(isRaining && isCold)) { /* go outside */ }

// De Morgan's applied: !AND becomes OR with flipped operands
if (!isRaining || !isCold) { /* go outside */ }  // equivalent

// Second law: not (hungry OR tired)
if (!(isHungry || isTired)) { /* keep working */ }

// De Morgan's applied: !OR becomes AND with flipped operands
if (!isHungry && !isTired) { /* keep working */ }  // equivalent

Comparing Object References (EK 2.6.B)

With reference types (objects), == and != compare memory addresses — whether two variables point to the same object in memory, not whether their content is identical. A reference variable can also hold the special value null, meaning it does not point to any object. Calling a method on a null reference throws a NullPointerException at runtime.

String a = new String("hello");
String b = new String("hello");
String c = a;
String d = null;

System.out.println(a == b);        // false — different objects
System.out.println(a == c);        // true  — same object (c points to a)
System.out.println(a.equals(b));   // true  — same content
System.out.println(a.equals(c));   // true  — same content

System.out.println(d == null);     // true  — d points to nothing
System.out.println(d != null);     // false

// Safe null check before calling .equals():
if (a != null && a.equals(b)) {   // short-circuits if a is null
    System.out.println("Match");
}

Real-World Connection

Equivalent boolean expressions are important in software maintenance: two developers might write logically identical conditions in different forms, and a code reviewer must recognize they are the same. De Morgan's Law is used constantly to simplify complex guard conditions. Object reference comparison matters in every system that manages collections of objects: a database query returns new object instances even for the same data row, so == will return false even when the records are identical. Java's entire .equals() convention exists to solve this problem.

Summary

• Equivalent expressions produce the same boolean result for every possible input. Prove with a truth table. (EK 2.6.A.1)
• De Morgan's Law: !(a && b) ≡ !a || !b and !(a || b) ≡ !a && !b. Distribute NOT, flip operands, flip operator. (EK 2.6.A.2)
• Common De Morgan's mistake: forgetting to flip AND to OR (or vice versa).
• == on objects compares memory addresses, not content. (EK 2.6.B)
• .equals() compares object content. Use for Strings and other objects.
• null check: obj == null or obj != null. Never call .equals() on a reference that may be null without checking first.
• Safe pattern: knownNonNull.equals(possiblyNull) or obj != null && obj.equals(other).

Equivalent Boolean Expressions

Two boolean expressions are equivalent if they evaluate to the same value for all possible inputs. Truth tables are a systematic way to prove equivalence.

// Are x > 5 and !(x <= 5) equivalent?
x = 3:  x>5 = false,  !(x<=5) = !(true)  = false  ✓
x = 5:  x>5 = false,  !(x<=5) = !(true)  = false  ✓
x = 7:  x>5 = true,   !(x<=5) = !(false) = true   ✓
// Same result for all inputs → EQUIVALENT

De Morgan’s Law

De Morgan’s Law provides a rule for distributing NOT across AND/OR:

!(a && b)  is equivalent to  !a || !b
!(a || b)  is equivalent to  !a && !b

// Original: not (raining AND cold)
!(isRaining && isCold)

// Equivalent via De Morgan's:
!isRaining || !isCold
// "not raining, or not cold"

Comparing Object References

With reference types (objects), == and != compare references (memory addresses), not content. A reference can be compared to null to check whether it points to any object.

String s = null;
System.out.println(s == null);   // true: no object

// Two variables can reference the same object
String a = "hello";
String b = a;         // b and a reference the SAME object
System.out.println(a == b);      // true: same reference

String s = null;
System.out.println(s == null);

int x = 4;
boolean p = x >= 5;
boolean q = !(x < 5);
System.out.println(p == q);