В чем разница между compare() и compareTo()?

В чем разница между методами Java compare() и compareTo()? Получают ли эти методы одинаковый ответ?

Ответ 1

a.compareTo(b):
Сопоставимый интерфейс: сравнивает значения и возвращает int, который сообщает, сравниваются ли значения меньше, равно или больше чем.
Если ваши объекты класса имеют естественный порядок, реализуйте интерфейс Comparable<T> и определите этот метод. Все классы Java, которые имеют естественное упорядочение, реализуют Comparable<T> - Пример: String, классы-обертки, BigInteger
compare(a, b):
Интерфейс компаратора: сравнивает значения двух объектов. Это реализовано как часть интерфейса Comparator<T>, и типичным использованием является определение одного или нескольких небольших служебных классов, которые реализуют это, для передачи в методы, такие как sort() или для использования путем сортировки структур данных, таких как TreeMap и TreeSet. Возможно, вы захотите создать объект Comparator для следующего:
- Многократные сравнения. Предоставить несколько разных способов что-то отсортировать. Например, вы можете отсортировать класс Person по имени, идентификатору, возрасту, росту и т.д. Для каждого из них вы должны определить компаратор для передачи в метод sort().
- Системный класс Для предоставления методов сравнения для классов, которые вы не можете контролировать. Например, вы можете определить компаратор для строк, которые сравнивают их по длине.
- Шаблон стратегии Для реализации шаблона стратегии, в котором вы хотите представить алгоритм в виде объекта, который можно передать в качестве параметра, сохранить в структуре данных и т.д.

Если у ваших объектов класса есть один естественный порядок сортировки, вам может не понадобиться сравнение().

Резюме от http://www.digizol.com/2008/07/java-sorting-comparator-vs-comparable.html

сравнимый
Сопоставимый объект способен сравнивать себя с другим объектом.

компаратор
Объект сравнения способен сравнивать два разных объекта. Класс сравнивает не свои экземпляры, а некоторые другие классы экземпляров.

Контексты использования:

Сопоставимый интерфейс

Метод equals и операторы == и != Проверяют равенство/неравенство, но не обеспечивают способ проверки на относительные значения.
Некоторые классы (например, String и другие классы с естественным упорядочением) реализуют интерфейс Comparable<T>, который определяет метод compareTo().
Вы захотите реализовать Comparable<T> в своем классе, если хотите использовать его с методами Collections.sort() или Arrays.sort().

Определение объекта Comparator

Вы можете создавать компараторы для сортировки любым произвольным способом для любого класса.
Например, класс String определяет компаратор CASE_INSENSITIVE_ORDER.

Разница между этими двумя подходами может быть связана с понятием:
Заказанная коллекция:

Когда коллекция упорядочена, это означает, что вы можете выполнять итерации в коллекции в определенном (не случайном) порядке (Hashtable не упорядочен).

Коллекция с естественным порядком не просто заказывается, а сортируется. Определить естественный порядок может быть сложно! (как в натуральном порядке строк).

Еще одно отличие, указанное HaveAGuess в комментариях:

Comparable находится в реализации и не виден из интерфейса, поэтому, когда вы сортируете, вы действительно не знаете, что произойдет.
Comparator дает вам уверенность в том, что порядок будет четко определен.

Ответ 2

compareTo() - это интерфейс Comparable.

compare() - это интерфейс Comparator.

Оба метода выполняют одно и то же, но каждый интерфейс используется в несколько другом контексте.

Интерфейс Comparable используется для наложения естественного упорядочения на объекты реализующего класса. Метод compareTo() называется естественным методом сравнения. Интерфейс Comparator используется для наложения полного порядка на объекты реализующего класса. Для получения дополнительной информации см. Ссылки для того, чтобы использовать каждый интерфейс.

Ответ 3

Сходства:
Оба являются обычными способами сравнения двух объектов.
Оба возвращают int, описывающие взаимосвязь между двумя объектами.

Отличия: Метод compare() - это метод, который вы обязаны реализовать, если вы реализуете интерфейс Comparator. Он позволяет передавать два объекта в метод и возвращает int описание их отношения.

Comparator comp = new MyComparator();
int result = comp.compare(object1, object2);

Метод compareTo() - это метод, который вы обязаны реализовать, если вы реализуете интерфейс Comparable. Это позволяет сравнивать объект с объектами подобного типа.

String s = "hi";
int result = s.compareTo("bye");

Резюме:
В принципе, это два разных способа сравнить вещи.

Ответ 4

Методы не должны давать одинаковые ответы. Это зависит от того, какие объекты/классы вы им называете.

Если вы реализуете свои собственные классы, которые, как вы знаете, хотите сравнить на определенном этапе, вы можете реализовать их интерфейс Comparable и реализовать метод compareTo() соответственно.

Если вы используете некоторые классы из API, которые не реализуют интерфейс Comparable, но вы все же хотите их сравнить. То есть для сортировки. Вы можете создать свой собственный класс, который реализует интерфейс Comparator и метод compare(), реализующий логику.

Ответ 5

Сопоставимый интерфейс содержит метод под названием compareTo(obj), который принимает только один аргумент и сравнивает себя с другим экземпляром или объектами того же класса.

Интерфейс Comparator содержит метод под названием compare(obj1,obj2), который принимает два аргумента и сравнивает значение двух объектов из одного и того же или разных классов.

Ответ 6

compareTo(T object)

поступает из интерфейса java.lang.Comparable, реализованного для сравнения этого объекта с другим, чтобы дать отрицательное значение int для этого объекта меньше, чем 0, для равно или положительное значение для большего, чем другое. Это более удобный метод сравнения, но он должен быть реализован в каждом классе, который вы хотите сравнить.

compare(T obj1, T obj2)

происходит из интерфейса java.util.Comparator, реализованного в отдельном классе, который сравнивает другие объекты класса, чтобы дать отрицательное значение int для первого объекта, меньшего, чем 0, для равных или положительное значение для большего, чем второй объект, Это необходимо, если вы не можете реализовать класс compareTo(), потому что он не модифицируется. Он также используется, когда вам нужны разные способы сравнения объектов, а не только один (например, по имени или возрасту).

Ответ 7

Используя Comparator, мы можем иметь n число логики сравнения, написанное для класса.

например.

Для класса автомобилей

Мы можем сравнить класс Comparator на основе номера модели автомобиля. У нас также может быть класс Comparator для сравнения на основе модельного года автомобиля.

Автомобильный класс

public class Car  {

    int modelNo;

    int modelYear;

    public int getModelNo() {
        return modelNo;
    }

    public void setModelNo(int modelNo) {
        this.modelNo = modelNo;
    }

    public int getModelYear() {
        return modelYear;
    }

    public void setModelYear(int modelYear) {
        this.modelYear = modelYear;
    }

}

Компаратор № 1 на основе модели №

public class CarModelNoCompartor implements Comparator<Car>{

    public int compare(Car o1, Car o2) {

        return o1.getModelNo() - o2.getModelNo();
    }

}

Компаратор №2 на основе модельного года

public class CarModelYearComparator implements Comparator<Car> {

    public int compare(Car o1, Car o2) {

        return o1.getModelYear() - o2.getModelYear();
    }

}

Но это невозможно в случае интерфейса Сопоставимый.

В случае интерфейса Comparable мы можем иметь только одну логику в методе compareTo().

Ответ 8

compareTo() вызывается на один объект, чтобы сравнить его с другим объектом. compare() вызывается для некоторого объекта для сравнения двух других объектов.

Разница заключается в том, где определена логика фактического сравнения.

Ответ 9

Отношение объекта, имеющего этот метод, и его соавторов отличается.

compareTo() - это метод интерфейса Comparable, поэтому он используется для сравнения этого экземпляра с другим.

compare() - это метод интерфейса Comparator, поэтому он используется для сравнения двух разных экземпляров другого класса с каждым другие.

Если вы это сделаете, реализация Comparable означает, что экземпляры класса можно легко сравнить.
Реализация Comparator означает, что экземпляры подходят для сравнения разных объектов (других классов).

Ответ 10

Основное отличие заключается в использовании интерфейсов:

Сопоставимый (который имеет compareTo()) требует сравнения объектов (для использования TreeMap или сортировки списка) для реализации этого интерфейса. Но что, если класс не реализует Comparable, и вы не можете его изменить, потому что он является частью сторонней библиотеки? Затем вам нужно реализовать Компаратор, который немного менее удобен в использовании.

Ответ 11

Если вы хотите отсортировать список, который включает Object Foo, класс Foo должен реализовать интерфейс Comparable, потому что метод сортировки List использует этот метод.

Если вы хотите написать класс Util, который сравнивает два других класса, вы можете реализовать класс Comparator.

Ответ 12

Таблица сотрудников
Имя, DoB, Зарплата
Томас, 2/10/1982, 300
Даниэль, 3/11/1990, 400
Kwame, 2/10/1998, 520

Интерфейс Сопоставимый позволяет вам сортировать список объектов, например, служащих со ссылкой на одно основное поле - для экземпляр, вы можете сортировать по имени или по зарплате с помощью метода CompareTo()

emp1.getName().compareTo(emp2.getName())

Более гибкий интерфейс для таких требований обеспечивается интерфейс Компаратор, единственным методом которого является compare()

public interface Comparator<Employee> {
 int compare(Employee obj1, Employee obj2);
}

Пример кода

public class NameComparator implements Comparator<Employee> {

public int compare(Employee e1, Employee e2) {
     // some conditions here
        return e1.getName().compareTo(e2.getName()); // returns 1 since (T)omas > (D)an 
    return e1.getSalary().compareTo(e2.getSalary()); // returns -1 since 400 > 300
}

}

Ответ 13

Еще один момент:

compareTo() из интерфейса Comparable а compare() из интерфейса Comparator.
Comparable используется для определения порядка по умолчанию для объектов в классе, в то время как Comparator используется для определения пользовательского порядка, передаваемого методу.

Ответ 14

Также следует подчеркнуть технический аспект. Скажем, вам нужна параметризация поведения сравнения из клиентского класса, и вы задаетесь вопросом, использовать ли Comparable или Comparator для такого метода:

class Pokemon {
    int healthPoints;
    int attackDamage;
    public void battle (Comparable<Pokemon> comparable, Pokemon opponent) {
        if (comparable.compareTo(opponent) > 0) { //comparable needs to, but cannot, access this.healthPoints for example
            System.out.println("battle won");
        } else {
            System.out.println("battle lost");
        }
    }
}

comparable бы лямбда или объект, и нет возможности comparable доступ к полям this покемона. (В лямбда-выражениях this относится к экземпляру внешнего класса в области лямбда-выражений, как определено в тексте программы.) Так что это не сработает, и мы должны использовать Comparator с двумя аргументами.

Ответ 15

Использовать интерфейс Comparable для сортировки по нескольким значениям, таким как age, name, dept_name... Для одного значения используйте интерфейс Comparator

Ответ 16

Important Answar
String name;
int roll;

public int compare(Object obj1,Object obj2) { // For Comparator interface
    return obj1.compareTo(obj1);
}

public int compareTo(Object obj1) { // For Comparable Interface
    return obj1.compareTo(obj);
}

Здесь в выражении return obj1.compareTo(obj1) или return obj1.compareTo(obj) только взять объект; примитив не допускается. Для примера

name.compareTo(obj1.getName()) // Correct Statement.

Но

roll.compareTo(obj1.getRoll()) 
// Wrong Statement Compile Time Error Because roll 
// is not an Object Type, it is primitive type.

name - это объект String, чтобы он работал. Если вы хотите сортировать число рулонов ученика, чем использовать код ниже.

public int compareTo(Object obj1) { // For Comparable Interface
    Student s = (Student) obj1;
    return rollno - s.getRollno();
}

или

public int compare(Object obj1,Object obj2) { // For Comparator interface
    Student s1 = (Student) obj1;
    Student s2 = (Student) obj2;
    return s1.getRollno() - s2.getRollno();
}