Java Academy · 강의

Comparator와 람다 정렬

람다 표현식과 Comparator.comparing 팩터리 메서드로 Comparator 인스턴스를 만듭니다.

Comparator와 람다 정렬은(는) CoddyKit의 무료 Java Academy 강의입니다. 이것은 4개 중 2번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 Java Academy 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. Java Academy 강의에는 총 4개의 강의가 포함되어 있습니다.

Comparator와 람다 정렬

Comparator<T>는 객체의 외부 정렬 순서를 정의합니다. 비교 가능 인터페이스와 달리 클래스를 수정하지 않고도 필요한 만큼 Comparator를 만들 수 있습니다.

Comparator 만들기

람다 또는 메서드 참조로 Comparator를 만든 다음 정렬 메서드에 전달하십시오.

import java.util.*;

record Product(String name, double price, int stock) {}

List<Product> products = new ArrayList<>(List.of(
    new Product("Mouse",    29.99, 50),
    new Product("Laptop",  999.00, 5),
    new Product("USB Hub",  24.99, 100)
));

// Lambda comparator
products.sort((a, b) -> Double.compare(a.price(), b.price()));
System.out.println(products);
// [USB Hub, Mouse, Laptop] (by price ascending)

Comparator.comparing 팩토리

Comparator.comparing(keyExtractor)는 키 추출 함수에서 Comparator를 만듭니다. 직접 작성한 람다보다 더 깔끔합니다.

import java.util.Comparator;

Comparator<Product> byPrice = Comparator.comparingDouble(Product::price);
Comparator<Product> byName  = Comparator.comparing(Product::name);
Comparator<Product> byStock = Comparator.comparingInt(Product::stock);

products.sort(byPrice);
System.out.println(products); // sorted by price ascending

products.sort(byName);
System.out.println(products); // sorted alphabetically

reversed()

reversed()는 모든 Comparator의 순서를 반대로 바꿉니다.

import java.util.Comparator;

Comparator<Product> mostExpensiveFirst =
    Comparator.comparingDouble(Product::price).reversed();

products.sort(mostExpensiveFirst);
System.out.println(products);
// [Laptop($999.0), Mouse($29.99), USB Hub($24.99)]

naturalOrder와 reverseOrder

Comparator.naturalOrder()는 클래스의 비교 가능 인터페이스를 사용합니다. reverseOrder()는 그 순서를 반대로 바꿉니다.

List<String> names = new ArrayList<>(List.of("Charlie", "Alice", "Bob"));

names.sort(Comparator.naturalOrder());
System.out.println(names); // [Alice, Bob, Charlie]

names.sort(Comparator.reverseOrder());
System.out.println(names); // [Charlie, Bob, Alice]

// Sort integers descending
List<Integer> nums = new ArrayList<>(List.of(5, 2, 8, 1, 9));
nums.sort(Comparator.reverseOrder());
System.out.println(nums); // [9, 8, 5, 2, 1]

null을 안전하게 처리하는 Comparator

Comparator.nullsFirst()와 nullsLast()는 NPE 없이 null 요소를 처리합니다.

import java.util.*;

List<String> withNulls = new ArrayList<>(Arrays.asList("Charlie", null, "Alice", null, "Bob"));

withNulls.sort(Comparator.nullsLast(Comparator.naturalOrder()));
System.out.println(withNulls); // [Alice, Bob, Charlie, null, null]

withNulls.sort(Comparator.nullsFirst(Comparator.naturalOrder()));
System.out.println(withNulls); // [null, null, Alice, Bob, Charlie]

Comparator를 사용한 Stream sorted()

함수형 방식으로 정렬하려면 Comparator와 함께 sorted() 중간 Stream 연산을 사용하십시오.

import java.util.stream.*;

record Employee(String name, String dept, double salary) {}

List<Employee> employees = List.of(
    new Employee("Alice",   "Engineering", 95000),
    new Employee("Bob",     "Marketing",   72000),
    new Employee("Charlie", "Engineering", 105000)
);

// Sort by salary descending in a stream pipeline
employees.stream()
    .sorted(Comparator.comparingDouble(Employee::salary).reversed())
    .forEach(e -> System.out.println(e.name() + ": $" + e.salary()));
// Charlie: $105000.0 / Alice: $95000.0 / Bob: $72000.0

람다와 메서드 참조로 Comparator 만들기

키 추출기가 단순한 getter일 때 메서드 참조를 사용하면 Comparator를 더욱 간결하게 만들 수 있습니다.

// Lambda
Comparator<String> c1 = (a, b) -> a.length() - b.length();

// Comparator.comparing with lambda
Comparator<String> c2 = Comparator.comparing(s -> s.length());

// Comparator.comparingInt with method reference (cleanest)
Comparator<String> c3 = Comparator.comparingInt(String::length);

List<String> words = new ArrayList<>(List.of("banana", "fig", "apple", "kiwi"));
words.sort(c3);
System.out.println(words); // [fig, kiwi, apple, banana]

상태를 가진 Comparator

Comparator는 일반적으로 상태가 없어야 하지만, 생성자 매개변수를 통해 구성을 주입할 수 있습니다.

class DistanceComparator implements Comparator<String> {
    private final String target;
    DistanceComparator(String target) { this.target = target; }

    @Override
    public int compare(String a, String b) {
        return Integer.compare(distance(a), distance(b));
    }

    private int distance(String s) { return Math.abs(s.length() - target.length()); }
}

List<String> words = new ArrayList<>(List.of("Java", "Go", "Python", "C", "Kotlin"));
words.sort(new DistanceComparator("Java"));
System.out.println(words); // closest length to "Java" first

Product catalog 사용자 지정 정렬

Product catalog를 먼저 재고 여부로, 다음으로 가격으로, 마지막으로 이름으로 정렬합니다.

import java.util.*;

record Item(String name, double price, boolean inStock) {}

List<Item> catalog = List.of(
    new Item("Laptop",  999.0,  true),
    new Item("Case",     19.99, false),
    new Item("Mouse",    29.99, true),
    new Item("Monitor", 349.0,  true)
);

Comparator<Item> catalogSort =
    Comparator.comparing(Item::inStock).reversed()     // in-stock first
    .thenComparingDouble(Item::price)                  // then cheapest
    .thenComparing(Item::name);                        // then alphabetical

catalog.stream().sorted(catalogSort)
    .forEach(i -> System.out.printf("%s %-15s $%.2f%n",
        i.inStock() ? "[Y]" : "[N]", i.name(), i.price()));

Comparator를 사용한 Arrays.sort

Arrays.sort(array, comparator)는 사용자 지정 Comparator를 사용해 객체 배열을 정렬합니다.

String[] words = {"banana", "fig", "apple", "kiwi", "cherry"};

// Sort by length, then alphabetically for same length
Arrays.sort(words,
    Comparator.comparingInt(String::length)
              .thenComparing(Comparator.naturalOrder()));

System.out.println(Arrays.toString(words));
// [fig, kiwi, apple, banana, cherry]

빠른 확인

Comparator.comparingDouble(Product::price).reversed()는 무엇을 생성합니까?

복습: Comparator와 람다 정렬

핵심 내용:

Comparator<T>는 외부 정렬 순서를 정의하므로 필요한 만큼 사용할 수 있습니다.
Comparator.comparing(keyExtractor)는 getter에서 Comparator를 만듭니다.
reversed()는 모든 Comparator의 순서를 반대로 바꾸며, naturalOrder()/reverseOrder()는 비교 가능 타입에 사용합니다.
nullsFirst()와 nullsLast()는 null 요소를 안전하게 처리합니다.
함수형 방식의 정렬을 위해 Stream 파이프라인에서 sorted(comparator)를 사용하십시오.
Comparator는 sort(), Arrays.sort(), TreeSet, TreeMap에 전달할 수 있습니다.

자주 묻는 질문

“Comparator와 람다 정렬” 강의는 무료인가요?

네 — “Comparator와 람다 정렬” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 Java Academy 강의 전체를 잠금 해제할 수 있습니다. Java Academy 강의에는 총 4개의 강의가 포함되어 있습니다.

“Comparator와 람다 정렬”에서 뭘 배우나요?

람다 표현식과 Comparator.comparing 팩터리 메서드로 Comparator 인스턴스를 만듭니다. 브라우저에서 직접 실행하는 실습 코드로 Java Academy을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

Java Academy을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 Java Academy은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 2번째 강의입니다.

“Comparator와 람다 정렬” 강의는 얼마나 걸리나요?

대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.

이 Java Academy 강의에서 코드를 작성하고 실행할 수 있나요?

네. 모든 Java Academy 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.

이 강의의 모든 강의

← Java Academy(으)로 돌아가기