先看下两个接口区别
public interface Comparable<T> {
public int compareTo(T o);
}
public interface Comparator<T> {
int compare(T o1, T o2);
boolean equals(Object obj);
}
用例子说话
ArrayList<Integer> integerList = new ArrayList<>();
integerList.add(3);
integerList.add(1);
integerList.add(2);
Collections.sort(integerList);
System.out.println("\n***************纯数字排序Collections.sort(integerList)***************");
System.out.println("默认排序\n" + integerList);
Collections.reverse(integerList);
System.out.println("倒序排序\n" + integerList);
System.out.println("\n***************纯字母排序Collections.sort(stringList)***************");
ArrayList<String> stringList = new ArrayList<>();
stringList.add("c");
stringList.add("a");
stringList.add("b");
Collections.sort(stringList);
System.out.println("默认排序\n" + stringList);
Collections.reverse(stringList);
System.out.println("倒序排序\n" + stringList);
System.out.println("\n***************自定义排序***************");
ArrayList<User> userList = new ArrayList<>();
userList.add(new User("aa",18));
userList.add(new User("aa",17));
userList.add(new User("ab",19));
System.out.println("按名字排序(升序)");
//可以直接用匿名类,也可以单独写一个实现类(Comparable接口只能用于排序的类的实现上)
Comparator<User> userComparator = new Comparator<User>() {
@Override
public int compare(User o1, User o2) {
//写法一
int result = o1.getName().compareTo(o2.getName());
if(result > 0){
return 1;
}else if(result < 0){
return -1;
}
return 0;
//写法二(效果一样)
// return o1.getName().compareTo(o2.getName());
}
};
Collections.sort(userList,userComparator);
for(User user : userList){
System.out.println(user.toString());
}
System.out.println("按名字排序(降序)");
Comparator<User> userComparator2 = new Comparator<User>() {
@Override
public int compare(User o1, User o2) {
int result = o1.getName().compareTo(o2.getName());
if(result > 0){
return -1;
}else if(result < 0){
return 1;
}
return 0;
}
};
Collections.sort(userList,userComparator2);
for(User user : userList){
System.out.println(user.toString());
}
System.out.println("按年龄排序(升序)");
Collections.sort(userList,new AgeComparator());
for(User user : userList){
System.out.println(user.toString());
}
System.out.println("按年龄排序(降序)");
Collections.sort(userList,new AgeComparator2());
for(User user : userList){
System.out.println(user.toString());
}
System.out.println("\n***************用Comparable排序(先按名字降序排列,再按年龄升序排列)***************");
Collections.sort(userList);
for(User user : userList){
System.out.println(user.toString());
}
***************纯数字排序Collections.sort(integerList)***************
默认排序
[1, 2, 3]
倒序排序
[3, 2, 1]
***************纯字母排序Collections.sort(stringList)***************
默认排序
[a, b, c]
倒序排序
[c, b, a]
***************自定义排序***************
按名字排序(升序)
name:aa age:18
name:aa age:17
name:ab age:19
按名字排序(降序)
name:ab age:19
name:aa age:18
name:aa age:17
按年龄排序(升序)
name:aa age:17
name:aa age:18
name:ab age:19
按年龄排序(降序)
name:ab age:19
name:aa age:18
name:aa age:17
***************用Comparable排序(先按名字降序排列,再按年龄升序排列)***************
name:ab age:19
name:aa age:17
name:aa age:18
User类
public class User implements Comparable<User>{
private String name;
private int age;
public User(String name, int age){
this.name = name;
this.age = age;
}
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 String toString(){
return "name:" + this.name + " age:" + this.age;
}
//先按名字降序排列,再按年龄升序排列
@Override
public int compareTo(User o) {
int nameResult = this.getName().compareTo(o.getName());
if(nameResult > 0){
return -1;
}else if(nameResult < 0){
return 1;
}
int ageResult = this.getAge() - o.getAge();
if(ageResult > 0){
return 1;
}else if(ageResult < 0){
return -1;
}
return 0;
}
}
Comparator比较器
public class AgeComparator implements Comparator<User> {
@Override
public int compare(User o1, User o2) {
return o1.getAge() - o2.getAge();
}
}
public class AgeComparator2 implements Comparator<User> {
@Override
public int compare(User o1, User o2) {
int result = o1.getAge() - o2.getAge();
if(result > 0){
return -1;
}else if(result < 0){
return 1;
}
return 0;
}
}