在java中比较两个对象的大小 ，可以实现Comparable接口，然后重写当中的compareTo方法。比如：

import java.util.*;

public class TestCompare {

    public static void main(String[] args) {
        ArrayList<Student> s = new ArrayList<>();
        s.add(new Student(0, "张三", 123));
        s.add(new Student(1, "李四", 456));
        s.add(new Student(2, "王五", 123));
        s.add(new Student(3, "zhangsan", 1233));
        s.add(new Student(4, "tracy", 555));
        Collections.sort(s);
        Iterator<Student> it = s.iterator();
        while(it.hasNext()) {
            Student temp = it.next();
            System.out.println(temp);
        }
        
        //其实Integer当中的compareTo方法也是Integer实现了Comparable<Integer>接口，重写了当中的compareTo方法
        //所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类，都重写了compareTo方法
        Integer i = new Integer(5);
        System.out.println(i.compareTo(new Integer(6)));
    }

}


class Student implements Comparable<Student>{
    private int id;
    private String name;
    private int score;
    public Student(int id, String name, int score) {
        super();
        this.id = id;
        this.name = name;
        this.score = score;
    }
    
    /**
     * 按照分数的高低进行排序，相同分数的按照id从小到大排序
     */
    @Override
    public int compareTo(Student o) {
        if(this.score != o.score) {
            return this.score < o.score ? 1 : -1;
        } else {
            return this.id > o.id ? 1 : -1;
        }
    }

    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", score=" + score + "]";
    }
}

在Hadoop当中呢，
实现WritableComparable，可以把对象序列化，同时重写compareTo方法， hadoop把 Writable和Comparable两个接口封装在了一起。
WritableComparable<>包含了Writable和Comparable<>两个接口。

序列化和反序列化重写的方法：

    /**
     * 这个就是序列化的方法
     * @param dataOutput
     * @throws IOException
     */
    @Override
    public void write(DataOutput dataOutput) throws IOException {
        dataOutput.writeLong(upFlow);
        dataOutput.writeLong(downFlow);
        dataOutput.writeLong(sumFlow);
    }

    /**
     * 反序列化的方法
     * 注意反序列化的顺序 先序列化的先出来 跟序列化顺序保持一致
     * @param dataInput
     * @throws IOException
     */
    @Override
    public void readFields(DataInput dataInput) throws IOException {
        this.upFlow = dataInput.readLong();
        this.downFlow = dataInput.readLong();
        this.sumFlow = dataInput.readLong();
    }