Java TreeSet：删除并包含（）不起作用

collections java set

2022-09-04 06:06:59

我已经向 TreeSet 添加了一些简单的对象，但是当我调用 TreeSet 的 remove（）和 contains（）方法时，它们不起作用。但是，当我循环访问集合时，将打印对象。员工对象应添加到集合中，而对象唯一性基于对象 name 属性。Id 属性是应排序的值，但不是唯一的。

public class Employee {
    private String name;
    private int id;

    public int getId() {
        return id;
    }

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

    public String getName() {
    return name;
    }

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

 // Two objects are considered equal if their names are equal
    @Override
    public boolean equals(Object o) {
    if (o == null)
        return false;
    if (this == o)
        return true; 
    if (o.getClass() == this.getClass()) {
        Employee p = ( Employee) o;
        if (p.getName() != null && this.getName() != null)
        return this.getName().equals(p.getName());
        else
        return false;
    } else {
        return false;
    }
    }
} 

//*******************************************************

public class EmployeeComp implements Comparator<Employee> {

    // Sort Ids, but allow duplicates, hence this function is never returning 0
    @Override
    public int compare(Employee p1, Employee p2) {
    int re = 0;

    boolean scoreLt = (p1.getId() > p2.getId());
    boolean scoreGt = (p1.getId() < p2.getId());

    if(scoreLt)
        re = -1;
    if(scoreGt)
        re = 1;
    else 
        re = -1;                       
         return re;                 
    }    
}
//*******************************************************
// Collection shall store unique names with ordered values like:
// Alex, 923
// Toni, 728
// Eddi, 232
// Peter, 232
// Eddi, 156  *** not allowed
import java.util.TreeSet;


public class Main {
    private static EmployeeComp comp = new EmployeeComp(); 
    private static TreeSet<Employee> employees = new TreeSet<Employee>(comp); 

    public static void main(String[] args) {

    Employee p1 = new Employee();
    p1.setName("Eddi");
    p1.setId(232);

    Employee p2 = new Employee();
    p2.setName("Toni");
    p2.setId(728);

    Employee p3 = new Employee();
    p3.setName("Peter");
    p3.setId(232);

    Employee p4 = new Employee();
    p4.setName("Alex");
    p4.setId(923);

    employees.add(p1);
    employees.add(p2);
    employees.add(p3);
    employees.add(p4);

    // Here, contains() and remove() should check the object address
    // and not perform their actions based on compareTo

       } 
}

答案 1

根据可比较的结果插入/删除，而不是.equals（）/.hashCode（）！TreeSet

这意味着，顺便说一句，您的do对象实现了（如果他们没有实现，每次您尝试并插入成员时，您都会受到一个）的问候。SetComparableClassCastException

更准确地说，是 SortedSet 的实现。TreeSet

如果需要与 /-兼容的集合，请使用，例如，使用 ..equals().hashCode()HashSet

对于插图，以下是发生的事情（几个小时前在这里发布）：BigDecimal

final BigDecimal one = new BigDecimal("1");
final BigDecimal oneDotZero = new BigDecimal("1.0");

final Set<BigDecimal> hashSet = new HashSet<>();
// BigDecimal implements Comparable of itself, so we can use that
final Set<BigDecimal> treeSet = new TreeSet<>();

hashSet.add(one);
hashSet.add(oneDotZero);
// hashSet's size is 2: one.equals(oneDotZero) == false

treeSet.add(one);
treeSet.add(oneDotZero);
// treeSet's size is... 1! one.compareTo(oneDotZero) == 0

引用 javadoc 的话，这意味着 's 是 “不一致”。ComparableBigDecimal.compareTo().equals()

** 编辑 ** 至于OP想要什么：

a 不接受重复名称;Collection
将根据用户 ID 进行排序的排序视图。Collection

如上所述，您不能有一个同时执行这两项操作的集合。解决方案：

对于第一个，HashSet;
对于第二个，将该集合的副本转换为，然后使用。ArrayListCollections.sort()

这意味着并且必须仅对名称执行操作，而自定义将作用于 ID。别无选择，只能定制，因为它是一个比较器，在任何情况下都不一致。.equals().hashCode()ComparatorComparator.equals()

至于建议的代码，存在问题。

首先：覆盖但不覆盖。因此，破坏契约（其中一部分是，如果两个对象相等，它们必须具有相同的哈希码）。更重要的是，对于工作至关重要。修复：Employee.equals().hashCode()Employee.equals().hashCode()HashSet

@Override
public int hashCode()
{
    return name == null ? 0 : name.hashCode();
}

@Override
public boolean equals(final Object obj)
{
    if (obj == null)
        return false;
    if (this == obj)
        return false;
    if (!(obj instanceof Employee))
        return false;
    final Employee other = (Employee) obj;
    return name == null ? other.name == null
        : name.equals(other.name);
}

第二：比较器与它破坏合约一样破碎（对于任何和，）。修复：EmployeeComparatoro1o2o1.compareTo(o2) == - o2.compareTo(o1)

public final class EmployeeComp
    implements Comparator<Employee>
{
    @Override
    public int compare(final Employee o1, final Employee o2)
    {
        final int id1 = o1.getId(), id2 = o2.getId();
        if (id1 == id2)
            return 0;
        return id1 > id2 ? 1 : -1;
    }
}

然后，如何获取该集的排序副本：

// "set" contains the unique employees
final List<Employee> sorted = new ArrayList<Employee>(set);
Collections.sort(list, new EmployeeComp());

做。

答案 2

你的问题是概念性的。

如果需要对唯一对象进行排序的集合：TreeSet
如果您希望排序的集合是不同的对象，则可以具有相同的比较值以进行排序：优先级队列

顺便说一句，优先级列表中的方法比 TreeSet 上的方法更适合第二种情况的通常需求。我曾经认为这是TreeSet的缺点。例如，从集合中删除第一项。

希望有所帮助：-）