Comparing Boolean Expressions

Hello everyone! It’s Saavi. Today we're diving into a topic that might seem small but has huge implications for writing bug-free code: comparing Boolean expressions and objects.

What Makes Two Expressions "Equivalent"?

Let's start with a simple idea. In math, you know that 2 + 4 is equivalent to 6. They look different, but they always produce the same value.

The same concept applies to Boolean logic. Two Boolean expressions are equivalent if they evaluate to the same result (true or false) in all possible situations.

How can we prove this? We can use a truth table. It’s just an organized way to check every single combination of inputs.

For example, let's say we have a Boolean variable isRaining. Is the expression !(!isRaining) equivalent to just isRaining? Let's see:

Look at the first and last columns. They match perfectly! So, yes, !(!isRaining) is equivalent to isRaining. It's a clunky way of saying the same thing. Our goal as programmers is to find the simplest, most readable form.

Your Secret Weapon: De Morgan's Law

Now for the superpower that lets you simplify complex logical statements: De Morgan's Law. It sounds fancy, but it's an incredibly useful pattern for dealing with negated ANDs and ORs.

There are two rules to remember:

1. !(a && b) is equivalent to !a || !b
2. !(a || b) is equivalent to !a && !b

Let's break this down with an analogy. Imagine the rule for getting into a school dance is: "You must have a ticket AND be a current student." hasTicket && isStudent

Now, what if we want to express the reason someone is denied entry? That would be !(hasTicket && isStudent).

According to De Morgan's Law, this is the same as !hasTicket || !isStudent. Let's translate that to English: "You are denied entry if you do NOT have a ticket, OR you are NOT a current student." It makes perfect sense!

[[fig:demorgans_mistake]]

Comparing Objects: The Twin Analogy

Okay, let's switch gears from pure logic to objects. This is one of the most important and frequently tested concepts in AP CSA.

Imagine you have identical twins, Priya and Sofia.

• == (the double equals sign) checks for identity. It asks, "Are these two variables pointing to the exact same person?" If you have one person and two nicknames for them, == would be true. But Priya and Sofia are two different people, so Priya == Sofia would be false.
• .equals() (the method) checks for equivalency. It asks, "Do these two people have the same attributes?" Since Priya and Sofia are identical twins, they have the same eye color, hair color, etc. So, Priya.equals(Sofia) would be true.

In Java, an "object reference" is like a nickname for an object living in your computer's memory.

// Create two different String objects with the same content
String city1 = new String("Chicago");
String city2 = new String("Chicago");

// Create a third reference that points to the *same* object as city1
String city3 = city1;

Let's apply our twin analogy:

• city1 == city2 evaluates to false. Why? Because new creates a brand new object in a new memory location. We have two separate, identical-looking objects. They are twins, not the same person.
• city1 == city3 evaluates to true. Why? We didn't use the new keyword. We just said, "Make city3 another name for the object city1 is already pointing to." They are two nicknames for the same object.

So how do we check if two String objects have the same characters? We use the .equals() method.

• city1.equals(city2) evaluates to true. The String class was written with an .equals() method that compares the actual sequence of characters. This is almost always what you want when comparing strings.

Finally, a variable might not be pointing to any object at all. In this case, its value is null. You can, and should, check for this using ==.

String name = null;
if (name == null) {
    System.out.println("No name has been assigned yet.");
}

For any custom objects you create (like a Player, Car, or Book class), you have to decide what "equals" means. Does it mean they have the same player ID? The same VIN? You would write your own .equals() method in that class to define that criteria.

Let's walk through a couple of examples to make these concepts concrete.

// Assume a simple Student class exists
Student student1 = new Student("Marcus", 11);
Student student2 = new Student("Marcus", 11);
Student student3 = student1;

System.out.println(student1 == student2);
System.out.println(student1 == student3);
System.out.println(student1.equals(student2));

Ready to test your understanding? Give these a shot.

1. 1
   Theme Park Logic

   A new roller coaster in Seattle has a complex rule for the fast-pass lane, written by the legal team. The condition to stop someone is: !(isTallEnough && hasFastPass). Use De Morgan's law to rewrite this as a simpler, positive condition. What does the simplified rule mean in plain English?
2. 2
   Object Puzzler

   Carlos is writing a program to track inventory. He writes the following code. Without running it, predict the output and be ready to explain why.

   StringBuilder item1 = new StringBuilder("Wrench");
   StringBuilder item2 = new StringBuilder("Wrench");
   StringBuilder item3 = item2;
   
   // Prediction 1: What will this print?
   System.out.println(item1 == item2);
   
   // Prediction 2: What will this print?
   System.out.println(item2 == item3);
   
   // Prediction 3: What will this print?
   System.out.println(item1.equals(item2));

   Hint: StringBuilder is a class like String, but its default .equals() method was not overridden. How does that affect Prediction 3?