java Comparable接口与Comparator接口使用小结

Comparable接口和Comparator接口主要功能用于对象的比较和集合、数组的排序。

Comparable接口：

java的基本类型完全实现了Comparable接口，可直接调用compareTo( )方法比较两个对象的大小，很多自定义类内部如果内部实现了Comparable接口，也可实现类似于基本类型调用compareTo( )方法直接比较大小（但返回值只能是int，无法修改为boolean），在使用集合存储引用对象时，可使用Collection.sort( )方法实现集合内部元素的排序。所以建议凡是自定义类涉及数值排序或者与顺序相关的类都实现Comparable接口。

必须在定义类时重写compareTo()方法。

Comparator接口：

Comparator接口一样能够实现Comparable接口的功能，同样是实现比较和排序，区别在于使用Comparator接口排序不需要类实现Comparable接口，即使实现了Comparable接口也可以使用该接口进行排序，问题在于多此一举。因此，Comparator接口的使用场景主要是针对没有实现Comparable接口的类，但又无法修改，或者已经用final修饰，也无法通过继承实现Comparable接口。

必须在实现Comparator接口时重写compare()方法。
示例代码如下：

public class TestComparableAndCompartor {

    public static void main(String[] args) {


        List<Point> listPint = new ArrayList<>();

        for (int i = 0; i < 10; i++) {
            Point pint = new Point();
            pint.setId(i);
            pint.setAngle((float) Math.random());
            pint.setX(i*i+100 -i );
            pint.setY(i*i*i +500 - i*i);//赋值随机数
            listPint.add(pint);
        }
        //调用sort()方法即可直接实现集合内部元素的排序
        Collections.sort(listPint);

        //同样也可以实现comparator接口实现集合内部元素的排序
        /*Collections.sort(listPint, new Comparator<Point>() {
            @Override
            public int compare(Point o1, Point o2) {
                // 自定义比较内容
                return 0;
            }       
        });*/


        List<Edge> listEdge = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Edge edge = new Edge();
            edge.setId(i);
            edge.setSegment(i*i);
            edge.setStart_pint((float)Math.random());
            edge.setEnd_pint(i+1);
            listEdge.add(edge);
        }
        //Edge类没有实现Comparable接口，只有通过实现Comparator接口完成排序
        //如果O1>O2返回正数，则是升序
        Collections.sort(listEdge, new Comparator<Edge>() {
            @Override
            public int compare(Edge o1, Edge o2) {
                if (o1.getStart_pint()< o2.getStart_pint()) {
                    return -1;
                }if (o1.getStart_pint() == o2.getStart_pint()) {
                    return 0;
                }
                return 1;
            }
        });
    }

}
class Point implements Comparable<Point>{
    private int id;
    private float x;
    private float y;
    private float angle;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public float getX() {
        return x;
    }
    public void setX(float x) {
        this.x = x;
    }
    public float getY() {
        return y;
    }
    public void setY(float y) {
        this.y = y;
    }
    public float getAngle() {
        return angle;
    }
    public void setAngle(float angle) {
        this.angle = angle;
    }
    //重写compareTo()方法，定义排序的字段，如果this.angle 大于o.angle返回正数，则是升序
    @Override
    public int compareTo(Point o) {
        if (this.angle > o.angle) {
            return 1;
        }else if (this.angle < o.angle) {
            return -1;
        }else {
            return (int) (this.x - o.x);
        }

    }

}

//未实现Comparable接口的类，排序时需要实现Comparator接口
class Edge{
    private int id;
    private float start_pint;
    private int end_pint;
    private int segment;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public float getStart_pint() {
        return start_pint;
    }
    public void setStart_pint(float start_pint) {
        this.start_pint = start_pint;
    }
    public int getEnd_pint() {
        return end_pint;
    }
    public void setEnd_pint(int end_pint) {
        this.end_pint = end_pint;
    }
    public int getSegment() {
        return segment;
    }
    public void setSegment(int segment) {
        this.segment = segment;
    }



}