java：用于删除重复项的Comparator和Treeset

我有一个这样的java类

public class A {

    private String field1;
    private String field2;

    // getters, setters but no equals and hashcode
}

这个类的一个对象列表，我想从这个列表中删除所有具有相同field1或相同field2的重复元素，所以我有两个比较器

public class Comparator1 implements Comparator<A> {
    public int compare(A o1, A o2) {

        return o1.getField1().compareToIgnoreCase( o2.getField1() );
    }
}

public class Comparator2 implements Comparator<A> {
    public int compare(A o1, A o2) {

        return o1.getField2().compareToIgnoreCase(o2.getField2());
    }
}

公共类比较器1实现比较器{
公共整数比较（A o1，A o2）{
返回o1.getField1（）.compareToIgnoreCase（o2.getField1（））；
}
}
公共类Comparator2实现了Comparator{
公共整数比较（A o1，A o2）{
返回o1.getField2（）.compareToIgnoreCase（o2.getField2（））；
}
}

因此，为了完成任务，我使用树集

TreeSet<A> ts1 = new TreeSet<A>(new Comparator1())
ts1.addAll(list)

TreeSet<A> ts2 = new TreeSet<A>(new Comparator2())
ts2.addAll(ts1)

list.clear()
list.addAll(ts2)

TreeSet ts1=新树集（新比较器1（））
ts1.addAll（列表）
树集ts2=新树集（新比较器2（））
ts2.addAll（ts1）
list.clear（）
list.addAll（ts2）

但是，我如何使用一个比较器和一个树集来实现同样的功能呢

谢谢你的帮助

更新：

谢谢大家的回答，但读完后我不知道这是否是解决真正问题的正确方法

在我的真实案例中，field1就像一个电话号码，field2就像一个名字。 因此，我不想多次拨打同一电话号码（这是第一个删除重复项的树集），也不想多次拨打同一姓名（第二个删除重复项的树集）

您可以修改该类，但我想知道这种方法是否可以解决实际问题

如果这种方法是正确的，从您的问题中，我可以看出不修改类就不可能只使用一个比较器

---

谢谢你不能用一个比较器同时按两个标准排序，所以在你的例子中没有比两个树集更好的方法了。当然，您可以将它们封装在一个数据结构中

---

（或者，您可以使用两个hashmap，每个hashmap都有一个字符串作为键-这将平均更快，但编程更复杂。）

publicstatic您不能，而且我不清楚您试图做的是定义良好的

您是否意识到当前的方法既取决于添加元素的顺序，也取决于您是先检查field1还是field2以查找重复项？想象一下，您拥有这些A类对象：

A ab = new A("a", "b");
A cb = new A("c", "b");
A cd = new A("c", "d");

首先检查字段1，根据添加的顺序给出结果
[ab]
或
[ab，cd]

首先检查字段2，根据添加的顺序给出结果
[cb]
或
[ab，cd]

这是非常奇怪的行为。这是你想要的吗？我认为，在一般情况下，不可能使用单个树集和比较器来重现这种情况。
如果您打算进行两级排序（第一级：PhoneNumber和第二级：Name），那么您可以使用以下代码，其中将对两个字段（field1和field2）进行重复检查。由于我们已经对这两个字段使用了compareTo，因此不需要使用equals和hashcode。但是使用hashcode和equals始终是一种很好的做法

public class A implements Comparable<A> {

private String field1;
private String field2;

public A(String number, String name) {
    this.field1 = number;
    this.field2 = name;
}

// First level sorting will be done by field1. 
// If field1 is equal then second level sorting will be done on field2
@Override
public int compareTo(A o) {
    int compareTo = field1.compareTo(o.getNumber());
    if(compareTo==0){
        return field2.compareTo(o.getName());
    }
    return compareTo;
}

public String getNumber() {
    return field1;
}

public String getName() {
    return field2;
}

公共类A实现了可比性{
私有字符串字段1；
私有字符串字段2；
公用A（字符串编号、字符串名称）{
此字段1=编号；
this.field2=名称；
}
//一级排序将由field1完成。
//如果字段1相等，则将在字段2上进行二级排序
@凌驾
公共整数比较（AO）{
int compareTo=field1.compareTo（o.getNumber（））；
如果（比较=0）{
返回字段2.compareTo（o.getName（））；
}
返回比较；
}
公共字符串getNumber（）{
返回字段1；
}
公共字符串getName（）{
返回字段2；
}

}
移除的公共类副本{
公共静态void main（字符串[]args）{
最终ArrayList学生=新ArrayList（）；
Set=新树集（）；
学生[]斯塔尔=新学生[6]；
斯塔尔[0]=新生（“学生1”、“1005”）；
斯塔尔[1]=新生（“学生2”、“1004”）；
斯塔尔[2]=新生（“学生3”、“1003”）；
斯塔尔[3]=新生（“学生6”、“1002”）；
斯塔尔[4]=新生（“学生5”、“1001”）；
斯塔尔[5]=新生（“学生6”、“1000”）；
数组.sort（starr、Student.studentComparator）；
对于（学生s:starr）{
学生。添加（s）；
}
系统输出打印（学生）；
set.addAll（学生）；
System.out.println（“\n*******删除重复项后******\n”）；
最终ArrayList newList=新ArrayList（集合）；
/**打印原始列表**/
System.out.println（newList）；
}}
导入java.util.ArrayList；
导入java.util.array；
导入java.util.Set；
导入java.util.TreeSet；
导入java.util.Comparator；
导入java.util.List；
公共类移除副本{
公共静态void main（字符串[]args）{
Set=新树集（）；
List students=array.asList（新生（“学生1”、“1005”）、新生（“学生2”、“1004”），
新生（“学生3”、“1003”）、新生（“学生6”、“1002”）、新生（“学生5”、“1001”），
新生（“学生6”、“1000”）；
//使用Lambda进行排序
学生。排序（新比较器（）{
@凌驾
公共整数比较（学生s1、学生s2）{
返回s1.getId（）.compareTo（s2.getId（））；
}
});
系统输出打印（学生）；
set.addAll（学生）；
System.out.println（“\n*******删除重复项后******\n”）；
最终ArrayList newList=新ArrayList（集合）；
/**打印原始列表**/
System.out.println（newList）；
}
}
班级学生实行可比性{
私有字符串名称；
私有字符串id；
公立学生（字符串名称、字符串id）{
this.name=名称；
this.id=id；
}
公共字符串getName（）{
返回名称；
}
公共void集合名（字符串名）{
this.name=名称；
}
公共字符串getId（）{
返回id；
}
公共无效集合id（字符串id）{
this.id=id；
}
@凌驾
公共字符串toString（）{
返回“\
A ab = new A("a", "b");
A cb = new A("c", "b");
A cd = new A("c", "d");

public class A implements Comparable<A> {

private String field1;
private String field2;

public A(String number, String name) {
    this.field1 = number;
    this.field2 = name;
}

// First level sorting will be done by field1. 
// If field1 is equal then second level sorting will be done on field2
@Override
public int compareTo(A o) {
    int compareTo = field1.compareTo(o.getNumber());
    if(compareTo==0){
        return field2.compareTo(o.getName());
    }
    return compareTo;
}

public String getNumber() {
    return field1;
}

public String getName() {
    return field2;
}

public class RemoveDuplicate {

public static void main(String[] args) {

    final ArrayList<Student> students = new ArrayList<Student>();

    Set<Student> set = new TreeSet<Student>();
    Student[] starr = new Student[6];
    starr[0] = new Student("Student1", "1005");
    starr[1] = new Student("Student2", "1004");
    starr[2] = new Student("Student3", "1003");
    starr[3] = new Student("Student6", "1002");
    starr[4] = new Student("Student5", "1001");
    starr[5] = new Student("Student6", "1000");

    Arrays.sort(starr, Student.StudentIdComparator);
    for (Student s : starr) {
        students.add(s);
    }

    System.out.println(students);
    set.addAll(students);

    System.out.println("\n***** After removing duplicates *******\n");

    final ArrayList<Student> newList = new ArrayList<Student>(set);

    /** Printing original list **/
    System.out.println(newList);
}}

 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Set;
 import java.util.TreeSet;
 import java.util.Comparator;
 import java.util.List;

 public class RemoveDuplicate {

public static void main(String[] args) {
    Set<Student> set = new TreeSet<Student>();
    List<Student> students = Arrays.asList(new Student("Student1", "1005"), new Student("Student2", "1004"),
            new Student("Student3", "1003"), new Student("Student6", "1002"), new Student("Student5", "1001"),
            new Student("Student6", "1000"));

    // Sorting Using Lambda

    students.sort(new Comparator<Student>() {

        @Override
        public int compare(Student s1, Student s2) {

            return s1.getId().compareTo(s2.getId());
        }

    });

    System.out.println(students);
    set.addAll(students);

    System.out.println("\n***** After removing duplicates *******\n");

    final ArrayList<Student> newList = new ArrayList<Student>(set);

    /** Printing original list **/
    System.out.println(newList);
}

  }

 class Student implements Comparable<Student> {
private String name;
private String id;

public Student(String name, String id) {
    this.name = name;
    this.id = id;
}

public String getName() {
    return name;
}

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

public String getId() {
    return id;
}

public void setId(String id) {
    this.id = id;
}

@Override
public String toString() {
    return "\n" + "Name=" + name + "   Id=" + id;
}

@Override
public int compareTo(Student o1) {
    if (o1.getName().equalsIgnoreCase(this.name)) {
        return 0;
    }
    return 1;
    }

// public static Comparator<Student> StudentIdComparator = (Student
// s1,Student s2) -> s1.getId().compareTo(s2.getId());
   }