自然排序与比较器排序的使用

1、自然排序：java.lang.Comparable

Comparable 接口中只提供了一个方法： compareTo(Object obj) ，该方法的返回值是 int 。如果返回值为正数，则表示当前对象(调用该方法的对象)比 obj 对象“大”；反之“小”；如果为零的话，则表示两对象相等。

总结为一句话：实现Comparable，重写 compareTo方法

案列：以TreeMap为例，默认的升序，可以重写自然排序的方法改变原有排序

public static void testComparable(){
        TreeMap<Car,Object> tmp = new TreeMap<Car,Object>();
        tmp.put(new Car(4), "肆");
        tmp.put(new Car(1), "壹");
        tmp.put(new Car(5), "伍");
        tmp.put(new Car(3), "三");
        tmp.put(new Car(2), "贰");
        System.out.println(tmp);
        //结果：//{Car [price=5.0]=伍, Car [price=4.0]=肆, Car [price=3.0]=三, Car [price=2.0]=贰, Car [price=1.0]=壹}
    }
1
2
3
4
5
6
7
8
9
10

//自定义TreeMap排序方法 自然排序

class Car implements Comparable<Car>{
    private double price;
 
    @Override
    public int compareTo(Car o) {
        // TODO Auto-generated method stub
        if(this.price>o.getPrice()){
            return -1;//大的往前排
        }else if(this.price<o.getPrice()){
            return 1;//小的往后排
        }else{
            return 0;
        }
    }
 
    @Override
    public String toString() {
        return "Car [price=" + price + "]";
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2、比较器排序：java.util.Comparator

总结为一句话：实现Comparator 接口，重写compare方法

public static void testComparator(){
        //HashMap hm = new HashMap();
        TreeMap<Integer,Object> tmp = new TreeMap<Integer,Object>(new MyComparatorBigtoSmall());
        tmp.put(4, "肆");
        tmp.put(1, "壹");
        tmp.put(5, "伍");
        tmp.put(3, "三");
        tmp.put(2, "贰");
        //System.out.println(tmp);//默认排序结果：{1=壹, 2=贰, 3=三, 4=肆, 5=伍}
        System.out.println(tmp);//修改为比较器排序(升序){5=伍, 4=肆, 3=三, 2=贰, 1=壹}
    }
 
//自定义TreeMap排序方法    比较器排序    
    class MyComparatorBigtoSmall implements Comparator<Integer>{
 
        @Override
        public int compare(Integer o1, Integer o2) {
            // TODO Auto-generated method stub
            return o2-o1;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

自然排序的使用

第一步：使用空参构造创建一个TreeSet集合对象。

第二步：在自定义类中实现一个Comparable接口（注意，接口里要写泛型，而泛型的类型要与集合里的数据类型一致）

第三步：重写里面的compareTo()抽象方法。抽象方法里要写排序规则，排序规则如下。

/*
 * TreeSet集合来存储Student类型
 * */
public class MyTreeSet2 {
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<>();

        Student s1 = new Student("xuyimiao",28);
        Student s2 = new Student("chenxuyuan",27);
        Student s3 = new Student("xiaoyufeng",29);
        Student s4 = new Student("caofengze",28);
        Student s5 = new Student("caofengze",30);


        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        System.out.println(ts);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class Student implements  Comparable<Student>{
    private String name;
    private int age;
    public Student() {
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        //按照对象的年龄进行排序
        //主要判断条件
        int result = this.age - o.age;
        //次要判断条件
        result = result == 0 ? this.name.compareTo(o.getName()) : result;
        return result;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

比较器排序的使用

public class MyTreeSet4 {
    public static void main(String[] args) {
        TreeSet<Teacher> ts = new TreeSet<>(new Comparator<Teacher>() {
            @Override
            public int compare(Teacher o1, Teacher o2) {
                //o1表示现在要存入的那个元素
                //o2表示已经存入到集合中的元素
                //主要条件
                int result = o1.getAge() - o2.getAge();
                //次要条件
                result = result == 0 ? o1.getName().compareTo(o2.getName()) : result;
                return result;
            }
        });
        Teacher t1 = new Teacher("zhangsan",23);
        Teacher t2 = new Teacher("lisi",22);
        Teacher t3 = new Teacher("wangwu",24);
        Teacher t4 = new Teacher("zhaoliu",24);
        ts.add(t1);
        ts.add(t2);
        ts.add(t3);
        ts.add(t4);
        System.out.println(ts);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class Teacher {
    private String name;
    private int age;

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

---

该使用哪一种方式？

如何理解？

//按长度进行排序
public class MyTreeSet5 {
    public static void main(String[] args) {
        TreeSet<String> ts = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //首先比较字符串长度是否相等，短的字符串放左边，长的字符串放右边
                int result = o1.length() - o2.length();
                //如果字符串长度相等，再来比里面的字母。ASCII码小的在左边，ASCII码大的在右边
                result = result == 0 ? o1.compareTo(o2) : result;
                return result;
            }
        });
        //Lambda表达式方法
        /*TreeSet ts = new TreeSet<>((String o1, String o2) -> {
            int result = o1.length() - o2.length();
            result = result == 0 ? o1.compareTo(o2) : result;
            return result;
        });*/
        ts.add("c");
        ts.add("ab");
        ts.add("df");
        ts.add("qwer");

        System.out.println(ts);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

上面这串代码中，由于Java自带的String类中已经重写了Comparable接口，我们没法再修改。所以只能使用比较排序。