Question

Java中Comparator接口的用法

对集合排序的例子

import java.util.ArrayList;

import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/*
* 当前文件： TestCollections.java
* 创建日期： 2006-6-29
* 版 本 号： 1.0
* 作 者： Stevie Liu
*
*/

/**
* 亲爱的kang1，请您在此详细描述我的用途.
*/

class BookType{
String idsn;
String name;
/**
* @param idsn
* @param name
*/
public BookType(String idsn, String name)
{
super();
this.idsn = idsn;
this.name = name;
}
/**
* @return Returns the idsn.
*/
public String getIdsn()
{
return idsn;
}
/**
* @param idsn The idsn to set.
*/
public void setIdsn(String idsn)
{
this.idsn = idsn;
}
/**
* @return Returns the name.
*/
public String getName()
{
return name;
}
/**
* @param name The name to set.
*/
public void setName(String name)
{
this.name = name;
}
}
public class TestCollections
{

public static void main(String[] args)
{
List list=new ArrayList();
list.add(new BookType("1","k"));
list.add(new BookType("5","z"));
list.add(new BookType("4","g"));

Comparator OrderIsdn = new Comparator(){
public int compare(Object o1, Object o2){
BookType b1=(BookType)o1;
BookType b2=(BookType)o2;
return (b1.getIdsn().hashCode()-b2.getIdsn().hashCode());
}
};

Comparator OrderName = new Comparator(){
public int compare(Object o1, Object o2){
BookType b1=(BookType)o1;
BookType b2=(BookType)o2;
return (b1.getName().hashCode()-b2.getName().hashCode());
}
};

Collections.sort(list,OrderName);
Collections.reverse(list);

for(int i=0;i
BookType ss=(BookType)list.get(i);
System.out.print(ss.getIdsn());
System.out.println(ss.getName());
}

}
}

程序有点长，但是不难，谢谢各位耐心看完，我得问题是，Comparator不是一个接口，为什么程序中还有这样的语句：
Comparator OrderIsdn = new Comparator(){
public int compare(Object o1, Object o2){
BookType b1=(BookType)o1;
BookType b2=(BookType)o2;
return (b1.getIdsn().hashCode()-b2.getIdsn().hashCode());
}
};

我知道这是匿名类，但是接口可以通过new实例化吗？

Answer 1

在java编程中，如果要对集合对象或数组对象进行排序，需要实现Comparator接口以达到目标，用法如下（模拟下在集合对象中对日期属性进行排序）：

一、实体类Step

package com.ljq.entity;
/**
 * 运号单流程
 * 
 * @author Administrator
 * 
 */
public class Step{
    /** 处理时间 */
    private String acceptTime = "";
    /** 快件所在地点 */
    private String acceptAddress = "";

    public Step() {
        super();
    }
    public Step(String acceptTime, String acceptAddress) {
        super();
        this.acceptTime = acceptTime;
        this.acceptAddress = acceptAddress;
    }
    public String getAcceptTime() {
        return acceptTime;
    }
    public void setAcceptTime(String acceptTime) {
        this.acceptTime = acceptTime;
    }
    public String getAcceptAddress() {
        return acceptAddress;
    }
    public void setAcceptAddress(String acceptAddress) {
        this.acceptAddress = acceptAddress;
    }
}

二、实现Comparator接口

package com.ljq.entity;
import java.util.Comparator;
import java.util.Date;
import com.ljq.util.UtilTool;
/**
 * 对Step类进行排序
 * 
 * @author Administrator
 *
 */
public class StepComparator implements Comparator<Step>{

    /**
     * 如果o1小于o2,返回一个负数;如果o1大于o2，返回一个正数;如果他们相等，则返回0;
     */
    @Override
    public int compare(Step o1, Step o2) {
        Date acceptTime1=UtilTool.strToDate(o1.getAcceptTime(), null);
        Date acceptTime2=UtilTool.strToDate(o2.getAcceptTime(), null);
        //对日期字段进行升序，如果欲降序可采用before方法
        if(acceptTime1.after(acceptTime2)) return 1;
        return -1;
    }
}

三、代码测试

package junit;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import org.junit.Test;
public class StepComparatorTest {
    @Test
    public void sort() throws Exception{
        List<Step> steps=new ArrayList<Step>;
        //对集合对象进行排序
         StepComparator comparator=new StepComparator();
        Collections.sort(steps, comparator);
        if(steps!=null&&steps.size()>0){
            for(Step step:steps){
               System.out.println(step.getAcceptAddress());
               System.out.println(step.getAcceptTime());
            }
        }
    }
}

Answer 2

在后面的代码中先实现这个接口然后再实例化的，由于是匿名类，没有名字，只好用接口名字代替，所以就成了你看到的new一个接口了。其实是new了一个实现了这个接口的匿名类出来。

Answer 3

这是匿名内部类 可以声明一个接口的实现类，这是没问题的.
如果接触后台，你可能经常做这样的声明 XXDAO xx= new XXDAOHibernateImpl(); 其中XXDAOHibernateImpl就是XXDAO的实现类，这句话表达的是声明一个XXDAO接口类型的变量，这变量指向这个接口某一实现类的实例。

举个例子:
public interface UserDAO{
public void save(User u);
}
public class UserDAOImpl inplements UserDAO{
public void save(User u){
.......;
}
}

完全可以这样声明：UserDAO dao = new UserDAOImpl();

Answer 4

我觉得楼上说的和楼主想问的不是一个概念，楼主是知道怎么new一个已经实现了接口的类的，只是不太明白为什么能够直接new一个接口。

我给你个通俗易懂的解释，其实这一句：
Comparator OrderIsdn = new Comparator(){

相当于（不是标准语法，只是说明原理，帮助理解）：
Comparator OrderIsdn = new (MyComp implements Comparator)(){

只是由于是匿名类没有名字，所以就变成你看到的那样了。

实际上，你问的这种写法是java的标准写法，它的意义是我将要实现这个接口并且由这个实现创建一个对象。注意并不是直接实例化接口（虽然看起来像），而是先实现（后面的一对大括号中的代码）再实例化。

Answer 5

匿名内部类。