Comparable和Comparator

Comparable和Comparator

package java.lang;

import java.util.*;

public interface Comparable<T> {

    public int compareTo(T o);

}

Comparable在java.lang包下，是一个接口，内部只有一个compareTo(T o)方法；

Comparable可以让实现它的类的对象进行比较，具体的比较规则是按照compareTo方法中的规则进行。这种顺序称为自然顺序。

package cn.chen.base;

import java.io.Serializable;

public class Book implements Serializable,Comparable

{

    private String name ;

    private int count ;

    public Book(String name, int count) {

        this . name = name;

        this . count = count;

    }

    @Override

    public boolean equals(Object obj) {

        if ( this == obj) return true ;

        if (!(obj instanceof Book)) return false ;

        Book book = (Book)obj;

        if (getCount() != book.getCount()) return false ;

        return getName().equals(book.getName());

    }

    @Override

    public int hashCode() {

        int result = getName().hashCode();

        result = 31 * result + getCount();

        return result;

    }

    @Override

    public String toString() {

        return "Book{" +

                "name='" + name + ' \' ' +

                ", count=" + count +

                '}' ;

    }

    @Override

    public int compareTo(Object anthor) {

        if (anthor instanceof Book){

            Book book = (Book)anthor;

            int result;

            result = getCount() - book.getCount();

//            result = getName().compareTo(book.getName());

            if (result == 0 ){

                result  = getName().compareTo(book.getName());

            }

            return result;

        }

        return 0 ;

    }

    public String getName() {

        return name ;

    }

    public void setName(String name) {

        this . name = name;

    }

    public int getCount() {

        return count ;

    }

    public void setCount( int count) {

        this . count = count;

    }

}

Comparator定制排序

Comparator在java.util包下，也是一个接口，JDK1.8之前只有两个方法

public interface Comparator<T> { 

    public int compare(T lhs, T rhs); 

    public boolean equals(Object object); 

}

JDK1.8之后又新增了很多和Function相关的方法

Comparator在外部制定排序规则，然后作为排序策略参数传递给某些类，比如Collections.sort(),Arrays.sort()，或者一些内部有序的集合比如SortedSet，SortedMap等。

使用方式主要分三步：

1.创建一个Comparator借口的实现类，并赋值给一个对象，在compare方法中针对自定义类写排序规则

2.将Comparator对象作为参数传递给排序类的某个方法

3.向排序类中添加compare方法中使用的自定义类

Comparator comparator = new Comparator() {

    @Override

    public int compare(Object o1, Object o2) {

        if (o1 instanceof Book && o2 instanceof Book){

            return ((Book) o1).getCount() - ((Book) o2).getCount();

        }

        return 0 ;

    }

};

TreeSet treeSet = new TreeSet( comparator );

private void test(){

    treeSet .add( new Book( "Java" , 111 ));

    treeSet .add( new Book( "Python" , 1 ));

    treeSet .add( new Book( "Scala" , 14 ));

    treeSet .add( new Book( "C" , 14 ));

}

Comparator的使用是一种策略模式。

Comparable 自然排序。（实体类实现）

Comparator 定制排序。（无法修改实体类时，直接在调用方创建）

同时存在时采用Comparator的规则进行比较。