如何覆盖compareTo（Java）

我是一名编程初学者，我有两门课。头等舱是：

public class User implements Comparable<User>

二等舱是

public class SortUser

具有从列表生成集合的方法：

public Set<User> sort(List<User> list) {
        Set<User> result = new TreeSet<>();
        for (User user : list) {
            result.add(user);
        }
        return result;
    }

（现在列表的顺序是：

312

） …并从该列表中创建了一个

集

（

树集

）：

SortUser sortUser = new SortUser();
Set<User> set = sortUser.sort(list);

SortUser-SortUser=new-SortUser（）；
Set=sortUser.sort（列表）；

---

最后我有一个

集合

，其顺序为：

13

，这意味着

集合中只有两个对象

。出了什么问题？

正如我看到的，比较方法的实现是错误的。你能把它更新到吗

@Override
public int compareTo(User user) {
  return Integer.compare(age, user.age);
}

---

您对

树集所做的操作是不必要的。我不确定它们在迭代时是否保证有一定的顺序

只需将排序方法替换为

Collections.sort（list）

至于为什么要删除一个元素，我的猜测是您的
compareTo
方法在任何情况下都不会返回
1
，因此元素总是被认为小于或等于其他元素，这可能与
树集
发生了冲突
 用户类

 public class User implements Comparable<User>{
  int age;
  User(int age){age=age;}
  @Override
  public int compareTo(User user) {
    return this.age >= age ? -1 : 0;
  }
 }

公共类用户实现可比较{
智力年龄；
用户（int-age）{age=age；}
@凌驾
公共整数比较（用户）{
返回this.age>=年龄？-1:0；
}
}

编制清单

   User a = new User(1);
   User b = new User(2);
   User c = new User(3);
   List<User> list = new ArrayList<>();
  list.add(c);
  list.add(a);
  list.add(b);

User a=新用户（1）；
用户b=新用户（2）；
用户c=新用户（3）；
列表=新的ArrayList（）；
增加（c）项；
列表.添加（a）；
列表.添加（b）；

用于分类

 Set<User> list1 = new TreeSet(list);

Set list1=新树集（列表）；
请遵循以下方法

如果是字符串

    public static Comparator<Employee> NameComparator = new Comparator<Employee>() {
    @Override
    public int compare(Employee e1, Employee e2) {
        return e1.getName().compareTo(e2.getName());
    }
};

publicstaticcomparatornameparator=newcomparator（）{
@凌驾
公共int比较（员工e1、员工e2）{
返回e1.getName（）.compareTo（e2.getName（））；
}
};

如果是整数值

public static Comparator<Employee> SalaryComparator = new Comparator<Employee>() {

    @Override
    public int compare(Employee e1, Employee e2) {
        return (int) (e1.getSalary() - e2.getSalary());
    }
};

publicstaticcomparatorsalarycomarator=newcomparator（）{
@凌驾
公共整数比较（员工e1、员工e2）{
return（int）（e1.getSalary（）-e2.getSalary（））；
}
};
类刮痕{
公共静态void main（字符串[]args）{
列表=新的ArrayList（）；
列表。添加（新用户（3））；
列表。添加（新用户（1））；
列表。添加（新用户（2））；
集合。排序（列表）；
list.forEach（el->System.out.println（el.age））；
}
}
类用户实现可比较的{
智力年龄；
用户（整数年龄）{
这个。年龄=年龄；
}
@凌驾
公共整数比较（用户）{
返回this.age>=user.age？-1:0；
}
}
您可能想尝试以下方法：

@覆盖
公共整数比较（用户）{
if（this==用户）{
返回0；
}
如果（用户！=null）{
返回此.age.compareTo（user.getAge（））
}
}
我不会通过将其添加到集合中来对其进行排序。只需在列表中调用
sort
。您不能拥有已排序的集合。集合是无序集合。sort（）方法需要对列表（或其他有序集合）进行适当排序，或返回列表。@chrisdowney从技术上讲，您可以有一个有序集。您只需确保特定的实现支持它。编写有序集实现是非常可能的。compareTo必须返回-1，0+1。好的做法是重新考虑hashCode（）和equals（）@Carcigenicate是正确的。考虑标准JavaUTI.TeSeET-这是一个有序的集合实现。当有一个参数是否定的时，这不是一个好方法。但是如果是薪水的话，我想那里有一些支票，不会让薪水为负数。试着对你的答案添加一个解释
    public static Comparator<Employee> NameComparator = new Comparator<Employee>() {
    @Override
    public int compare(Employee e1, Employee e2) {
        return e1.getName().compareTo(e2.getName());
    }
};

public static Comparator<Employee> SalaryComparator = new Comparator<Employee>() {

    @Override
    public int compare(Employee e1, Employee e2) {
        return (int) (e1.getSalary() - e2.getSalary());
    }
};

class Scratch {
    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        list.add(new User(3));
        list.add(new User(1));
        list.add(new User(2));
        Collections.sort(list);
        list.forEach(el -> System.out.println(el.age));
    }
}

class User implements Comparable<User> {
    int age;

    User(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(User user) {
        return this.age >= user.age ? -1 : 0;
    }
}