Что определяет восходящий или нисходящий порядок в классе сбора данных Comparator/Comparable?

Я понимаю, что мы можем сортировать или заказывать объекты, хранящиеся в коллекции, в соответствии с нашими требованиями.

В то время как я получаю глубокое понимание, меня не убеждает тот факт, что восходящий и нисходящий порядок расположения достигается путем (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;
    }
}

Пожалуйста, поделитесь, большое спасибо!

Edit:

Я получаю документы 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

"Как это происходит?" был мой первоначальный вопрос. Я читал документы, все еще не мог понять.

ОТВЕТЫ

Ответ 1

Что такое логика для упорядочения элементов объекта? как "(this.grade - s.grade)", если положительный 1 перемещает "this.grade" вперед и ставит "s.grade" следующим образом, почему бы и другим способом?

Используя отрицательные числа, чтобы сказать "это меньше этого", положительные числа, чтобы сказать "это больше, чем это", и 0, чтобы сказать, что "эти 2 вещи равны", было во многих компьютерных языках более 30 лет.

Кто проверяет результат сравнения (+1, -1, 0), а затем помещает в порядке возрастания/убывания соответственно, есть ли какая-либо документация, описывающая внутреннюю работу этой части?

Существует несколько внутренних классов, которые используют возвращаемое значение для переупорядочения элементов в массивах или коллекциях, включая

Collections.sort()  Arrays.sort()  TreeSet

ИЗМЕНИТЬ

Чтобы ответить, как это работает, вам придется посмотреть исходный код для каждого из перечисленных выше классов. Некоторые из них довольно сложны, чтобы попытаться сделать сортировку максимально эффективной. Но в целом все сводится к следующему коду:

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

Ответ 2

@DavidPrun Хороший вопрос. Я попытался объяснить это на примере.

(х, у) → (2, 5)

По возрастанию (x.compareTo(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.

По убыванию (y.compareTo(x)):

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.

По сути, мы всегда будем перемещать y перед x, если результат метода compareTo равен 1.

Ответ 3

Используются методы Collections.sort().

теперь idk, какой именно алгоритм sort() в java есть, я верю его модифицированный двойной объединенный вид... но где-то в этом кодере compareTo (Comparable c) вызывается для определения того, что больше/меньше, чем попробуйте объяснить в более простом алгоритме:

скажет, что у меня есть Circle, обычно u будет сравнивать круги по их диаметру, поэтому...

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

теперь позволяет создать массив кругов:

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

теперь допустим, что это алгоритм сортировки, определенный в Collection.sort():

  Comparable tmp;
  for(int i=0;i<collection.size();i++){
   for(int j=i;j<collection.size();j++){
    if(collection.get(j).compareTo(collection.get(i)>0){
      //swap
      tmp=collection.get(i);
      collection.set(i,collection.get(j));
      collection.set(j,tmp);
     }
    }
   }

Теперь я не уверен, что написал алгоритм сортировки write (asceding/descending), я просто сделал это быстро, но я думаю, что смысл в том, как sort() решает, что происходит там... вы можете спросить в комментарии для дальнейшего объяснения