Блог

Программа сортирует массив в порядке возрастания, но при замене id и compareid в инструкции return массив сортируется в порядке убывания, но это никак не влияет на результат, который System.out.println(e[1].compareTo(e[0])); он возвращает 1 в обоих случаях. Почему это так?

 package example;

import java.util.Arrays;

class Example implements Comparable<Example> {
    int id;

    public int compareTo(Example ob) {
        int compareid = ob.id;
        return Integer.compare(id, compareid); // problem
    }
}

class comparableinterface {
    public static void main(String args[]) {
        Example e[] = new Example[3];
        e[0] = new Example();
        e[0].id = 2;
        e[1] = new Example();
        e[1].id = 3;
        e[2] = new Example();
        e[2].id = 0;
        Arrays.sort(e);
        for (Example temp : e) {
            System.out.println(temp.id);
        }
        System.out.println(e[1].compareTo(e[0]));
    }
}
  

Потому что ваше сравнение выполняется после того, как вы отсортировали массив, а Arrays.sort(e) изменяет содержимое массива e.

Переместить

 System.out.println(e[1].compareTo(e[0]));
  

перед сортировкой, и она будет вести себя так, как вы ожидали.

Результат compareTo отражает определенный порядок между объектом и аргументом. Это всегда будет 1 между первым и вторым в отсортированном массиве, отсортированном в соответствии с тем, что выражается compareTo.

Это не указывает на числовое отношение!

Вы используете Integer.compare(id,compareid) в своем переопределенном compareTo(Example ob) методе, и для вашей информации,

Integer.compare(id,compareid) возвращает значение 0, если id == compareid; значение меньше 0, если id < compareid; и значение больше 0, если id > compareid.

И вы вызываете compareTo(Example ob) после сортировки массива, вот почему метод всегда возвращает 1 .

Попробуйте вызвать compareTo(Example ob) перед сортировкой массива.

Метод compareTo упоминается как его естественный метод сравнения.

Считается, что естественный порядок для класса C согласуется с equals тогда и только тогда, когда e1.compareTo(e2) == 0 имеет то же логическое значение, что и e1.equals (e2) для каждого e1 и e2 класса C.

Ссылка

Смотрите также java.utils.Исходный код Arrays.mergeSort(), позволяющий увидеть, как compareTo используется для сортировки массива:

 for (int j=i; j>low amp;amp;
             ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
                    swap(dest, j, j-1);
  

Потому что для сортировки вашего массива по возрастанию / убыванию вы также меняете свой compareTo метод в example на compare для < соответственно> (т. Е. вы меняете логику в методе compareTo). Вот почему он дает вам тот же результат из System.out.println(e[1].compareTo(e[0])); . По сути, после изменения ваш compareTo больше не проверяет «меньше», а проверяет «больше». Таким образом, даже несмотря на то, что System.out.println(e[1].compareTo(e[0])); возвращает 1 в обоих случаях, в первом случае он сообщает вам «e [1] больше, чем e[0]», а во втором случае он сообщает вам «e[1] меньше, чем e [0]». Это довольно сложно, подумайте об этом.

Вы должны вызвать метод compareTo() для экземпляра целого числа, а не статический compare()

Попробуйте это:

 int id;
public int compareTo(Example ob) {

        Integer compareid = ob.id;
        return compareid.compareTo(id);
    }