Java 什么决定了Comparator/Comparable collection类的升序或降序？

我知道我们可以根据我们的要求对储存在集合中的物品进行分类或订购

虽然我有了深刻的理解，但我不相信这样一个事实，即升序和降序是通过（a-b）->升序或（b-a）->降序来实现的，其中“a”和“b”是我们选择比较的班级成员

例如：

public int compareTo(Student s) {
     return this.grade - s.grade; //ascending order 
    // return s.grade - this.grade; // descending order
}

排序对象元素背后的逻辑是什么？（this.grade-s.grade）“如果正1将“this.grade”移到前面，然后依次放置“s.grade”，为什么不换个方向呢？谁验证比较结果（+1，-1，0），然后分别按升序或降序排列，是否有任何文档描述该零件的内部工作

public class Student implements Comparable <Student>{
    String name;
    int grade;
    public Student(String name, int grade) {
        this.name = name;
        this.grade = grade;
    }
    public int compareTo(Student s) {
         return this.grade - s.grade; //ascending order 
        // return s.grade - this.grade; // descending order
    }
    public String toString() {
        return this.name + ", " + this.grade;
    }
}

公共班级学生实施可比{
字符串名；
国际等级；
公立学生（字符串名称，整数等级）{
this.name=名称；
这个。等级=等级；
}
公共int比较（学生s）{
返回this.grade-s.grade；//升序
//返回s.grade-this.grade；//降序
}
公共字符串toString（）{
返回this.name+“，”+this.grade；
}
}

请分享，非常感谢

---

编辑：

我得到了Java文档，我的问题是：

sort these grades (13, 2)

Case ascending -> return this.grade - s.grade;

picture in my mind: 
compare (13, 2) , (13 - 2) > 0 so move 2 to front.
result -> 2, 13
------
Case descending -> return s.grade - this.grade;

picture in my mind: 
compare (2, 13) , (2 - 13) < 0 so move 13 to front.

result -> 13, 2

对这些等级进行排序（13,2）
案例升序->返回this.grade-s.grade；
我脑海中的画面：
比较（13,2），（13-2）>0，将2移动到前面。
结果->2，13
------
案例降序->返回s.grade-本.grade；
我脑海中的画面：
比较（2,13），（2-13）<0，将13移到前面。
结果->13，2

“这是怎么发生的？”这是我最初的问题。我看了文件，还是不明白

排序对象元素背后的逻辑是什么？（this.grade-s.grade）“如果正1将“this.grade”移到前面，然后依次放置“s.grade”，为什么不换个方向呢

用负数表示“这比那小”，用正数表示“这比那大”，用0表示“这两件事是相等的”，已经在许多计算机语言中使用了30多年

谁验证比较结果（+1，-1，0），然后分别按升序/降序排列，是否有任何文档描述该零件的内部工作

public class Student implements Comparable <Student>{
    String name;
    int grade;
    public Student(String name, int grade) {
        this.name = name;
        this.grade = grade;
    }
    public int compareTo(Student s) {
         return this.grade - s.grade; //ascending order 
        // return s.grade - this.grade; // descending order
    }
    public String toString() {
        return this.name + ", " + this.grade;
    }
}

有几个内部类使用返回值对数组或集合中的元素重新排序，包括

Collections.sort（）

Arrays.sort（）

TreeSet

编辑

要回答它是如何工作的，您必须查看我上面列出的每个类的源代码。为了尽可能提高排序效率，其中一些问题相当复杂。但总的来说，这一切归结为如下代码：

if( data[i].compareTo(data[j]) > 0 ){
   // swap data[i] and  data[j]
}

Collections.sort（）方法不支持

现在idk在java中sort（）的具体算法是什么，我相信它是一个经过修改的双合并排序。。。但是在代码中的某个地方调用compareTo（Comparable c）来确定什么大于/小于，我将尝试用更简单的算法来解释：

假设我有一个圆，通常你会比较圆的直径，所以

public class Circle implements Comparable<Cricle> {
 int diameter;
 //constructor
 public int compareTo(Circle c){
  return this.diameter-c.diameter;
   }

公共类循环实现可比性{
内径；
//建造师
公共整数比较（c圈）{
返回此.diameter-c.diameter；
}

现在，让我们创建一个圆数组：

ArrayList<Circle> collection = new ArrayList;
collection.add(new Circle(10)); // and more circles

ArrayList集合=新建ArrayList；
collection.add（新圆圈（10））；//和更多圆圈

现在让我们假设这是Collection.sort（）中定义的排序算法：

可比tmp；
对于（inti=0；i@davidpun）来说，这是一个很好的问题。我试着用一个例子来解释这个问题

（x，y）->（2，5）

升序（x.与（y）相比）：

降序（y.与（x）相比）：

基本上，如果比较法的结果是1，我们总是将y移到x前面。
你的问题的答案取决于，你是如何对学生进行排序的？

（s）？@ElliottFrisch，我提到如果我需要使用升序（this.grade-s.grade），但为什么this.grade是第一名，s.grade是第二名，即为什么（s.grade）从（这个等级）中减去？为什么不换一种方式呢？这是我需要遵循的标准规则吗？如果没有调用者，将

compareTo的结果更改为
，则没有任何作用。结果由调用者解释，并记录在javadoc中。一开始不应该进行减法。当值接近Integer.MAX\u值或Integer.MIN\u值。每个实现Comparable的类都负责定义自己的自然排序顺序。如果调用方希望按相反顺序对该类的项进行排序，则他们必须做一些额外的工作。谢谢，但我在编辑的帖子中澄清了我想问的问题。@DavidRun我在回答中添加了更多内容仍然令人困惑：/…（y>x）这不是意味着你需要将x移到y的前面吗？它是如何得到降序的？
if x.compareTo(y) == 1, then x > y , since y is smaller than x, you would have to move y in front of x.

2.compareTo(5) == 1 , Then don't move 5 in front of 2.

if y.compareTo(x) == 1, then y > x , since y is greater than x, you would have to move y in front of x.

5.compareTo(2) == -1 , Move 5 in front of 2.