Java比较器

导语

本节内容，比较器Comparable是核心内容。

主要内容

• 重新认识Arrays类
• 两种比较器的使用

具体内容

Arrays类

在之前一直使用的“java.util.Arrays.sort()”可以实现数组的排序，而Arrays类就是java.util包中提供的一个工具类，这个工具类主要是完成所有与数组有关的操作功能。

在这个类里面存在有二分查找法：public static int binarySearch(数据类型[] a, 数据类型 key)。但是如果要进行二分查找，有一个前提，那么就是数组必须是排序后的内容。

范例：实现二分查找

public class TestDemo {
    public static void main(String args[]) {
        int data [] = new int [] {1, 5, 6, 2, 3, 4, 9, 8, 7, 10}; 
        java.util.Arrays.sort(data);  // 进行排序
        System.out.println(Arrays.binarySearch(data, 9));
    }
}

输出结果

8

Arrays类提供了数组比较：public static boolean equals(数据类型[] a, 数据类型[] a2)，只不过借用了equals的方法名称，与Object类的equals()没有关系。

范例：实现二分查找

public class TestDemo {
    public static void main(String args[]) {
        int dataA [] = new int [] {1, 2, 3}; 
        int dataB [] = new int [] {2, 1, 3}; 
        int dataC [] = new int [] {1, 2, 3}; 
        System.out.println(Arrays.equals(dataA, dataB));
        System.out.println(Arrays.equals(dataA, dataC));
    }
}

输出结果

false
ture

要想判断数组是否相同，需要顺序完全一致。

• 填充数组：public static void fill(数据类型[] a, 数据类型 val)。
• 将数组变为字符串输出：public static String toString(数据类型[] a)。

范例：使用上面方法

public class TestDemo {
    public static void main(String args[]) {
        int data[] = new int[10];
        Arrays.fill(data, 3);
        System.out.println(Arrays.toString(data));
    }
}

输出结果

[3, 3, 3, 3, 3, 3, 3, 3, 3, 3]

以上实际上就属于数组的基本操作，只不过这样的操作在实际的开发里面很少出现。

比较器：Comparable（核心）

下面来观察一下Arrays类中提供的数组排序方法：public static void sort(Object[] a)。
发现Arrays类里面可以直接利用sort()方法实现对象数组排序。

范例：编写测试代码

public class Book {
    private String title;
    private double price;
    public Book(String title, double price) {
    this.title = title;
    this.price = price;
    }
    public String to String() {
        return "书名：" + this.title + " 价格：" + this.price;
    }
}

public class TestDemo {
    public static void main(String args[]) {
        Book books [] = new Book [] {
                new Book("Java开发", 79.8), 
                new Book("JSP开发", 69.8), 
                new Book("Oracle开发", 99.8), 
                new Book("Android开发", 89.8), 
        };
        Arrays.sort(books);  // 对象数组排序
        System.out.println(Arrays.toString(books));
    }
}

输出结果

Exception in thread "main" java.lang.ClassCastException：Book cannot be cast to java.lang.Comparable...

造成此类异常只有一个原因：丙个没有关系的类对象发生了强制性的转换。

每一个对象实际上只保留有地址信息，地址里面是有内容的，所以如果是普通的int型数组要进行比较，只要判断大小就够了，但是如果是对象数组，里面包含的如果只是编码（地址）比较是没意义的，就拿上面的代码来讲，应该按照价格排序才是有意义的，所以此处必须要明确地设置出比较的规则：
比较的规则就是由Comparable接口定义的，此接口定义如下：

public interface Comparable<T> {
    public int compareTo(T o);
}

实际上String类就是Comparable接口的子类，之前使用的compareTo()方法就是比较的操作功能，如果用户现在要针对于对象进行比较，建议compareTo()方法返回三类数据：1（大于）、0（等于）、-1（小于）。

范例：使用比较器

public class Book implements Comparable<Book> {  // 实现比较
    private String title;
    private double price;
    public Book(String title, double price) {
    this.title = title;
    this.price = price;
    }
    @Override
    public String to String() {
        return "书名：" + this.title + " 价格：" + this.price;
    }
    @Override
    public int compareTo(Book o) {  // Arrays.sort()会自动调用此方法比较
        if(this.price > o.price) {
            return 1;
        } else if(this.price < o.price) {
            return -1;
        } else {
            return 0;
        }
    }
}

public class TestDemo {
    public static void main(String args[]) {
        Book books [] = new Book [] {
                new Book("Java开发", 79.8), 
                new Book("JSP开发", 69.8), 
                new Book("Oracle开发", 99.8), 
                new Book("Android开发", 89.8), 
        };
        Arrays.sort(books);  // 对象数组排序
        System.out.println(Arrays.toString(books));
    }
}

输出结果

[书名：JSP开发 价格：69.8, 书名：Java开发 价格：79.8, 书名：Android开发 价格：89.8, 书名：Oracle开发 价格：99.8]

compareTo()方法由Arrays.sort()自动进行调用。

以后不管何种情况下，只要是一组对象要排序，对象所在的类一定要实现Comparable接口。

挽救的比较器：Comparator

Comparable接口的主要特征是在类定义的时候就默认实现好的接口，那么如果说现在有一个类已经开发完善了。
但是由于初期的设计并没有安排此类对象数组的排序，而后又突然需要实现对象数组的排序，那么这个时候，在不能修改Book类定义的情况下是不能使用Comparable接口的，为此，在Java里面为了解决这个问题，在Java里又出现了另一个比较器：java.util.Comparator。

原本在Comparator接口下有两个方法：

@FunctionalInterface
public interface Comparator<T> {
    public int compare(T o1, T o2);
    public boolean equals(Object obj);
}

而真正要实现的只有compare()方法，需要单独准备出一个类来实现Comparator接口，这个类将作为指定类的排序类。

范例：定义排序的工具类

public class BookComparator implements Comparator<Book> {
    @Override
    public int compare(Book o1, Book o2) {
        if(o1.getPrice() > o2.getPrice()) {
            return 1;
        } else if(o1.getPrice() < o2.getPrice()) {
            return -1;
        } else {
            return 0;
        }
    }
}

之前使用Comparable接口的时候利用的是Arrays类中的sort()方法，可是现在更换了一个接口之后，那么可以使用另外一个被重载的sort()方法：public static void sort(T[] a, Comparator

public class TestDemo {
    public static void main(String args[]) {
        Book books [] = new Book [] {
                new Book("Java开发", 79.8), 
                new Book("JSP开发", 69.8), 
                new Book("Oracle开发", 99.8), 
                new Book("Android开发", 89.8), 
        };
        Arrays.sort(books, new BookComparator());  // 对象数组排序
        System.out.println(Arrays.toString(books));
    }
}

输出结果：

[书名：JSP开发 价格：69.8, 书名：Java开发 价格：79.8, 书名：Android开发 价格：89.8, 书名：Oracle开发 价格：99.8]

使用Comparator比较麻烦，因为要定义一个专门的排序类，而且调用排序的时候也要明确的指明一个排序规则类。

面试题：请解释Comparable和Comparator的区别。
- 如果对象数组要进行排序那么必须设置排序规则，可以使用Comparable或Comparator接口实现。
- java.lang.Comparable是在一个类定义的时候要去实现好的接口，这样本类的对象数组就可以进行排序，在Comparable接口下定义有一个public int compareTo()方法。
- java.util.Comparator是专门定义一个指定类的比较规则，属于挽救的比较操作，里面有两个方法：compare()、equals()。

总结

不管何种情况下，只要牵扯到对象数组的排序大多数使用Comparable接口。

进入我的CSDN戳这里（我的博客导航）