In Java development, arranging object collections based on specific attributes is a frequent requirement. To handle this efficiently, the language provides the Comparable interface, which defines the natural ordering for objects of a class. By implementing this interface, developers enable their objects to be sorted automatically by utilities like Arrays.sort or Collections.sort based on a defined set of rules, such as sorting by ID, age, or priority.

The core contract of the Comparable interface involves the compareTo method. This method accepts a target object for comparison and returns an integer value. The logic dictates that if the current instance is "greater" than the target based on the sorting criteria, it returns a positive integer; if it is "less," it returns a negative integer; and if they are equal, it returns zero.

A standard implementation for comparing an integer property typically follows this structure:

public int compareTo(Object target) {
    Node otherNode = (Node) target;
    if (this.priority > otherNode.priority) {
        return 1;
    }
    if (this.priority < otherNode.priority) {
        return -1;
    }
    return 0;
}

In this snippet, the priority attribute determines the sort order. Developers can easily swap this attribute for other fields, such as weight or timestamp, to change the sorting behavior.

When sorting operations are invoked, the underlying mechanism implicitly calls the compareTo method. The following example demonstrates a User class implementing this interface to sort instances by their userId:

import java.util.Arrays;

public class SortDemo {
    public static void main(String[] args) {
        User[] userList = {
            new User(50, "Alice"),
            new User(12, "Bob"),
            new User(35, "Charlie")
        };

        Arrays.sort(userList);
        System.out.println(Arrays.toString(userList));
    }
}

class User implements Comparable {
    int userId;
    String username;

    public User(int userId, String username) {
        this.userId = userId;
        this.username = username;
    }

    @Override
    public String toString() {
        return this.userId + ": " + this.username;
    }

    @Override
    public int compareTo(Object o) {
        User other = (User) o;
        if (this.userId < other.userId) {
            return -1;
        }
        if (this.userId == other.userId) {
            return 0;
        }
        return 1;
    }
}

Executing this code will output the users ordered by their IDs from lowest to highest.

A critical consideration when implementing this logic is the data type of the fields being compared. Primitive types like int or double support direct arithmetic comparison operators (<, >). However, reference types such as arrays or objects cannot be compared using these operators. Attempting to do so will result in a compilation error.

class DataPacket implements Comparable {
    int[] payload;

    public DataPacket(int[] payload) {
        this.payload = payload;
    }

    @Override
    public int compareTo(Object o) {
        DataPacket other = (DataPacket) o;
        // Compilation Error: bad operand types for binary operator '<'
        if (this.payload < other.payload) {
            return -1;
        }
        return 0;
    }
}

To sort based on complex types like Strings or arrays, developers must use specific comparison methods such as String.compareTo() or Arrays.compare() instead of arithmetic operators.