在Java中传递比较器语法帮助

我试过几种方法，第一种是在下面代码的底部有一个实现comparator的类。当我试图在sortListByLastName中传递Comparator时，我得到了一个构造函数not found错误，我不知道为什么

import java.util.*;

public class OrganizeThis implements WhoDoneIt
{
    /** 
    Add a person to the organizer

    @param p A person object
    */
    public void add(Person p)
    {   
        staff.put(p.getEmail(), p);
        //System.out.println("Person " + p + "added");
    }

    /**
    * Remove a Person from the organizer.
    *
    * @param email The email of the person to be removed.
    */
    public void remove(String email)
    {
        staff.remove(email);
    }

    /**
    * Remove all contacts from the organizer.
    *
    */
    public void empty()
    {
        staff.clear();
    }

    /**
    * Find the person stored in the organizer with the email address.
    * Note, each person will have a unique email address.
    * 
    * @param email The person email address you are looking for.
    *
    */
    public Person findByEmail(String email)
    {
        Person aPerson = staff.get(email);
        return aPerson;
    }

    /**
    * Find all persons stored in the organizer with the same last name.
    * Note, there can be multiple persons with the same last name.
    * 
    * @param lastName The last name of the persons your are looking for.
    *
    */
    public Person[] find(String lastName)
    {
        ArrayList<Person> names = new ArrayList<Person>();

        for (Person s : staff.values())
        {
            if (s.getLastName() == lastName) {
                names.add(s);
            }
        }
        // Convert ArrayList back to Array
        Person nameArray[] = new Person[names.size()];
        names.toArray(nameArray);
        return nameArray;
    }

    /**
    * Return all the contact from the orgnizer in
    * an array sorted by last name.
    * 
    * @return An array of Person objects.
    *
    */
    public Person[] getSortedListByLastName()
    {
        PersonLastNameComparator comp = new PersonLastNameComparator();
        Map<String, Person> sorted = new TreeMap<String, Person>(comp);


        ArrayList<Person> sortedArrayList = new ArrayList<Person>();
        for (Person s: sorted.values()) {
            sortedArrayList.add(s);
        }
        Person sortedArray[] = new Person[sortedArrayList.size()];
        sortedArrayList.toArray(sortedArray);
        return sortedArray;
    }


    private Map<String, Person> staff = new HashMap<String, Person>();

    public static void main(String[] args)
    {
        OrganizeThis testObj = new OrganizeThis();
        Person person1 = new Person("J", "W", "111-222-3333", "JW@ucsd.edu");
        Person person2 = new Person("K", "W", "345-678-9999", "KW@ucsd.edu");
        Person person3 = new Person("Phoebe", "Wang", "322-111-3333", "phoebe@ucsd.edu");
        Person person4 = new Person("Nermal", "Johnson", "322-342-5555", "nermal@ucsd.edu");
        Person person5 = new Person("Apple", "Banana", "123-456-1111", "apple@ucsd.edu");
        testObj.add(person1);
        testObj.add(person2);
        testObj.add(person3);
        testObj.add(person4);
        testObj.add(person5);

        System.out.println(testObj.findByEmail("JW@ucsd.edu"));
        System.out.println("------------" + '\n');

        Person a[] = testObj.find("W");

        for (Person p : a)
        System.out.println(p);

        System.out.println("------------" + '\n');
        a = testObj.find("W");

        for (Person p : a)
        System.out.println(p);

        System.out.println("SORTED" + '\n');
        a = testObj.getSortedListByLastName();
        for (Person b : a) {
            System.out.println(b);
        }

        System.out.println(testObj.getAuthor());
    }
}

class PersonLastNameComparator implements Comparator<Person>
{
    public int compare(Person a, Person b)
    {
        return a.getLastName().compareTo(b.getLastName());
    }
}

import java.util.*；
公共类组织实现了WhoDoneIt
{
/** 
向组织者添加一个人
@param p个人对象
*/
公共无效添加（人员p）
{   
staff.put（p.getEmail（），p）；
//系统输出打印项次（“人员”+p+“添加”）；
}
/**
*从组织者中删除一个人。
*
*@param email要删除的人的电子邮件。
*/
公共作废删除（字符串电子邮件）
{
删除（电子邮件）；
}
/**
*从组织者中删除所有联系人。
*
*/
public void empty（）
{
staff.clear（）；
}
/**
*使用电子邮件地址查找存储在组织者中的人员。
*注意，每个人都有一个唯一的电子邮件地址。
* 
*@param email您要查找的个人电子邮件地址。
*
*/
公众人士findByEmail（字符串电子邮件）
{
Person aPerson=staff.get（电子邮件）；
回程票；
}
/**
*查找存储在组织者中具有相同姓氏的所有人员。
*注意，可以有多个姓氏相同的人。
* 
*@param lastName您要查找的人员的姓氏。
*
*/
公共人物[]查找（字符串lastName）
{
ArrayList name=新的ArrayList（）；
对于（人员：staff.values（））
{
如果（s.getLastName（）==lastName）{
名称。添加（s）；
}
}
//将ArrayList转换回Array
Person nameArray[]=新的Person[names.size（）]；
names.toArray（nameArray）；
返回名称数组；
}
/**
*返回组织中的所有联系人
*按姓氏排序的数组。
* 
*@返回人物对象数组。
*
*/
公众人物[]getSortedListByLastName（）
{
PersonLastNameComparator comp=新的PersonLastNameComparator（）；
已排序的映射=新树映射（comp）；
ArrayList sortedArrayList=新建ArrayList（）；
对于（人员s:sorted.values（））{
分类列表。添加（s）；
}
Person-SorterDarray[]=新的Person[SorterDarrayList.size（）]；
SorterDarrayList.toArray（SorterDarray）；
返回至Darray；
}
私有映射staff=newhashmap（）；
公共静态void main（字符串[]args）
{
OrganizeThis testObj=新的OrganizeThis（）；
Person person1=新人（“J”、“W”、“111-222-3333”）JW@ucsd.edu");
Person person2=新的Person（“K”、“W”、“345-678-9999”），“KW@ucsd.edu");
Person person3=新人（“菲比”、“王”、“322-111-3333”）phoebe@ucsd.edu");
Person person4=新人（“Nermal”、“Johnson”、“322-342-5555”、”nermal@ucsd.edu");
Person person5=新人（“苹果”、“香蕉”、“123-456-1111”、”apple@ucsd.edu");
testObj.add（person1）；
testObj.add（person2）；
testObj.add（person3）；
testObj.add（person4）；
testObj.add（person5）；
System.out.println（testObj.findByEmail（“JW@ucsd.edu"));
System.out.println（“--------------”+“\n”）；
人员a[]=testObj.find（“W”）；
个人（p:a）
系统输出println（p）；
System.out.println（“--------------”+“\n”）；
a=测试对象查找（“W”）；
个人（p:a）
系统输出println（p）；
System.out.println（“排序的”+'\n'）；
a=testObj.getSortedListByLastName（）；
（b:a人）{
系统输出打印ln（b）；
}
System.out.println（testObj.getAuthor（））；
}
}
类PersonLastNameComparator实现Comparator
{
公共整数比较（人员a、人员b）
{
返回a.getLastName（）.compareTo（b.getLastName（））；
}
}

然后，当我试图通过创建一个匿名内部类来实现它时，我还得到了一个构造函数TreeMap not find symbol错误。有什么想法吗

内部类方法：

public Person[] getSortedListByLastName()
    {
        //PersonLastNameComparator comp = new PersonLastNameComparator();
        Map<String, Person> sorted = new TreeMap<String, Person>(new Comparator<Person>()
        {
                public int compare(Person a, Person b)
    {
        return a.getLastName().compareTo(b.getLastName());
    }
    });


        ArrayList<Person> sortedArrayList = new ArrayList<Person>();
        for (Person s: sorted.values()) {
            sortedArrayList.add(s);
        }
        Person sortedArray[] = new Person[sortedArrayList.size()];
        sortedArrayList.toArray(sortedArray);
        return sortedArray;
    }

公众人物[]getSortedListByLastName（）
{
//PersonLastNameComparator comp=新的PersonLastNameComparator（）；
映射排序=新树映射（新比较器（）
{
公共整数比较（人员a、人员b）
{
返回a.getLastName（）.compareTo（b.getLastName（））；
}
});
ArrayList sortedArrayList=新建ArrayList（）；
对于（人员s:sorted.values（））{
分类列表。添加（s）；
}
Person-SorterDarray[]=新的Person[SorterDarrayList.size（）]；
SorterDarrayList.toArray（SorterDarray）；
返回至Darray；
}

比较器应该比较键，而不是映射的值

---

也就是说，您的

Map

包含从

String

到

Person

的映射，因此构造函数将期望一个类型为

Comparator的参数。Comparator应该比较键，而不是映射的值

也就是说，您的
映射
包含从
字符串
到
个人
的映射，因此构造函数将期望得到@aioobe所说的
Comparator类型的参数

解释（例如）中的编译错误

Map排序=
新树映射（新比较器（）{
公共整数比较（人员a、人员b）{
返回a.getLastName（）.compareTo（b.getLastName（））；
}
});

编译错误（实际上）抱怨它找不到类型为
TreeMap（Comparator）
的构造函数。您打算使用的构造函数的真正类型签名是：

    TreeMap<K, V>(Comparator<K>)

TreeMap（比较器）

但您所编写的内容需要一个不存在的带签名的构造函数：

    TreeMap<K, V>(Comparator<V>)

TreeMap（比较器）
正如@aioobe所说

解释（例如）中的编译错误

Map排序=
    TreeMap<K, V>(Comparator<V>)