AP CS Debugger

What Does .compareTo() Do?

The .compareTo() method compares two strings lexicographically—essentially determining their order in the dictionary. It evaluates the Unicode value of each character, one by one, until a mismatch is found or both strings are fully compared.

Syntax:

int result = string1.compareTo(string2);

• Returns 0: If the two strings are equal.

• Returns a positive number: If string1 comes after string2.

• Returns a negative number: If string1 comes before string2.

Note: The comparison is case-sensitive, meaning uppercase and lowercase letters are treated as distinct.

Why Does It Return Those Results?

The .compareTo() method doesn’t just return arbitrary numbers when comparing strings. Its behavior is based on the Unicode values of the characters in the strings being compared. Let’s break this down step-by-step to understand how these results are calculated.

How Unicode Values Work

Each character in Java is represented by a Unicode value, which is a unique number assigned to characters across different languages and scripts. For example:

• ‘A’ has a Unicode value of 65.

• ‘B’ has a Unicode value of 66.

• ‘a’ has a Unicode value of 97.

• ‘b’ has a Unicode value of 98.

The .compareTo() method calculates the difference between the Unicode values of corresponding characters in two strings.

Step-by-Step: How .compareTo() Calculates Results

When comparing two strings, .compareTo() performs the following steps:

1. Compare Characters at the Same Position:

• It starts with the first character of each string.

• If the characters are different, it calculates the difference by subtracting the Unicode value of the character in the second string from the first.

• If the characters are the same, it moves to the next character.

2. Return the Difference or Continue:

• If a difference is found at any position, the method immediately returns that difference (a positive or negative number).

• If it reaches the end of one string but not the other, the shorter string is considered “smaller.”

3. Handle Equal Strings:

• If all characters are the same and both strings have the same length, .compareTo() returns 0.

Example 1: Comparing Two Different Strings

String str1 = "apple";

String str2 = "banana";

int result = str1.compareTo(str2);

System.out.println(result);  // Output: Negative number

Here’s what happens:

1. Compare the first characters: ‘a’ (Unicode 97) vs. ‘b’ (Unicode 98).

• Difference: 97 – 98 = -1.

2. Since the first characters are different, .compareTo() returns -1 immediately.

Why a Negative Result?

The result is negative because ‘a’ comes before ‘b’ lexicographically.

Example 2: Comparing Strings with a Common Prefix

String str1 = "car";

String str2 = "cat";

int result = str1.compareTo(str2);

System.out.println(result);  // Output: Negative number

Here’s what happens:

1. Compare the first characters: ‘c’ (Unicode 99) vs. ‘c’ (Unicode 99).

• Difference: 99 – 99 = 0. (Move to the next character.)

2. Compare the second characters: ‘a’ (Unicode 97) vs. ‘a’ (Unicode 97).

• Difference: 97 – 97 = 0. (Move to the next character.)

3. Compare the third characters: ‘r’ (Unicode 114) vs. ‘t’ (Unicode 116).

• Difference: 114 – 116 = -2.

4. The method returns -2 because ‘r’ comes before ‘t’.

Example 3: Comparing Strings of Different Lengths

String str1 = "apple";

String str2 = "applesauce";

int result = str1.compareTo(str2);

System.out.println(result);  // Output: Negative number

Here’s what happens:

1. Compare the first five characters: ‘a’, ‘p’, ‘p’, ‘l’, ‘e’ (same in both strings).

2. When “apple” ends, “applesauce” still has more characters. The method considers “apple” smaller than “applesauce” and returns a negative number.

Why Does It Use Unicode?

Java strings are sequences of Unicode characters, and .compareTo() directly operates on their Unicode values because:

1. Universal Standard: Unicode provides a consistent way to compare characters across different languages and scripts.

2. Lexicographical Order: Using Unicode ensures that comparisons are made in dictionary order.

3. Efficiency: Subtracting integer values (Unicode) is faster than comparing characters one by one using complex logic.

More Examples

1. Positive Result: The first string comes after the second.

String str1 = "dog";

String str2 = "cat";

int result = str1.compareTo(str2);  // Output: Positive number

• ‘d’ (Unicode 100) is greater than ‘c’ (Unicode 99).

• Difference: 100 – 99 = 1.

2. Negative Result: The first string comes before the second.

String str1 = "ant";

String str2 = "bat";

int result = str1.compareTo(str2);  // Output: Negative number

• ‘a’ (Unicode 97) is less than ‘b’ (Unicode 98).

• Difference: 97 – 98 = -1.

3. Zero Result: The strings are equal.

String str1 = "tree";

String str2 = "tree";

int result = str1.compareTo(str2);  // Output: 0

• All characters are identical, so the method returns 0.

Tips for AP CS A Students

• Understand the Math: The result of .compareTo() comes directly from subtracting the Unicode values of characters.

• Think Lexicographically: The method behaves like sorting in a dictionary—shorter words come before longer ones if the prefix matches.

• Avoid Null Strings: Ensure strings are not null before calling .compareTo() to avoid runtime errors.

By mastering .compareTo() and understanding its reliance on Unicode subtraction, you’ll gain confidence in string manipulation and be well-prepared for sorting and comparison tasks on the AP CS A exam!