标签：重载 修改 自动 return system 另一个 情况 pre 工具类
本节内容，比较器Comparable是核心内容。
在之前一直使用的“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 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]
以上实际上就属于数组的基本操作，只不过这样的操作在实际的开发里面很少出现。
下面来观察一下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（小于）。
范例：使用比较器
/**
* Java学习交流QQ群：589809992 我们一起学Java！
*/
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接口。
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接口。
Java学习交流QQ群：589809992 我们一起学Java！
标签：重载 修改 自动 return system 另一个 情况 pre 工具类
原文地址：http://www.cnblogs.com/aishangJava/p/7633138.html
