What Does .compare() Do in Java?

The compare() method in Java is used to compare two objects of a specific class. It’s a crucial part of sorting and ordering collections of custom objects. Understanding how it works is fundamental for any Java developer working with data structures. This article delves into the functionality of compare(), its return values, and various implementation strategies.

Understanding the compare() Method’s Role

The compare() method, part of the Comparator interface, defines the logic for ordering objects. It takes two objects as input (let’s call them obj1 and obj2) and returns an integer value that signifies their relative order:

• 0: Returned if obj1 is equal to obj2.
• -1 (or any negative value): Returned if obj1 is less than obj2.
• 1 (or any positive value): Returned if obj1 is greater than obj2.

This return value dictates how objects are arranged in sorted collections like TreeSet or when using sorting algorithms like Collections.sort().

Syntax of the compare() Method

public int compare(Object obj1, Object obj2)

Example: Comparing Integers

A simple example demonstrates how compare() works with the Integer class:

import java.lang.Integer;

class Main {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        System.out.println(Integer.compare(a, b)); // Output: -1 (a < b)

        int x = 30;
        int y = 30;

        System.out.println(Integer.compare(x, y)); // Output: 0 (x == y)


        int w = 15;
        int z = 8;

        System.out.println(Integer.compare(w, z)); // Output: 1 (w > z)
    }
}

Internal Working of compare()

The logic within compare() often involves subtracting the values of the two objects after casting them to a comparable type. Here’s a simplified representation:

int intObj1 = (int)obj1;
int intObj2 = (int)obj2;

int difference = intObj1 - intObj2;

if (difference == 0) {
    return 0;
} else if (difference < 0) {
    return -1;
} else {
    return 1;
}

Implementing compare() for Custom Objects

For custom classes, you need to implement the Comparator interface and define the compare() method to specify how instances of your class should be compared. Here’s an example demonstrating this internal logic:

import java.lang.Integer;

class Main {

    public static int compare(Object obj1, Object obj2) {
        int intObj1 = (int)obj1;
        int intObj2 = (int)obj2;
        int difference = intObj1 - intObj2;

        if (difference == 0) {
            return 0;
        } else if (difference < 0) {
            return -1;
        } else {
            return 1;
        }
    }

    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(compare(a, b)); // -1

        int x = 30;
        int y = 30;
        System.out.println(compare(x, y)); // 0

        int w = 15;
        int z = 8;
        System.out.println(compare(w, z)); // 1
    }
}

Different Implementations of compare()

The compareTo() method within the Integer class (and other wrapper classes) provides flexibility in defining comparison logic:

public int compare(Object obj1, Object obj2){
    Integer I1 = (Integer)obj1; 
    Integer I2 = (Integer)obj2; 

    // Ascending order
    return I1.compareTo(I2); 

    // Descending order - Option 1
    return -I1.compareTo(I2);

    // Descending order - Option 2
   return I2.compareTo(I1);  
}

Conclusion

The compare() method is essential for establishing order among objects in Java. By understanding its workings and different implementation approaches, you can effectively utilize it for sorting and managing collections of objects, leading to cleaner and more efficient code.