APCSA Unit 3: College Board Learning Objectives and Standards

Learning Objectives

The objective of today’s lesson is to…

Evaluate Boolean expressions that use relational operators in program code

Essential Knowledge

College Board wants you to know that…

Primitive values and reference values can be compared using relational operators (i.e., == and !=)
Arithmetic expression values can be compared using relational operators (such as <, >, <=, >=)
An expression involving relational operators evaluates to a Boolean value

Warm Up

Answer the following questions as a group or individually. Write down your answers in your hacks notebook.

What is a boolean?

A binary `true` or `false` value.

What values can a boolean represent? How many?

It can represent `true` and `false`, so 2 values.

What is an example of when we’d use a boolean?

If we wanted the application to know if a certain process has already occurred, a variable `processOccurred` could be set to `true`, which could affect a conditional statement later.

Recap on Booleans

A boolean is a type of variable that can evaluate to true or false. In Java, there are various comparison operators that can be used in order to compare two values. What are some?

The format is val1 <oper> val2, and will return a boolean given the state of the system. Like all booleans, this can only return two values true or false

public class Example {

    private static boolean isAdult = false;
    private static int myAge = 16;

    public static void main(String [] args){

        if(myAge >= 18){
            System.out.println("You are an adult!");
            isAdult = true;
        } else {
            System.out.println("You are not an adult!");
        }  

        System.out.println(isAdult);
    }
}

Example.main(null);

You are not an adult!
false

Comparison Operators

Whenever you want to make a boolean statement (such as setting a boolean to be true or false), you want to use the "=" or "!=" sign and not the "==" sign.

On the other hand, if you are ever trying to compare String objects, use the String methods such as .equals or .compareTo, NOT the Boolean expressions mentioned above.

Setup Class

Note the utilization of the compareTo in a custom class in order to compare two classes

public class ComparisonExample implements Comparable<ComparisonExample> { // uses Comparable to implement comparisons
    private int comp; // initializing variables
    private int comp2;
    // constructor for the comparisonExample class
    public ComparisonExample(int _comp, int _comp2) {
        this.comp = _comp;
        this.comp2 = _comp2;
    }
    // using @Override to override the automatic compareTo method
    @Override
    public int compareTo(ComparisonExample s) {
        // the comp attribute of both objects are compared
        return Integer.compare(this.comp, s.comp);
    }
    // compare method
    public static int compare(ComparisonExample a, ComparisonExample b)
    {
        if(Integer.compare(a.comp, b.comp)==0){ // starts by checking if the comps of the 2 objects are the same
            return Integer.compare(a.comp2, b.comp2); // ends up checking the second comp if the first are the same
        }
        else {
            return Integer.compare(a.comp, b.comp);
        }
    }
}

Comparing using compareTo

Describe this code and the code above using comments. Talk about how we define the compareTo in the class definition and how that compares each instance of a class using a certain comparison variables.

See my code comments on both the above and below cells.

In your notes Compare and contrast Comparator<> and compareTo

compareTo:

It’s a method inside a class.
Used to define a primary way of comparing objects.
Ideal for natural ordering and sorting.
Objects implement this method themselves.

Comparator:

It’s a separate class.
Used to define custom or multiple ways of comparing objects.
Ideal for flexible sorting.
External class defines comparison logic.

ComparisonExample c = new ComparisonExample(2, 2); // different second comp values
ComparisonExample v = new ComparisonExample(2, 3);
System.out.println(c.compareTo(v)); // Allows comparison of these two instances of a class
System.out.println(ComparisonExample.compare(c, v)); // Also allows for the instances

if(ComparisonExample.compare(c, v) < 0){ // using the custom comparison method
    System.out.println("This is less than!"); // result because of the second comp value of c
}
else { System.out.println("it is not"); }

0
-1


This is less than!

Comparing using .equals

You can use the .equals method to compare the contents of two strings. To test if the two strings are the same or not, you can use Sysout (System.out.println) so that the console will provide a value that is either true or false.

System.out.println("hello".equals("hello")); // will return true, since the strings are the same
System.out.println("Hello".equals("hello")); // will return false, as the one thing that separates these two strings is that the h is capitalized in the first string

true
false

Comparing two arrays

The code below compares the contents of two arrays to see if they are equal. It uses the equals method. However, as we see below, this is rather shallow as opposed to deep comparison.

int arr1[] = { 1, 2, 3 };
int arr2[] = { 1, 2, 3 };

if (Arrays.equals(arr1, arr2)){
    System.out.println("Same");
} else {
    System.out.println("Not same");
}

Same

Deep Equality

All of the methods you just saw are examples of regular equality. Whereas regular equality methods such as the .equals method compares the content of the objects themselves to check if they are equal (i.e. point to the same object), deep equality methods such as the .deepequals method compares the content of nested objects or arrays to determine equality.

import java.util.Arrays;

public class DeepEquality {

    public static void main(String[] args) {
        
        String[][] fruit1 = {
            {"apple", "banana"},
            {"orange", "grape"}
        };

        String[][] fruit2 = {
            {"apple", "banana"},
            {"orange", "grape"}
        };

        // Regular comparison (compares array references, not contents)
        System.out.println("Regular/shallow equality result: " + (fruit1.equals(fruit2))); // will output false since the arrays do not reference the same object

        // Deep comparison (compares array contents, not just references)
        System.out.println("Deep equality result: " + (Arrays.deepEquals(fruit1, fruit2))); // will output true since the arrays have the same content
    }
}

DeepEquality.main(null);

Regular/shallow equality result: false
Deep equality result: true

Challenge!

Identify the issue(s) in the code below (hint: try running it yourself). Then, make the necessary corrections to ensure that the program runs as intended.

public class Challenge {

    private static boolean isName = false;
    private static String name = new String("John");

    public static void main(String [] args){

        Scanner sc = new Scanner(System.in);

        System.out.println("Guess my name!");

        String guess = sc.nextLine();
        System.out.println("Your guess: " + guess);
    
        if(guess.equals(name)){ // the problem was with the equality statement here
            isName = true;
        } else {
            System.out.println("Wrong! L Cope");
        }

        System.out.println(isName);

    }
}

Challenge.main(null);

Guess my name!


Your guess: John
true

I fixed it by changing the `==` equality statement to the `.equals` statement because these are not boolean conditions and thus they cannot be compared this way.

Your Homework

Now that you know what boolean expressions are and how to write them, as well as several comparison methods, your task is to write a class that uses either the compareTo or comparator and compare. Then create two instances of these classes and demonstrate using if statements.

BONUS: Create a program that checks if a year is a leap year or not.

Here is how the method should work:

(1) Prompt the user to input any year that they would like
(2) Determine if the year is a leap year or not
(3) Print the necessary dialogue (ex. [year] is/is not a leap year) AND return the value of any boolean(s) used

I created a class to compare the information of a real celebrity and the information of someone who is suspected to be going undercover as that same celebrity. If their birth years, countries of residence and blood type are the same, they are considered likely matches.

To incorporate the leap year checker, I added a checker for if the birthday of either of the two people being compared is a leap year.

public class UndercoverSuspect {
    private int birthYear;
    private String countryOfResidence;
    private String bloodType;
    private String name;

    // constructor
    public UndercoverSuspect(int birthYear, String countryOfResidence, String bloodType, String name) {
        this.birthYear = birthYear;
        this.countryOfResidence = countryOfResidence;
        this.bloodType = bloodType;
        this.name = name;
    }

    // compareTo function
    public boolean compareTo(UndercoverSuspect other) {
        // important variables
        int yearComparison = Integer.compare(this.birthYear, other.birthYear);
        boolean countryComparison = this.countryOfResidence.equals(other.countryOfResidence);
        boolean bloodTypeComparison = this.bloodType.equals(other.bloodType);

        // using boolean logic
        if ((yearComparison == 0) && countryComparison && bloodTypeComparison) {
            return true;
        } else {return false;}
    }

    // bonus leap year function
    public boolean isLeapYear() {
        return (birthYear % 4 == 0 && birthYear % 100 != 0) || (birthYear % 400 == 0);
    }

    // main demonstration
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // receiving suspect's info
        System.out.println("What is the name of this suspected celebrity (suspected Keanu Reeves)?");
        String suspectName = scanner.nextLine();
        System.out.println("In what country does the suspect live?");
        String suspectLocation = scanner.nextLine();
        System.out.println("What is the blood type of this suspected celebrity?");
        String suspectBloodType = scanner.nextLine();
        System.out.println("What is this person's birth year?\n");
        int suspectBirthYear = scanner.nextInt();

        // examples
        UndercoverSuspect celebrity = new UndercoverSuspect(1964, "USA", "A+", "Keanu Reeves");
        UndercoverSuspect suspect = new UndercoverSuspect(suspectBirthYear, suspectLocation, suspectBloodType, suspectName);
        boolean comparisonResult = celebrity.compareTo(suspect);

        if (comparisonResult) {
            System.out.println(celebrity.name + " and " + suspect.name + " might be the same person!");
        } else {
            System.out.println(celebrity.name + " and " + suspect.name + " are probably different people.");
        }

        if (suspect.isLeapYear()) {
            System.out.println(suspect.birthYear + " is a leap year.");
        } else {
            System.out.println(suspect.birthYear + " is not a leap year.");
        }

        scanner.close();
    }
}

UndercoverSuspect.main(null);

What is the name of this suspected celebrity (suspected Keanu Reeves)?


In what country does the suspect live?
What is the blood type of this suspected celebrity?
What is this person's birth year?

Keanu Reeves and Falsetto Giuseppe might be the same person!
1964 is a leap year.

U3 Boolean and If statements • 26 min read

Description