[JAVA] Comparable ,Comparator

JAVA

[JAVA] Comparable ,Comparator

경딩 2024. 11. 23. 14:28

Comparable 자신과 같은 객체를 받아서 비교하는 인터페이스
Comparator 객체 두 개를 받아서 그 둘을 비교한다.

정렬 1 - Comparable, Comparator (

package org.example;

import java.util.Arrays;

public class SortMain1 {
    public static void main(String[] args) {
        Integer[] array = {3, 2, 1};
        System.out.println(Arrays.toString(array));
        System.out.println("기본 정렬 후");
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
    }
}

데이터를 정렬하는 방법에 대해 알아보자.

다음과 같이 Integer 배열에 있는 값을 순서대로 정렬하고 싶다면 Array.sort()를 사용하면 된다.

3,2,1 순으로 들어있던 데이터가 정렬 후 1, 2, 3 의 순서로 데이터가 정렬된것을 확인할 수 있다.

비교자 - Comparator

만약 정렬순서를 3,2,1로 정렬하고 싶다면 비교자(Comparator)를 사용하면된다.

public interface Comparator<T> {
 int compare(T o1, T o2);
}

두 인수를 비교해서 결과 값을 반환하면 된다.

첫 번째 인수가 더 작으면 음수 -1
두 값이 같으면 0
첫 번째 인수가 더 크면 양수 1

package org.example;

import java.util.Arrays;
import java.util.Comparator;

public class SortMain2 {

    public static void main(String[] args) {
        Integer[] array = {3, 2, 1};
        System.out.println(Arrays.toString(array));
        System.out.println("Comparator 비교");
        Arrays.sort(array, new AscComparator());
        System.out.println("AscComparator:" + Arrays.toString(array));
        Arrays.sort(array, new DescComparator());
        System.out.println("DescComparator:" + Arrays.toString(array));
    }

    static class AscComparator implements Comparator<Integer>{

        @Override
        public int compare(Integer o1, Integer o2) {
            System.out.println("o1=" + o1 + " o2=" + o2);
            return (o1 < o2) ? -1 : ((o1 == o2) ? 0 : 1);
        }
    }

    static class DescComparator implements Comparator<Integer>{

        @Override
        public int compare(Integer o1, Integer o2) {
            System.out.println("o1=" + o1 + " o2=" + o2);
            return ((o1 < o2) ? -1 : ((o1 == o2) ? 0 : 1))*-1;
        }
    }
}

Arrays.sort()를 사용할 때 비교자 Comparator를 넘겨주면 알고리즘에서 어떤 값이 더 큰지 두 값을 비교할 때, 비교자를 사용한다.

AscComparator를 사용하면 숫자가 점점 올라가는 오름차순 정렬이 된다.

DescComparator를 사용하면 숫자가 점점 내려가는 내림차순 정렬이 된다.

왜냐하면 구현 마지막에 -1을 곱해주었기 때문에 이렇게 하면 양수는 음수로 , 음수는 양수로 반환된다.

계산 결과가 반대로 되면서 정렬 결과도 반대가 된다.

정렬을 반대로

new AscComparator().reversed()

정렬을 반대로 하고 싶으면 reversed() 메서드를 사용하면 된다.

비교자 (Comparator)를 사용하면 정렬의 기준을 자유롭게 변경할 수 있다.

정렬 2 - Comparable, Comparator

자바에서 기본으로 제공하는 Integer, String 같은 객체를 제외하고 MyUser와 같인 직접 만든 객체를 정렬하려면 내가 만든 두 객체 중에 어떤 객체가 더 큰지 알려줄 방법이 있어야 한다.

이때는 Comparable 인터페이스를 구현하면 된다 이 인터페이스는 이름 그대로 비교가능한 이라는 뜻으로

객체에 비교기능을 추가해 준다.

public interface Comparable<T> {
 public int compareTo(T o);
}

자기 자신과 인수로 넘어온 객체를 비교해서 반환하면 된다.

현재 객체가 인수로 주어진 객체보다 더 작으면 음수, -1
두 객체 크기가 같으면 0
현재 객체가 인수로 주어진 객체보다 더 크면 양수, 1

package org.example;

public class MyUser implements Comparable<MyUser> {
    private String id;
    private int age;

    public MyUser(String id, int age) {
        this.id = id;
        this.age = age;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "MyUser{" +
                "id='" + id + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(MyUser o) {
        return this.age > o.age ? 1 : (this.age == o.age ? 0 : -1);
    }
}

MyUser 가 Comparable 인터페이스를 구현한 것을 확인할 수 있다.
compareTo() 구현을 보면 여기서는 정렬 기준을 나이로 정했다.
MyUser 클래스의 기본 정렬방식을 나이 오름차순으로 정한 것이다.
Comparable을 통해 구현한 순서를 자연 순서(Natural Ordering)라 한다.

package org.example;

import java.util.Arrays;

public class SortMain3 {
    public static void main(String[] args) {
        MyUser myUser1 = new MyUser("a", 30);
        MyUser myUser2 = new MyUser("b", 20);
        MyUser myUser3 = new MyUser("c", 10);
        MyUser[] array = {myUser1, myUser2, myUser3};
        System.out.println("기본 데이터");
        System.out.println(Arrays.toString(array));
        System.out.println("Comparable 기본 정렬");
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
    }
}

Array.sort(array);

기본 정렬을 시도한다. 이때 객체가 스스로 가지고 있는 Comparable 인터페이스를 사용해서 비교한다.

MyUser 가 구현한 대로 나이( age ) 오름차순으로 정렬된 것을 확인할 수 있다. MyUser의 자연적인 순서를 사용했다.

다른 방식으로 정렬

만약 객체가 가지고 있는 Comparable 기본 정렬이 아니라 다른 정렬을 추가하고 싶다면 Comparator을 다음과 같이 구현하여 Arrays.sort의 인수로 비교자(Comparator)를 만들어서 넘겨주면 된다. 이렇게 비교자를 따로 전달하면 객체가 기본적으로 가지고 있는 Comparable을 무시하고, 별도로 달한 비교자를 사용해 정렬한다.

package org.example;

import java.util.Arrays;

public class SortMain3 {
    public static void main(String[] args) {
        MyUser myUser1 = new MyUser("a", 30);
        MyUser myUser2 = new MyUser("b", 20);
        MyUser myUser3 = new MyUser("c", 10);
        MyUser[] array = {myUser1, myUser2, myUser3};
        System.out.println("기본 데이터");
        System.out.println(Arrays.toString(array));
        System.out.println("Comparable 기본 정렬");
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));


        System.out.println("IdComparator 정렬");
        Arrays.sort(array, new IdComparator());
        System.out.println(Arrays.toString(array));

        System.out.println("IdComparator().reversed() 정렬");
        Arrays.sort(array, new IdComparator().reversed());
        System.out.println(Arrays.toString(array));
    }
}

package org.example;

import java.util.Comparator;

public class IdComparator implements Comparator<MyUser> {
    @Override
    public int compare(MyUser o1, MyUser o2) {
        return o1.getId().compareTo(o2.getId());
    }
}

주의! 만약 Comparable 도 구현하지 않고, Comparator 도 제공하지 않으면 다음과 같은 런타임 오류가 발생한다.

java.lang.ClassCastException: class collection.compare.MyUser cannot be cast 
to class java.lang.Comparable

Comparator 가 없으니, 객체가 가지고 있는 기본 정렬을 사용해야 한다. 이때 Comparable을 사용한다.

하지만 Comparable을 찾는데 없으니 예외가 발생한다.

Comparable, Comparator 정리

객체의 기본 정렬 방법은 객체에 Comparable를 구현해서 정의한다.

이렇게 하면 객체는 이름 그대로 비교할 수 있는 객체가 되고 기본 정렬 방법을 가진다.

그런데 기본 정렬 외에 다른 정렬 방법을 사용해야 하는 경우 비교자 ( Comparator )를 별도로 구현해서 정렬 메서드에 전달하면 된다. 이 경우 전달한 Comparator 가 항상 우선권을 가진다.

자바가 제공하는 Integer , String 같은 기본 객체들은 대부분 Comparable을 구현해 두었다.

정렬 3 - Comparable, Comparator

정렬은 배열뿐만 아니라 순서가 있는 List 같은 자료 구조에도 사용할 수 있다.

package org.example;

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

public class SortMain4 {
    public static void main(String[] args) {
        MyUser myUser1 = new MyUser("a", 30);
        MyUser myUser2 = new MyUser("b", 20);
        MyUser myUser3 = new MyUser("c", 10);

        List<MyUser> list = new LinkedList<>();
        list.add(myUser1);
        list.add(myUser2);
        list.add(myUser3);
        System.out.println("기본 데이터");
        System.out.println(list);

        System.out.println("Comparable 기본 정렬");
        list.sort(null);
        //Collections.sort(list);
        System.out.println(list);


        System.out.println("IdComparator 정렬");
        list.sort(new IdComparator());
        //Collections.sort(list, new IdComparator());
        System.out.println(list);
    }
}

Collections.sort(list)

리스트는 순서가 있는 컬렉션이므로 정렬할 수 있다.
이 메서드를 사용하면 기본 정렬이 적용된다.
하지만 이 방식보다 객체 스스로정렬 메서드를 가지고 있는 list.sort() 사용을 더 권장한다.
참고로 둘의 결과는 같다.

list.sort(null)

별도의 비교자가 없으므로 Comparable로 비교해서 정렬한다.
자연적인 순서로 비교한다.
자바 1.8부터 사용

Collections.sort(list, new IdComparator())

별도의 비교자로 비교하고 싶다면 다음 인자에 비교자를 넘기면 된다.
하지만 이 방식보다는 객체 스스로 정렬 메서드를 가지고 있는 list.sort() 사용을 더 권장한다. 참고로 둘의 결과는 같다.

list.sort(new IdComparator())

전달한 비교자로 비교한다.
자바 1.8부터 사용

Tree 구조와 정렬

TreeSet 과 같은 이진 탐색 구조는 데이터를 보관할 때 데이터를 정렬하면서 보관한다.

따라서 정렬 기준을 제공하는 것이 필수다.

이진 탐색 트리는 데이터를 저장할 때 왼쪽 노드에 저장해야할지, 오른쪽 노드에 저장해야 할지 비교가 필요하다.

따라서 TreeSet , TreeMap 은 Comparable 또는 Comparator 가 필수이다.

package org.example;

import java.util.TreeSet;

public class SortMain5 {
    public static void main(String[] args) {
        MyUser myUser1 = new MyUser("a", 30);
        MyUser myUser2 = new MyUser("b", 20);
        MyUser myUser3 = new MyUser("c", 10);

        TreeSet<MyUser> treeSet1 = new TreeSet<>();
        treeSet1.add(myUser1);
        treeSet1.add(myUser2);
        treeSet1.add(myUser3);

        System.out.println("Comparable 기본 정렬");
        System.out.println(treeSet1);

        TreeSet<MyUser> treeSet2 = new TreeSet<>(new IdComparator().reversed());
        treeSet2.add(myUser1);
        treeSet2.add(myUser2);
        treeSet2.add(myUser3);

        System.out.println("IdComparator 정렬");
        System.out.println(treeSet2);

    }
}

Comparable 기본 정렬
[MyUser{id='c', age=10}, MyUser{id='b', age=20}, MyUser{id='a', age=30}]
IdComparator 정렬
[MyUser{id='c', age=10}, MyUser{id='b', age=20}, MyUser{id='a', age=30}]

Process finished with exit code 0

new TreeSet<>()

TreeSet 을 생성할 때 별도의 비교자를 제공하지 않으면 객체가 구현한 Comparable 을 사용한다.

new TreeSet<>(new IdComparator())

TreeSet 을 생성할 때 별도의 비교자를 제공하면 Comparable 대신 비교자( Comparator )를 사용해서 정렬한다.

자바는 개발자가 복잡한 정렬 알고리즘은 신경 쓰지 않으면서 정렬의 기준만 간단히 변경할 수 있도록, 정렬의 기준을 Comparable , Comparator 인터페이스를 통해 추상화해 두었다. 객체의 정렬이 필요한 경우 Comparable 을 통해 기본 자연 순서를 제공하자. 자연 순서 외에 다른 정렬 기준이 추가 로 필요하면 Comparator 를 제공하자

참고자료 : 김영한의 자바 중급 2편

'JAVA' 카테고리의 다른 글

[JAVA] 자원 정리 (try-catch , try-with-resources) 2 (1)	2024.11.26
[JAVA] 자원 정리 (try-catch , try-with-resources) (0)	2024.11.26
[JAVA] 싱글톤 구현 방식 (0)	2024.11.21
[JAVA] iterator 순회 중 만난 ConcurrentModificationException (1)	2024.11.20
[JAVA ]Set , Map 알아보기, 로드 팩터 (Load Factor)와 HashSet의 리해싱 (0)	2024.11.19

현재글[JAVA] Comparable ,Comparator

뚝딱 뚝딱 개발일기

chain – matrix multiplication problem, Java, 다양한 의존관계 주입, 행렬곱셈순서, 김영한, 스프링컨테이너, equals ==, 스프링, 자바의신11~18, call by value 와 call by reference, 프로그래머스, 정리해봅시다, 정규식, 백준 12886, realmysql, 자바의 신2, 인프런, 자바, 람다식, 백준11049,

Today :
Yesterday :

뚝딱 뚝딱 개발일기