Osheep

时光不回头,当下最重要。

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 <T> void sort(T[] a, Comparator<? super T> c)。

范例:实现排序

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接口。

更多内容戳下面:

点赞