Comparator와 Comparable

Comparator와 Comparable

객체를 비교 해주는 인터페이스이다

 

 

Comparator란?

 

같은 타입의 객체를 서로 비교 해주는 인터페이스 이다.

 

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

Comparator는 위와같이 정의 되어 있으며, compare를 반드시 구현해야한다.

 

매개변수가 o1, o2가 들어오며 o1을 기준으로 정렬을 하게 된다.

 

기본적으로

o1의 데이터가 o2보다 크다면 1을 반환

o1의 데이터와 o2의 데이터가 같다면 0을 반환

o1의 데이터가 o2보다 작다면 -1을 반환한다.

 

public class ComparatorFruit {

    @Override
    public String toString() {
        return "Fruit{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }

    public Integer getPrice() {
        return price;
    }

    public ComparatorFruit(String name, Integer price) {
        this.name = name;
        this.price = price;
    }

    private final String name;

    private final Integer price;
}

 

오름 차순으로 정렬할 Comparator

public class FruitComparator implements Comparator<ComparatorFruit> {

    // 오름차순 정렬
    @Override
    public int compare(ComparatorFruit o1, ComparatorFruit o2) {
        // o1이 기준이 된다.

        // o.1 이 o.2 가격보다 크다면 1
        if (o1.getPrice() > o2.getPrice()) {
            return 1;

        // o.1 과 o.2 가격이 같다면 0
        } else if (o1.getPrice().equals(o2.getPrice())) {
            return 0;

        // o.1 이 o.2 가격보다 작다면 -1
        } else {
            return -1;
        }
    }
}

 

 

내림 차순으로 정렬할 Comparator

public class FruitDescendingComparator implements Comparator<ComparatorFruit> {

	// 내림차순 정렬
    @Override
    public int compare(ComparatorFruit o1, ComparatorFruit o2) {

        // o.2 이 o.1 가격보다 크다면 1
        if (o1.getPrice() < o2.getPrice()) {
            return 1;

            // o.1 과 o.2 가격이 같다면 0
        } else if (o1.getPrice().equals(o2.getPrice())) {
            return 0;

            // o.2 이 o.1 가격보다 작다면 -1
        } else {
            return -1;
        }
    }
}

 

메인 메소드

public class Comparator {

    public static void main(String[] args) {

        List<ComparatorFruit> comparatorFruits = new ArrayList<>();

        comparatorFruits.add(new ComparatorFruit("A", 3000));
        comparatorFruits.add(new ComparatorFruit("B", 10000));
        comparatorFruits.add(new ComparatorFruit("C", 25000));
        comparatorFruits.add(new ComparatorFruit("D", 15000));
        System.out.println("before = " + comparatorFruits);

        comparatorFruits.sort(new FruitComparator());
        System.out.println("Ascending after = " + comparatorFruits);

        comparatorFruits.sort(new FruitDescendingComparator());
        System.out.println("Descending after = " + comparatorFruits);
    }
}

 

 

위 코드를 실행하면

before = [Fruit{name='A', price=3000}, Fruit{name='B', price=10000}, Fruit{name='C', price=25000}, Fruit{name='D', price=15000}]
Ascending after = [Fruit{name='A', price=3000}, Fruit{name='B', price=10000}, Fruit{name='D', price=15000}, Fruit{name='C', price=25000}]
Descending after = [Fruit{name='C', price=25000}, Fruit{name='D', price=15000}, Fruit{name='B', price=10000}, Fruit{name='A', price=3000}]

위와같은 실행 결과를 얻을 수 있다.

 

 

 

 

Comparable 이란?

자기 자신과 매개변수로 받은 객체를 비교해주는 인터페이스 이다.

 

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

Comparable은 위와같이 정의되어 있으며 compareTo를 반드시 구현해야한다.

클래스에서 implements하여 사용하는것이 일반적이다.

 

public class ComparableFruit implements java.lang.Comparable<ComparableFruit> {

    @Override
    public String toString() {
        return "Fruit{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }

    public ComparableFruit(String name, Integer price) {
        this.name = name;
        this.price = price;
    }

    public Integer getPrice() {
        return price;
    }

    private final String name;

    private final Integer price;

    @Override
    public int compareTo(ComparableFruit o) {
        // CompareTo는 자기 자신이 기준이 된다.
        // 오름차순 정렬

        // 자기자신의 price가 o.price보다 크다면 1
        if (this.price > o.price) {
            return 1;

        // 자기자신의 price가 o.price와 같다면 0
        } else if (this.price.equals(o.price)) {
            return 0;
        } else {

        // 자기자신의 price가 o.price보다 작다면 -1
            return -1;
        }
    }
}

 

오름 차순으로 정렬할 Comparator (compare 구현부가 위에 Comparator 코드와 다르다)

public class FruitComparableComparator implements Comparator<ComparableFruit> {

    // 오름차순 정렬
    @Override
    public int compare(ComparableFruit o1, ComparableFruit o2) {
        // o1이 기준이 된다.

        // o.1 이 o.2 가격보다 크다면 1
        // o.1 과 o.2 가격이 같다면 0
        // o.1 이 o.2 가격보다 작다면 -1
        return o1.compareTo(o2);
    }
}

 

내림 차순으로 정렬할 Comparator

public class FruitComparableDescendingComparator implements Comparator<ComparableFruit> {

	// 내림차순 정렬
    @Override
    public int compare(ComparableFruit o1, ComparableFruit o2) {
        // o1이 기준이 된다.

        // o.1 이 o.2 가격보다 크다면 1
        // o.1 과 o.2 가격이 같다면 0
        // o.1 이 o.2 가격보다 작다면 -1
        return o1.compareTo(o2) * -1;
//        return o2.compareTo(o1);
    }
}

 

메인 메서드

public class Comparable {

    public static void main(String[] args) {

        List<ComparableFruit> comparatorFruits = new ArrayList<>();

        comparatorFruits.add(new ComparableFruit("A", 3000));
        comparatorFruits.add(new ComparableFruit("B", 10000));
        comparatorFruits.add(new ComparableFruit("C", 25000));
        comparatorFruits.add(new ComparableFruit("D", 15000));
        System.out.println("before = " + comparatorFruits);

        comparatorFruits.sort(new FruitComparableComparator());
        System.out.println("Ascending after = " + comparatorFruits);

        comparatorFruits.sort(new FruitComparableDescendingComparator());
        System.out.println("Descending after = " + comparatorFruits);
    }
}

 

위 코드를 실행하면

before = [Fruit{name='A', price=3000}, Fruit{name='B', price=10000}, Fruit{name='C', price=25000}, Fruit{name='D', price=15000}]
Ascending after = [Fruit{name='A', price=3000}, Fruit{name='B', price=10000}, Fruit{name='D', price=15000}, Fruit{name='C', price=25000}]
Descending after = [Fruit{name='C', price=25000}, Fruit{name='D', price=15000}, Fruit{name='B', price=10000}, Fruit{name='A', price=3000}]

위와같은 실행 결과를 얻을 수 있다.