Compareable接口的compareTo方法详解

Compareable接口可以实现类中成员属性的排序方法。通过重写Compareable接口中的CompareTo方法实现自定义规则的排序。

针对Compareable接口的排序方式,将通过对学生类和测试类进行一个代码演示

一般情况下

一般情况下Compareable接口是实现自然排序,即依照对象的添加顺序进行排序。如果CompareTo方法中返回的是正整数那么将依照添加顺序正序排序，如果是负整数将依照添加顺序逆序排序。

//student类
public class d_stu implements Comparable<d_stu>{
    //通过对Comparable接口的实现 重写CompareTo方法实现排序规则的自定义
    @Override
    public int compareTo(d_stu o) {
        return -1;//这里直接要求返回-1 所以将按照添加顺序逆序排序
    }
​
    public  String name;
    public int age;
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    @Override
    public String toString() {
        return "d_stu{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
​

import java.util.Iterator;
import java.util.TreeSet;
​
public class demo1 {
    public static void main(String[] args) {
        d_stu d1= new d_stu();
        d_stu d2=new d_stu();
        d_stu d3=new d_stu();
        d_stu d4=new d_stu();
        d_stu d5=new d_stu();
        d1.setName("张三");
        d1.setAge(15);
        d2.setName("李四");
        d2.setAge(14);
        d3.setName("王五");
        d3.setAge(19);
        d4.setName("马六");
        d5.setAge(18);
        d5.setName("jakc");
        d4.setAge(16);
//创建TreeSet集合 将元素添加进去
        TreeSet<d_stu>ts=new TreeSet<>();
        ts.add(d1);
        ts.add(d2);
        ts.add(d3);
        ts.add(d5);
        ts.add(d4);
​
        Iterator<d_stu>it=ts.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}
​

最终程序的运行结果如下，

 

也就是说在直接返回指定数字的情况下。
**如果是负整数的话CompareTo方法将依照元素的添加顺序在输出的时候逆序输出。**
​
**那么是正整数的话就将按照元素的添加顺序在输出的时候正序输出。**
​
**是零的话就另外考虑**

重写方法后

重写方法后也分如下几种情况

成员变量-局部变量

将依据参照变量进行升序排序

//student类
public class d_stu implements Comparable<d_stu>{
    //重写compareTo方法 这里使用成员变量减去局部变量的方式
    @Override
    public int compareTo(d_stu o) {
        return this.getAge()-o.getAge();
        //这里使用age作为参照变量
    }
​
    public  String name;
    public int age;
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    @Override
    public String toString() {
        return "d_stu{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
​

//测试类
import java.util.Iterator;
import java.util.TreeSet;
​
public class demo1 {
    public static void main(String[] args) {
        d_stu d1= new d_stu();
        d_stu d2=new d_stu();
        d_stu d3=new d_stu();
        d_stu d4=new d_stu();
        d_stu d5=new d_stu();
        d1.setName("张三");
        d1.setAge(15);
        d2.setName("李四");
        d2.setAge(14);
        d3.setName("王五");
        d3.setAge(19);
        d4.setName("马六");
        d4.setAge(16);
        d5.setName("jakc");
        d5.setAge(18);
​
        TreeSet<d_stu>ts=new TreeSet<>();
        ts.add(d1);
        ts.add(d2);
        ts.add(d3);
        ts.add(d4);
        ts.add(d5);
​
        Iterator<d_stu>it=ts.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}
​

程序最终运行效果图

 

局部变量-成员变量

将依据参照变量进行降序排序

//student类
public class d_stu implements Comparable<d_stu>{
    //这里重写compareTo方法 采取局部变量减成员变量的方法
    //参照变量为age
    @Override
    public int compareTo(d_stu o) {
        return o.getAge()-this.getAge();
    }
​
    public  String name;
    public int age;
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    @Override
    public String toString() {
        return "d_stu{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
​

//测试类
import java.util.Iterator;
import java.util.TreeSet;
​
public class demo1 {
    public static void main(String[] args) {
        d_stu d1= new d_stu();
        d_stu d2=new d_stu();
        d_stu d3=new d_stu();
        d_stu d4=new d_stu();
        d_stu d5=new d_stu();
        d1.setName("张三");
        d1.setAge(15);
        d2.setName("李四");
        d2.setAge(14);
        d3.setName("王五");
        d3.setAge(19);
        d4.setName("马六");
        d4.setAge(16);
        d5.setName("jakc");
        d5.setAge(18);
​
        TreeSet<d_stu>ts=new TreeSet<>();
        ts.add(d1);
        ts.add(d2);
        ts.add(d3);
        ts.add(d4);
        ts.add(d5);
​
        Iterator<d_stu>it=ts.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

​

程序最终运行效果

 

小结:

针对自定义类对Compareable接口的实现。采取重写compareTo方法的方式可以自定义排序规则。

如果直接在comparaTo方法中返回数值的话。那么排序规则就将判断这个数是正整数还是负整数或者是零来进行排序。如果是正整数就将依照元素的添加顺序采取顺排序。如果是负整数就将依照元素的添加顺序采取倒序排序

如果在重写compareTo方法中采取成员变量减局部变量的方式。那么就将依照表达式中的参照变量进行升序排序

如果在重写compareTo方法中采取局部变量减成员变量的方式。那么将依照表达式中的参照变量进行降序排序