[Java] 객체 배열/리스트 오름차순,내림차순 정렬과 다중 조건 정렬

Comparable 인터페이스 - compareTo

comparable 인터페이스의 compareTo 메서드를 오버라이드해서 사용합니다.

1) 오름차순 정렬 기준

정렬 기준을 나이 오름차순으로 정의

• Arrays.sort(객체명), Collections.sort(객체명) 통해 사용
• 내림차순: Collections.sort(객체명, Collections.reverseOrder()) 
• 리스트인 경우 내림차순: 객체명.sort(Collections.reverseOrder())으로 사용 가능

import java.util.*;

public class classSort{

    static class Person implements Comparable<Person> {
        private String name;
        private int age;

        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        @Override
        public int compareTo(Person other) {
            /* 동일한 코드
            if (this.age < other.age) return -1;
            else if (this.age == other.age) return 0;
            else return 1;
             */
            return this.age - other.age;
        }

        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("kim", 35));
        people.add(new Person("Jen", 20));
        people.add(new Person("max", 67));
        people.add(new Person("tom", 18));

        //나이 오름차순 정렬
        Collections.sort(people);
        for (Person person : people) {
            System.out.println(person);
        }

        System.out.println();

        //나이 내림차순 정렬
        Collections.sort(people, Collections.reverseOrder());
        // people.sort(Collections.reverseOrder()); // 사용 가능
        for (Person person : people) {
            System.out.println(person);
        }
    }
}

2) 내림차순 정렬 기준

정렬 기준을 나이 내림차순으로 정의

• Arrays.sort(객체명), Collections.sort(객체명) 통해 사용
• 오름차순: Collections.sort(객체명, Collections.reverseOrder()) 
• 리스트인 경우 오름차순: 객체명.sort(Collections.reverseOrder())으로 사용 가능

@Override
public int compareTo(Person other) {
    /* 동일한 코드
    if (this.age > other.age) return -1;
    else if (this.age == other.age) return 0;
    else return 1;
     */
    return other.age - this.age;
}

 

Comparator 인터페이스

기본 정렬기준 외에 다른 기준으로 정렬하고자 할 때 또는 기본 정렬기준은 클래스에 정의할 수 없을 때 Comparator를 사용할 수 있습니다.

1) 오름차순 정렬 기준

나이를 오름차순으로 정렬하는 Comparator 객체를 생성해서 comparator 인자에 넘겨서 정렬할 수 있습니다.

• Arrays.sort(객체명, comparator) 또는 Collection.sort(객체명, comparator)의 comparator 인자에 넘겨주기
• 내림차순: comparator 인자에 comaparator.reversed() 넘겨주기

    public static void main(String[] args) {
        /* 내용 생략 */
        Comparator<Person> comparator = new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o2.age - o1.age;
            }
        };

        // 오름차순 정렬
        Collections.sort(people, comparator);
        for (Person person : people) {
            System.out.println(person);
        }

        System.out.println();

        // 내림차순 정렬
        Collections.sort(people, comparator.reversed());
        // people.sort(comparator.reversed()); // 사용 가능
        for (Person person : people) {
            System.out.println(person);
        }
    }

 

2) 내림차순 정렬 기준

위 의 compare 메서드에서 return o2.age - o1.age 를 사용하면 내림차순 정렬 기준으로 바꿀 수 있습니다. 

Comparator<Person> comparator = new Comparator<Person>() {
    @Override
    public int compare(Person o1, Person o2) {
        return o2.age - o1.age;
    }
};

 

Stream 사용

stream을 사용해서 나이 오름차순과 내림차순으로 간단하게 정렬이 가능합니다.

public static void main(String[] args) {
    /* 내용 생략 */

        List<Person> sortedPeople = new ArrayList<>();

        //오름차순 정렬
        sortedPeople = people.stream()
                .sorted((p1, p2) -> p1.age - p2.age)
                .collect(Collectors.toList());
        for (Person person : sortedPeople) {
            System.out.println(person);
        }

        //내림차순 정렬
        sortedPeople = people.stream()
                .sorted((p1, p2) -> p2.age - p1.age)
                .collect(Collectors.toList());
        for (Person person : sortedPeople) {
            System.out.println(person);
        }
}

 

Comparator → 람다 함수 대체

public static void main(String[] args) {
    /* 내용 생략 */

    // 오름차순 정렬
    Collections.sort(people, (p1, p2) -> p1.age - p2.age);
    for (Person person : people) {
        System.out.println(person);
    }

    // 내림차순 정렬
    Collections.sort(people, (p1, p2) -> p2.age - p1.age);
    for (Person person : people) {
        System.out.println(person);
    }
}

 

다중 정렬

Comparator - comparing, thenComparing

점수를 비교해서 내림차순으로 정렬하고, 이후에 나이를 오름차순 비교하도록 했습니다.

점수가 높은 사람이 가장 앞에 나오고, 점수가 같으면 더 어린 사람이 앞에 나오는 것을 확인할 수 있습니다.

import java.util.*;

public class multipleSort {
    static class Student {
        private String name;
        private int age;
        private int score;

        /* 생성자, Getter, toString 생략 */
    }

    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("kim", 15, 70));
        students.add(new Student("tom", 19, 40));
        students.add(new Student("alice", 17, 70));
        students.add(new Student("jen", 17, 90));

        //점수 내림차순 정렬 > 나이 오름차순 정렬
        students.sort(Comparator.comparing(Student::getScore, Comparator.reverseOrder())
                .thenComparing(Student::getAge));
        /*students.sort(Comparator.comparing(Student::getScore, Collections.reverseOrder())
                .thenComparing(Student::getAge)); // 사용 가능 */
        for (Student student : students) {
            System.out.println(student);
        }
    }
}