java. sort()

sort()를 사용하기 위해 필요한 것들은:

-->git; java.util.Comparator,  java.util.Collections
알고리즘 공부하면서.. 배열만 보면 '닥치고 소팅!' 하고싶은 순간이 여러번 오게 된다.
그 때마다 검색해서 Compare 어쩌구.. Descending / ascending 등 매 번 잘 몰라 고민할 때가 많아 정리해 보려고 한다.

한 줄 요약하자면, Comparable을 implements 한 객체를 compare()해서 sort() 하는 것이다.

세부 내용은 다음과 같다.

sort()를 쓰기 위해서는 다음이 필요하다.

•  Arrays, Collections의 object들을 sort() 하여 정렬하려면 자연정렬 하거나.. Comparator를 인자로 주어야 한다.

• 자연정렬은 Arrays.sort(int[] array)로간단하게되지만, (물론 2차 배열은 Comparator 필요)
• List를 정렬하는 Collections.sort()와 같은 것은 Comparator를 인자로 주어야 한다. 어떻게 주느냐..
• Comparator instance를 생성해보면 알겠지만 public int compare()를 override 하게 된다. 여기에 Compare 방법을 구현하면 됨. 음수는 작다 0이면 같다 양수면 크다이다. 쉽지?
• Comparable를 상속한 Object는 compareTo()를 override하면 된다. 아래 예시에 잘 나와 있음. javadoc에는 다음과 같이 되어 있다.

     * Sorts the specified list into ascending order, according to the
     * {@linkplain Comparable natural ordering} of its elements.
     * All elements in the list must implement the {@link Comparable}
     * interface.  Furthermore, all elements in the list must be
     * mutually comparable (that is, {@code e1.compareTo(e2)}
     * must not throw a {@code ClassCastException} for any elements
     * {@code e1} and {@code e2} in the list).

• 즉, Comparable을 implement 한 객체만 비교 가능하고 compare()를 override 하여야 한다는 말. 이게 핵심이다. 쉽지? ㅋㅋ

인터넷에서 검색한 예제를 하나 살펴보자.
(출처:http://java67.blogspot.kr/2012/10/how-to-sort-object-in-java-comparator-comparable-example.html)

package test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 *
 * Java program to test Object sorting in Java. This Java program
 * test Comparable and Comparator implementation provided by Order
 * class by sorting list of Order object in ascending and descending order.
 * Both in natural order using Comparable and custom Order using Comparator in Java
 *
 * @author http://java67.blogspot.com
 */
public class ObjectSortingExample {

    public static void main(String args[]) {
     
        //Creating Order object to demonstrate Sorting of Object in Java
        Order ord1 = new Order(101,2000, "Sony");
        Order ord2 = new Order(102,4000, "Hitachi");
        Order ord3 = new Order(103,6000, "Philips");
     
        //putting Objects into Collection to sort
        List orders = new ArrayList();
        orders.add(ord3);
        orders.add(ord1);
        orders.add(ord2);
     
        //printing unsorted collection
        System.out.println("Unsorted Collection : " + orders);
     
        //Sorting Order Object on natural order - ascending
        Collections.sort(orders); //sorting here.
     
        //printing sorted collection
        System.out.println("List of Order object sorted in natural order : " + orders);
     
        // Sorting object in descending order in Java
        Collections.sort(orders, Collections.reverseOrder());
        System.out.println("List of object sorted in descending order : " + orders);
             
        //Sorting object using Comparator in Java
        Collections.sort(orders, new Order.OrderByAmount());
        System.out.println("List of Order object sorted using Comparator - amount : " + orders);
     
        // Comparator sorting Example - Sorting based on customer
        Collections.sort(orders, new Order.OrderByCustomer());
        System.out.println("Collection of Orders sorted using Comparator - by customer : " + orders);
    }
}

/*
 * Order class is a domain object which implements
 * Comparable interface to provide sorting on natural order.
 * Order also provides copule of custom Comparators to
 * sort object based uopn amount and customer
 */
class Order implements Comparable {

    private int orderId;
    private int amount;
    private String customer;

    /*
     * Comparator implementation to Sort Order object based on Amount
     */
    public static class OrderByAmount implements Comparator {

        @Override
        public int compare(Order o1, Order o2) {
            return o1.amount > o2.amount ? 1 : (o1.amount < o2.amount ? -1 : 0);
        }
    }

    /*
     * Anohter implementation or Comparator interface to sort list of Order object
     * based upon customer name.
     */
    public static class OrderByCustomer implements Comparator {

        @Override
        public int compare(Order o1, Order o2) {
            return o1.customer.compareTo(o2.customer);
        }
    }

    public Order(int orderId, int amount, String customer) {
        this.orderId = orderId;
        this.amount = amount;
        this.customer = customer;
    }

 
    public int getAmount() {return amount; }
    public void setAmount(int amount) {this.amount = amount;}

    public String getCustomer() {return customer;}
    public void setCustomer(String customer) {this.customer = customer;}

    public int getOrderId() {return orderId;}
    public void setOrderId(int orderId) {this.orderId = orderId;}

    /*
     * Sorting on orderId is natural sorting for Order.
     */
    @Override
    public int compareTo(Order o) {
        return this.orderId > o.orderId ? 1 : (this.orderId < o.orderId ? -1 : 0);
    }
 
    /*
     * implementing toString method to print orderId of Order
     */
    @Override
    public String toString(){
        return String.valueOf(orderId);
    }
}

Output
Unsorted Collection : [103, 101, 102]
List of Order object sorted in natural order : [101, 102, 103]
List of object sorted in descending order : [103, 102, 101]
List of Order object sorted using Comparator - amount : [101, 102, 103]
Collection of Orders sorted using Comparator - by customer : [102, 103, 101]

위에서 Order를 sorting 하는방법을 보면

• Order가 Comparable을 implements 하여 compareTo()를 override 했기 때문에 Collections.sort()로 sorting 하는 방법
• Order의 내부에 Comparator를 상속받은 class(OrderByAmount와 OrderByCustomer)를 구현해서 sorting 하는 방법을 구현하고 있다. 잘 안보이나? 코드를 잘 뜯어보면 보인다.

사용하는 관점에서 한번 더 정리를 하자면,

• List를 sorting 하려면 Collections의 sort()를 쓰고 Comparator를 넘겨줘야 하고
• 배열을 sorting 하려면 Arrays의 sort()를 쓰면 된다. 2차 배열은 마찬가지로 Comparator를 넘겨줘야 한다.
• 비교를 하려면 비교 대상(Object)이 Comparable이어야 한다.