Java中的Comparable<T>和Comparator<T>接口

有的时候在面试时会被问到Comparable<T>和Comparator<T>的区别(或者Java中两种排序功能的实现区别)。

1) 在使用普通数组的时候，如果想对数据进行排序，可以调用java.util.Arrays.sort()。但要通过该方式对数组进行排序，还需要数组中的对象实现Comparable<T>接口。

package org.lyk.entities;

public class Book implements Comparable<Book>
{
    private String name;
    private double price;

    public Book(String name,double price)
    {
        super();
        this.name = name;
        this.price = price;
    }

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public double getPrice()
    {
        return price;
    }

    public void setPrice(double price)
    {
        this.price = price;
    }

    @Override
    public String toString()
    {
        return "Book [name=" + name + ", price=" + price + "]";
    }

    @Override
    public int compareTo(Book o)
    {
        if(this.price < o.price)
            return -1;
        else if(this.price > o.price)
            return 1;
        else
            return 0;
    } 

}

测试代码:

package org.lyk.main;

import org.lyk.entities.*;
import org.lyk.interfaces.*;

import java.math.*;
import java.sql.*;
import java.text.*;
import java.util.*; 

public class Main
{
    public static void main(String[] args)
    {
        Book[] books = new Book[]
        {
            new Book("Java编程思想", 73.8),
            new Book("Java从入门到精通", 40.7),
            new Book("疯狂Java讲义（第3版 附光盘）", 91.3),
            new Book("O'Reilly：Head First Java", 47.3),
            new Book("Java Web整合开发王者归来", 78.8)
        };

        Arrays.sort(books);

        for(Book item : books)
        {
            System.out.println(item);
        }
    }
}

2)现在如果一个类已经开发完成，或者这个类由第三方提供，在这个类中没有实现Comparable<T>接口。此时我们已经不能修改Book类，那么要实现Book数组的排序，就必须借助另外一个Comparator<T>接口。

package org.lyk.entities;

public class Book
{
    private String name;
    private double price;

    public Book(String name,double price)
    {
        super();
        this.name = name;
        this.price = price;
    }

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public double getPrice()
    {
        return price;
    }

    public void setPrice(double price)
    {
        this.price = price;
    }

    @Override
    public String toString()
    {
        return "Book [name=" + name + ", price=" + price + "]";
    }
}

实现Comparator<T>的BookComparator类。

package org.lyk.entities;

import java.util.Comparator;

public class BookComparator implements Comparator<Book>
{

    @Override
    public int compare(Book o1, Book o2)
    {
        if(o1.getPrice() < o2.getPrice())
            return -1;
        else if(o1.getPrice() > o2.getPrice())
            return 1;
        else
            return 0;
    }
}

测试代码:

package org.lyk.main;

import org.lyk.entities.*;
import org.lyk.interfaces.*;

import java.math.*;
import java.sql.*;
import java.text.*;
import java.util.*; 

public class Main
{
    public static void main(String[] args)
    {
        Book[] books = new Book[]
        {
            new Book("Java编程思想", 73.8),
            new Book("Java从入门到精通", 40.7),
            new Book("疯狂Java讲义（第3版 附光盘）", 91.3),
            new Book("O'Reilly：Head First Java", 47.3),
            new Book("Java Web整合开发王者归来", 78.8)
        };

        Arrays.sort(books,new BookComparator());

        for(Book item : books)
        {
            System.out.println(item);
        }
    }
}

小结:

　　一个类实现Comparable<T>接口，那么这个类本身就具有了被排序的功能。

　　一个类如果没有实现Comparable<T>接口，要使该类在数组中能排序,就要另外再写一个针对该类的排序类,新写的类必须实现Comparator<T>功能。

也就是说，一个是自己有比较功能，另一个是让第三方类实现比较功能。