Comparable & Comparator ——比较

Comparable接口

简介：Comparable" 的中文翻译为 “可比较的”。在Java中，Comparable是一个接口，允许对象自身实现compareTo()方法，以定义它们之间的自然顺序。实现Comparable接口的类可以进行自身排序，并且可以用于集合排序，例如Collections.sort()方法。Comparable接口只有一个方法，即compareTo()方法，用于比较两个对象之间的大小关系。该方法返回一个整数值，表示两个对象之间的大小关系。如果该对象小于另一个对象，则返回负数；如果两个对象相等，则返回零；如果该对象大于另一个对象，则返回正数。通过实现Comparable接口，可以用自然顺序比较对象，并在使用排序算法时使用该自然顺序。

案例：用户数组排序

Comparablel类是自己写的，不过具体都差不多

用户Class

/**
 * 用户类
 */
public class User implements Comparable{

    private String name;

    private int age;

    private int height;

    public User() {
    }

    public User(String name, int age, int height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", height=" + height +
                '}';
    }
    
	
    @Override
    public Integer compareTo(Comparable comparable) {
        if (comparable instanceof User) {
            User user = (User) comparable;
            return this.getAge() - user.getAge();
        }
        return null;
    }
}

Comparable接口

/**
 * 可比较的类
 */
public interface Comparable {
    Integer compareTo(Comparable comparable);
}

用户排序Class

/**
 * 用户排序
 */
public class UserSort {

    /**
     * 排序方法
     * @param users
     */
    public void sort(User[] users) {
        for (int i = 0; i < users.length - 1; i++) {
            for (int j = 0; j < users.length - i - 1; j++) {
                if (users[j].compareTo(users[j + 1]) > 0) {
                    User temp = users[j];
                    users[j] = users[j + 1];
                    users[j + 1] = temp;
                }
            }
        }
    }
}

main方法

    public static void main(String[] args) {
        User[] users = {
                new User("张三",30,160),
                new User("李四",33,167),
                new User("王五",26,163),
                new User("赵六",21,170)
        };

        UserSort userSort = new UserSort();
        userSort.sort(users);

        System.out.println(Arrays.toString(users));
    }

结果：

Comparator接口

简介：“Comparator” 的中文翻译为 “比较器”。在Java中，Comparator是一个函数式接口，可以用来定义如何比较两个对象的大小。Comparator接口中有个compare()方法，用于比较两个对象。可以通过Comparator实现类来定制化比较规则。比较器常用于集合的排序操作，其中的排序方法可以自定义比较顺序，而不依赖于实现Comparable接口的类的排序方法。

案例：用户数组排序

Comparator类是自己写的，不过使用也差不多

用户Class

/**
 * 用户类
 */
public class User implements Comparable{

    private String name;

    private int age;

    private int height;

    public User() {
    }

    public User(String name, int age, int height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", height=" + height +
                '}';
    }
}

用户排序Class

/**
 * 用户排序
 */
public class UserSort {

    /**
     * 排序方法
     * @param users
     */
    public void sort(User[] users,Comparator comparator) {
        for (int i = 0; i < users.length - 1; i++) {
            for (int j = 0; j < users.length - i - 1; j++) {
                if (comparator.compare(users[j],users[j + 1]) > 0) {
                    User temp = users[j];
                    users[j] = users[j + 1];
                    users[j + 1] = temp;
                }
            }
        }
    }
}

Comparator接口

/**
 * 比较器
 */
public interface Comparator {

    Integer compare(User u1, User u2);

}

用户年龄策略Class

/**
 * 用户年龄策略
 */
public class UserAgeStrategy implements Comparator{
    /**
     * 用于比较年龄
     * @param u1
     * @param u2
     * @return
     */
    @Override
    public Integer compare(User u1, User u2) {
        return u1.getAge() - u2.getAge();
    }
}

用户身高策略Class

/**
 * 用户身高策略
 */
public class UserHeightStrategy implements Comparator{
    /**
     * 用于比较升高
     * @param u1
     * @param u2
     * @return
     */
    @Override
    public Integer compare(User u1, User u2) {
        return u1.getHeight() - u2.getHeight();
    }
}

main方法

    public static void main(String[] args) {
        User[] users = {
                new User("张三",30,160),
                new User("李四",33,167),
                new User("王五",26,163),
                new User("赵六",21,170)
        };

        UserSort userSort = new UserSort();
        // 这里就可以通过跟换策略而改变代码的业务逻辑
        userSort.sort(users,new UserHeightStrategy());

        System.out.println(Arrays.toString(users));
    }

结果：

Comparable和Comparator的区别

Comparator和Comparable都是Java中用于排序的接口，但它们有以下几个主要区别：

1. Comparable是在类的定义中实现的，而Comparator是在类外部单独实现的。
2. 实现Comparable接口的类可以进行自身的排序，而Comparator则允许通过创建不同的比较器实现对同一类的多种排序方法。
3. Comparable接口定义了自然排序顺序，而Comparator接口定义了自定义排序顺序。
4. 如果一个类实现了Comparable接口，它可以在排序时直接使用Collections.sort()方法。而使用Comparator接口时，必须显式指定>Comparator对象，以说明排序方法。

总而言之，Comparable适用于单一排序方法，当类本身自身的属性可以用于进行排序时应当使用。而Comparator适用于多重排序方法>或外部排序控制。如果需要一种默认的排序方式，可以实现Comparable接口，如果需要提供多个排序方法或同时考虑外部因素，则应该使>用Comparator接口。