Comparible 및 Comparator를 사용하는 경우
필드에서 정렬해야 하는 개체 목록이 있습니다(예: Score).별 생각 없이 Comparator를 구현하는 새로운 클래스를 작성했습니다.이 클래스는 작업을 수행하고 동작합니다.
지금 다시 생각해 보면, 비교기를 실장하는 새로운 클래스를 만드는 것이 아니라, 학급에 Comparatible을 실장하는 것이 좋을까 하는 생각이 듭니다.점수는 개체의 순서를 지정하는 유일한 필드입니다.
내가 한 일이 관행으로 받아들여질 만 한 건가?
올바른 접근법 "우선 클래스에게 비교 가능 (자연적 주문에 대해)을 구현하도록 하고 대체 필드 비교가 필요한 경우 비교기를 구현하는 새로운 클래스를 만듭니다."
위의 (2)가 참일 경우 클래스에서 Comparatible을 구현한 후에 Comparator를 구현해야 합니까?(원래 클래스는 내가 소유하고 있다고 가정합니다.
해당 객체의 기본(자연) 순서 동작을 정의하려면 일반적으로 이 작업에 객체의 기술적 식별자 또는 자연스러운(데이터베이스?) 식별자를 사용합니다.
외부 제어 가능한 주문 동작을 정의하려는 경우 사용합니다. 기본 주문 동작을 재정의할 수 있습니다.
다음 항목도 참조하십시오.
클래스의 정렬이 명확하고 자연스러운 방법이라면 오브젝트는 Comparible을 구현해야 하며, 클래스 정렬이 필요한 사람은 일반적으로 이 방법을 사용합니다.
그러나 정렬이 클래스를 비정상적으로 사용한 경우 또는 정렬이 특정 사용 사례에만 적합한 경우 Comparator(비교기)를 사용하는 것이 좋습니다.
다른 말로 하자면, 클래스명을 지정하면, 동등한 클래스명이 어떻게 정렬되는지 명확합니까, 아니면 javadoc을 읽어야 합니까?후자의 경우, 향후의 모든 정렬 사용 사례에 비교자가 필요할 가능성이 높으며, 이 시점에서 비교 대상 사용자 구현으로 인해 사용자 속도가 느려지는 대신 속도가 느려질 수 있습니다.
Comparable:
- 오브젝트가 관리 하에 있는지 확인합니다.
- 비교 행동이 주요 비교 행동인 경우.
Comparator:
- , 그 「실행할 수 」
Comparable. - (「Default」(에서는 「Default」로 되어 있습니다)
Comparable의 동작
동등 -java.lang.Comparable: int compareTo(Object o1)
동등한 오브젝트는 자신을 다른 오브젝트와 비교할 수 있습니다.클래스 자체는 java.lang을 구현해야 합니다.인스턴스를 비교할 수 있는 동등한 인터페이스.
- 현재 개체를 제공된 개체와 비교할 수 있습니다.
- 이를 통해 인스턴스 속성을 기반으로 구현할 수 있습니다.예:
Person.id - String, Wrapper class, Date, Calendar와 같은 미리 정의된 클래스에는 Comparable 인터페이스가 구현되어 있습니다.
비교기 -java.util.Comparator: int compare(Object o1, Object o2)
비교기 개체는 서로 다른 두 개체를 비교할 수 있습니다.클래스는 해당 인스턴스가 아니라 다른 클래스의 인스턴스를 비교하고 있습니다.이 비교기 클래스는 java.util을 구현해야 합니다.컴퍼레이터 인터페이스
- 같은 타입의 임의의 2개의 오브젝트를 비교할 수 있습니다.
- 이를 통해 인스턴스 속성에 따라 구현하고 이름을 지정할 수 있습니다.예:
Person.id, Person.name, Person.age - 커스터마이즈된 정렬을 위해 사전 정의된 클래스에 Comparator 인터페이스를 구현할 수 있습니다.
예:
public class Employee implements Comparable<Employee> {
private int id;
private String name;
private int age;
private long salary;
// Many sort sequences can be created with different names.
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> idComparator = new Comparator<Employee>() {
@Override
public int compare(Employee e1, Employee e2) {
return Integer.valueOf(e1.getId()).compareTo(Integer.valueOf(e2.getId()));
}
};
public Employee() { }
public Employee(int id, String name, int age, long salary){
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
}
// setters and getters.
// Only one sort sequence can be created with in the class.
@Override
public int compareTo(Employee e) {
//return Integer.valueOf(this.id).compareTo(Integer.valueOf(e.id));
//return Character.toString(this.name.charAt(0)).compareToIgnoreCase(Character.toString(e.name.charAt(0)));
if (this.id > e.id) {
return 1;
}else if(this.id < e.id){
return -1;
}else {
return Character.toString(this.name.charAt(0)).compareToIgnoreCase(Character.toString(e.name.charAt(0)));
}
}
public static void main(String[] args) {
Employee e1 = new Employee(5, "Yash", 22, 1000);
Employee e2 = new Employee(8, "Tharun", 24, 25000);
List<Employee> list = new ArrayList<Employee>();
list.add(e1);
list.add(e2);
Collections.sort(list); // call @compareTo(o1)
Collections.sort(list, Employee.nameComparator); // call @compare (o1,o2)
Collections.sort(list, Employee.idComparator); // call @compare (o1,o2)
}
}
- 맞춤 정렬의 경우 다른 시나리오에서는 비교기 @compare(o1, o2)를 선택하고 여러 필드를 정렬하려면 코드를 변경하지 않고 비교기를 사용합니다.
Java 8 Lambda의 경우 : 비교는 제 게시물을 참조하십시오.
같은 클래스의 인스턴스를 비교할 때는 Comparible을 사용해야 합니다.
비교기를 사용하여 다른 클래스의 인스턴스를 비교할 수 있습니다.
비교 가능한 클래스는 객체의 자연스러운 순서를 정의해야 하는 클래스에 의해 구현됩니다.예를 들어 String은 Comparable을 구현합니다.
다른 정렬 순서가 필요한 경우 비교기를 구현하고 두 인스턴스를 비교하는 고유한 방법을 정의합니다.
오브젝트의 정렬이 자연순서에 따라 이루어져야 하는 경우 Comparable을 사용하고, 다른 오브젝트의 속성으로 정렬해야 하는 경우 Comparator를 Java에서 사용합니다.
Comparatible과 Comparator의 주요 차이점:
+------------------------------------------------------------------------------------+
¦ Comparable ¦ Comparator ¦
¦-----------------------------------------+------------------------------------------¦
¦ java.lang.Comparable ¦ java.util.Comparator ¦
¦-----------------------------------------+------------------------------------------¦
¦ int objOne.compareTo(objTwo) ¦ int compare(objOne, objTwo) ¦
¦-----------------------------------------+------------------------------------------¦
¦ Negative, if objOne < objTwo ¦ Same as Comparable ¦
¦ Zero, if objOne == objTwo ¦ ¦
¦ Positive, if objOne > objTwo ¦ ¦
¦-----------------------------------------+------------------------------------------¦
¦ You must modify the class whose ¦ You build a class separate from to sort. ¦
¦ instances you want to sort. ¦ the class whose instances you want ¦
¦-----------------------------------------+------------------------------------------¦
¦ Only one sort sequence can be created ¦ Many sort sequences can be created ¦
¦-----------------------------------------+------------------------------------------¦
¦ Implemented frequently in the API by: ¦ Meant to be implemented to sort ¦
¦ String, Wrapper classes, Date, Calendar ¦ instances of third-party classes. ¦
+------------------------------------------------------------------------------------+
Comparator는 동등한 기능을 모두 갖추고 있습니다.
| | Comparable | Comparator ._______________________________________________________________________________ Is used to allow Collections.sort to work | yes | yes Can compare multiple fields | yes | yes Lives inside the class you’re comparing and serves | | as a “default” way to compare | yes | yes Can live outside the class you’re comparing | no | yes Can have multiple instances with different method names | no | yes Input arguments can be a list of | just Object| Any type Can use enums | no | yes
다음과 같이 대조군을 익명의 클래스로 사용할 수 있는 최선의 방법을 찾았습니다.
private static void sortAccountsByPriority(List<AccountRecord> accounts) {
Collections.sort(accounts, new Comparator<AccountRecord>() {
@Override
public int compare(AccountRecord a1, AccountRecord a2) {
return a1.getRank().compareTo(a2.getRank());
}
});
}
정렬하려는 클래스 내에서 이러한 메서드의 여러 버전을 직접 만들 수 있습니다.다음과 같은 이점이 있습니다.
- Sort Accounts By Priority
- 계정 정렬 기준유형
sort AccountsByPriorityAndType
기타...
이제 어디서든 이러한 정렬 방법을 사용하여 코드를 재사용할 수 있습니다.이것이라면 비교 가능한 모든 것을 얻을 수 있을 뿐만 아니라 더 많은 것을 얻을 수 있기 때문에 비교 가능한 것을 사용할 이유가 전혀 없습니다.
저는 이렇게 말하고 싶어요.
- 비교가 직관적인 경우에는 반드시 Comparatible을 구현한다.
- 비교가 직관적일수록 불분명한 경우 비교기를 사용하십시오.비교기는 더 명확하고 코드를 유지해야 하는 불쌍한 영혼에게 더 명확합니다.
- 직감적으로 비교할 수 있는 것이 여러 개 있다면 비교기를 선호합니다.아마도 비교 대상이 되는 클래스의 공장 방식으로 제작할 수 있습니다.
- 특수 목적의 비교인 경우 Comparator를 사용합니다.
다음 사항은 Comparible을 사용해야 하는 상황과 Comparator를 결정하는 데 도움이 됩니다.
1) 코드 가용성
2) 단일 분류 기준과 다중 분류 기준
3) Arays.sort() 및 Collection.sort()
4) SortedMap 및 SortedSet의 키로서
5) 유연성 대비 클래스 수 증가
6) 클래스 간 비교
7) 자연질서
자세한 내용은 비교 가능한 제품을 사용하는 시기와 비교기 사용 시기를 참조하십시오.
자연스러운 순서 정렬이 필요한 경우 - 사용자 정의 순서 정렬이 필요한 경우 사용자 비교 가능 - 비교기 사용
예:
Class Employee{
private int id;
private String name;
private String department;
}
Natural Order Sorting은 고유하고 커스텀 Order Sorting은 name과 department가 되기 때문에 id를 기반으로 합니다.
★★★★★★★★★★★★★★★★★★:
Comparatible Comparator (비교기)http://javarevisited.blogspot.com/2011/06/comparator-and-comparable-in-java.htmlhttpjavarevisited.blogspot.com/2011/06/.html
- 클래스를 작성할 때 정렬의 사용 사례가 하나뿐이라면 Comparable을 사용하십시오.
- 둘 이상의 정렬 전략이 있는 경우에만 비교기를 구현합니다.
여기에도 비슷한 질문이 있었습니다.클래스가 Comparable 및/또는 Comparator여야 하는 경우
나는 다음과 같이 말할 것이다.내부 ID를 기반으로 한 자연스러운 주문과 유사한 구현
여러 필드 등 보다 복잡한 비교 알고리즘이 있는 경우 Comparator를 구현합니다.
동등:
동종 요소와 기본 자연 정렬 순서만 저장하고 싶을 때는 언제든지 클래스 구현을 진행할 수 있습니다.comparable인터페이스입니다.
비교기:
동종 및 이종 요소를 저장하고 기본 맞춤 정렬 순서로 정렬하려면 언제든지 다음을 수행할 수 있습니다.comparator인터페이스입니다.
내 욕구는 날짜를 기준으로 분류되었다.
그래서 Comparible을 사용했는데 저는 쉽게 작동했어요.
public int compareTo(GoogleCalendarBean o) {
// TODO Auto-generated method stub
return eventdate.compareTo(o.getEventdate());
}
Comparible의 한 가지 제약사항은 목록 이외의 컬렉션에 사용할 수 없다는 것입니다.
만약 당신이 그 클래스를 소유하고 있다면 Comparatible을 선택하는 것이 좋습니다.일반적으로 Comparator는 클래스를 소유하고 있지 않지만 TreeSet 또는 TreeMap의 컨스트럭터로 Comparator가 전달될 수 있기 때문에 TreeSet 또는 TreeMap을 사용해야 하는 경우에 사용됩니다.Comparator 와 Comparible 의 사용 방법에 대해서는, http://preciselyconcise.com/java/collections/g_comparator.php 를 참조해 주세요.
인터뷰 중 한 곳에서 일정 범위의 숫자를 nogn 시간보다 더 잘 분류해 달라는 요청을 받았습니다.(계수 정렬 사용 안 함)
오브젝트에 Comparable 인터페이스를 구현하면 암묵적 정렬 Algo에서 재정의된 compareTo 메서드를 사용하여 정렬 요소를 정렬할 수 있으며, 이는 선형 시간이 됩니다.
숫자 값이 오름차순이고 문자열이 알파벳 순서인 경우 제공되는 기본 자연 정렬 순서입니다.예:
Treeset t=new Treeset();
t.add(2);
t.add(1);
System.out.println(t);//[1,2]
Comparator는 커스텀 myComparator 클래스에서 구현되는 커스텀 정렬 순서입니다.다음과 같은 비교 방법을 덮어씁니다.
Treeset t=new Treeset(new myComparator());
t.add(55);
t.add(56);
class myComparator implements Comparator{
public int compare(Object o1,Object o2){
//Descending Logic
}
}
System.out.println(t);//[56,55]
매우 간단한 접근방식은 문제의 엔티티 클래스가 데이터베이스에 표현되어 데이터베이스 테이블에 엔티티 클래스의 필드로 구성된 인덱스가 필요하다고 가정하는 것입니다.대답이 예인 경우 비교 가능한 항목을 구현하고 인덱스 필드를 사용하여 자연스러운 정렬 순서를 지정합니다.다른 모든 경우에는 비교기를 사용합니다.
구현을 위한 주석 libComparable그리고.Comparator:
public class Person implements Comparable<Person> {
private String firstName;
private String lastName;
private int age;
private char gentle;
@Override
@CompaProperties({ @CompaProperty(property = "lastName"),
@CompaProperty(property = "age", order = Order.DSC) })
public int compareTo(Person person) {
return Compamatic.doComparasion(this, person);
}
}
다른 예를 보려면 링크를 클릭하십시오.http://code.google.com/p/compamatic/wiki/CompamaticByExamples
언급URL : https://stackoverflow.com/questions/2266827/when-to-use-comparable-and-comparator
'source' 카테고리의 다른 글
| 코드 저장소를 사용할 때 리소스의 상대 경로를 참조하는 방법 (0) | 2022.12.25 |
|---|---|
| JQuery .each()의 역방향 (0) | 2022.12.25 |
| unix socket을 통해 java와 mariaDB localhost를 연결하는 방법은 무엇입니까? (0) | 2022.12.25 |
| MySQL 특정 달의 이전 날짜 이후의 모든 행을 선택합니다. (0) | 2022.12.25 |
| AngularJS : 컨트롤러 기능에서 뷰를 전환하려면 어떻게 해야 합니까? (0) | 2022.12.25 |