컬렉션 정렬과 불변 변환

표준 컬렉션 유틸리티는 비슷한 모양의 List를 만들지만 변경 가능성, 원본 공유, null 허용이 다릅니다.

List.of, List.copyOf, Arrays.asList, new ArrayList를 구분하지 않으면 add에서 예외가 나거나 외부 배열 변경이 내부 상태에 번집니다.

정렬도 제자리 변경과 새 결과 생성을 먼저 나눠야 합니다.

Arrays.asList의 변경 범위

배열을 List 뷰로 만든 뒤 set은 가능하지만, 원소를 추가하거나 제거해 크기를 바꾸는 연산은 지원하지 않습니다.

원본 배열의 원소 변경과 List.set은 서로 반영됩니다.

import java.util.Arrays;
import java.util.List;

public final class FixedSizeListAddFailure {
    public static void main(String[] args) {
        String[] source = {"array", "list"};
        List<String> view = Arrays.asList(source);
        source[0] = "changed";
        System.out.println("view=" + view);
        view.add("failure");
    }
}

출력 뒤 UnsupportedOperationException이 발생합니다.

독립된 가변 목록이 목적이면 new ArrayList<>(Arrays.asList(source)), 불변 스냅샷이면 List.copyOf(Arrays.asList(source))를 사용합니다.

수정 불가와 null 허용은 서로 다른 조건입니다. Arrays.asList는 null 원소를 보관할 수 있지만 List.copyOf와 List.of는 null 원소를 거부합니다. Stream.toList의 수정 불가 결과와도 이 경계를 구별해야 합니다.

예시

import java.util.Arrays;
import java.util.List;

public final class ListNullBoundary {
    public static void main(String[] args) {
        List<String> view = Arrays.asList("array", null);
        List<String> streamResult = view.stream().toList();
        System.out.println("null-kept=" + (streamResult.get(1) == null));
        try { List.copyOf(view); }
        catch (NullPointerException expected) { System.out.println("copy rejects null"); }
        try { streamResult.set(0, "changed"); }
        catch (UnsupportedOperationException expected) { System.out.println("stream result rejects set"); }
    }
}

출력은 null-kept=true, copy rejects null, stream result rejects set입니다. null을 보존하는 것과 set으로 내용을 바꿀 수 있는 것은 별도 규칙입니다. 반환 전에 List.copyOf를 사용한다면 입력에 null이 없는지도 API 조건으로 알려야 합니다.

빈 컬렉션의 값 의미

null List는 호출자마다 분기를 요구하고 “결과 없음”과 “계산 안 함”을 섞습니다.

결과가 0개라면 List.of(), Set.of(), Map.of() 같은 빈 불변 컬렉션을 반환합니다.

호출자는 안전하게 size와 for-each를 사용할 수 있습니다.

Collections.emptyList()도 불변 빈 List이며 제네릭 문맥에서 타입을 추론합니다.

매번 새 가변 ArrayList를 반환하면 호출자가 수정 가능한 규칙으로 오해할 수 있으므로 API 의도를 선택합니다.

제자리 정렬과 불변 정렬 결과 구분

가변 ArrayList의 정렬은 같은 객체의 순서를 바꿉니다.

List.of()로 만든 목록에 정렬을 호출하면 UnsupportedOperationException이 발생합니다.

원본을 보존하려면 스트림의 sorted() 또는 가변 복사본을 사용합니다.

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

public final class SortingAndCopyContracts {
    public static void main(String[] args) {
        List<Entry> source =
                List.of(new Entry("thread", 60), new Entry("array", 40), new Entry("hash", 50));
        Comparator<Entry> byViewCount = Comparator.comparingInt(Entry::viewCount);
        List<Entry> immutableSorted = source.stream().sorted(byViewCount).toList();
        List<Entry> mutableSorted = new ArrayList<>(source);
        mutableSorted.sort(byViewCount.reversed());
        System.out.println("source=" + source);
        System.out.println("asc=" + immutableSorted);
        System.out.println("desc=" + mutableSorted);
        mutableSorted.add(new Entry("queue", 30));
        System.out.println("mutable-size=" + mutableSorted.size());
    }

    private record Entry(String title, int viewCount) {}
}

Stream.toList() 결과는 수정할 수 없는 List입니다. 이 main은 그 결과의 변경을 시도하지 않고 별도 ArrayList 복사본에만 원소를 추가합니다.

가변 결과가 필요하면 수집기 또는 ArrayList 생성자로 복사합니다.

List.copyOf는 입력이 이미 적합한 불변 List일 때 같은 인스턴스를 반환할 수 있으므로 “항상 새 객체”를 규칙으로 삼지 않습니다.

원소가 가변 객체라면 수정 불가 목록 안에서도 그 객체의 필드는 바뀔 수 있습니다. 아래에서는 목록의 칸 교체와 원소 필드 변경을 나눠 확인합니다.

예시

실행 버전: 다음 예제의 List.getFirst()는 Java 21에 추가된 API입니다. 이 예제를 그대로 실행하려면 JDK 21 이상을 사용하세요. 비어 있지 않은 List에서는 첫 원소를 읽는 get(0)과 같은 결과지만, 빈 목록이면 NoSuchElementException이 발생합니다.

import java.util.ArrayList;
import java.util.List;

public final class ShallowSnapshotBoundary {
    public static void main(String[] args) {
        Box first = new Box(40);
        List<Box> source = new ArrayList<>(List.of(first));
        List<Box> snapshot = List.copyOf(source);
        first.count = 55;
        source.set(0, new Box(70));
        System.out.println("source=" + source.getFirst().count);
        System.out.println("snapshot=" + snapshot.getFirst().count);
        System.out.println("shared-first=" + (snapshot.getFirst() == first));
    }

    private static final class Box {
        int count;
        Box(int count) { this.count = count; }
    }
}

출력은 source=70, snapshot=55, shared-first=true입니다. source의 첫 칸을 새 Box로 바꿔도 snapshot은 옛 Box를 가리킵니다. 그러나 복사 전에 공유한 그 Box의 40→55 변경은 snapshot에서도 보입니다. 원문의 Entry는 불변 값 필드를 가진 record라 이 추가 예의 가변 Box와 조건이 다릅니다.

TreeSet·List의 중복 처리

List.sort()는 모든 원소를 보존하고 순서만 바꿉니다.

TreeSet은 비교 결과가 0인 원소를 하나만 남깁니다.

정렬된 보고서에 중복 게시글이 모두 필요하면 List를 정렬해야 합니다.

고유 정렬 키 집합과 범위 조회가 목적이면 TreeSet이 맞습니다.

Collections.min·max는 비교 규칙에 따라 전체 원소를 검사하므로 미리 정렬할 필요가 없습니다. binarySearch에는 검색에 사용할 비교 규칙으로 정렬된 List가 필요합니다.

binarySearch에 정렬되지 않은 List를 넣은 결과는 믿을 수 없습니다.

검색 결과의 뜻: 정렬과 검색에는 같은 순서를 만드는 비교 규칙을 사용해야 합니다. 비교자 객체가 같은 인스턴스일 필요는 없습니다. 성공하면 비교 결과가 0인 원소의 인덱스를 돌려주며, 동점이 여러 개라면 어느 인덱스인지는 보장하지 않습니다. 실패하면 반환값은 -(삽입 위치)-1입니다. 예를 들어 [80, 90, 90]에서 85의 삽입 위치는 0부터 센 1이므로 결과는 -2입니다. 점수만 비교하는 검색으로 특정 제목까지 찾았다고 판단하면 안 됩니다. binarySearch의 전제와 반환값을 함께 확인하세요.

정렬 비교자와 검색 비교자도 같아야 합니다.

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;

public final class ListAndTreeSortingDifference {
    public static void main(String[] args) {
        Comparator<Entry> byScore = Comparator.comparingInt(Entry::score).reversed();
        List<Entry> list =
                new ArrayList<>(
                        List.of(
                                new Entry("hash", 90),
                                new Entry("set", 90),
                                new Entry("queue", 80)));
        list.sort(byScore);
        Set<Entry> tree = new TreeSet<>(byScore);
        tree.addAll(list);
        System.out.println("list-size=" + list.size() + " " + list);
        System.out.println("tree-size=" + tree.size() + " " + tree);
    }

    private record Entry(String title, int score) {}
}

이 예제의 TreeSet에는 먼저 들어간 hash와 queue가 남아 size=2입니다. 같은 90점인 set은 hash와 비교 결과가 0이어서 추가되지 않습니다.

제목 tie-breaker를 추가하거나 List를 유지해야 합니다.

동점과 동일 객체를 구분하세요. 위 Entry의 equals는 제목과 점수를 모두 비교하지만, 점수만 보는 비교자는 다른 제목에도 0을 반환합니다. 이 TreeSet은 그런 비교자에서 어떻게 원소를 남기는지 보여 주는 예제이며, 일반 Set의 equals 기반 동일성 계약과는 일치하지 않습니다. 제목도 보존할 집합이라면 Comparator.comparingInt(Entry::score).thenComparing(Entry::title)처럼 두 필드를 함께 비교하세요. 이 예제의 제목은 null이 아니며 String의 자연 순서를 사용합니다. 같은 점수·같은 제목까지 모두 중복 보관하려면 집합 대신 List를 선택합니다. TreeSet의 비교와 동일성 계약을 기준으로 자료구조의 목적을 먼저 정하세요.

정렬의 안정성: List.sort는 비교 결과가 0인 원소끼리 기존 순서를 유지합니다. 따라서 위 목록에서 먼저 들어간 hash가 같은 90점인 set보다 앞섭니다. 순서가 있는 List.stream().sorted(...)도 이 성질을 보장하지만, 순서가 없는 스트림의 동점 순서까지 보장하지는 않습니다. 안정성은 원소를 제거하는 규칙이 아니므로 목록의 크기는 그대로 3입니다.

이 차이는 성능보다 먼저 확인할 기능 규칙입니다.

동기화 래퍼와 복합 원자성

Collections.synchronizedList는 개별 메서드 호출을 동기화합니다.

if (!list.contains(x)) list.add(x) 두 호출 전체는 하나의 잠금 구간이 아니므로 다른 스레드가 사이에 들어올 수 있습니다.

중복 없는 동시 저장이면 동시성 Set 등 목적에 맞는 구조를 사용합니다.

래퍼를 순회할 때는 문서대로 해당 컬렉션 객체를 synchronized 블록으로 잠가야 합니다.

Iterator 자체가 전체 순회를 잠그지 않습니다.

중복 검사 두 호출의 틈을 예로 들면, 빈 목록에서 A 스레드 contains(x)=false, B도 contains(x)=false, 그 뒤 A와 B가 각각 add(x)를 실행할 수 있습니다. 각 메서드가 보호되어도 목록은 [x, x]가 됩니다. 한 잠금으로 contains부터 add까지 묶는 별도 정책이 필요한 이유입니다. 이 순서는 가능한 실행 모델이며 여기서 실제 스레드 경합을 재현한 것은 아닙니다.

이 장에서는 규칙만 확인하고 실제 가시성과 경합은 19장에서 다룹니다.

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

public final class BoardSnapshotService {
    public static void main(String[] args) {
        Service service = new Service();
        service.add("hash", 50);
        service.add("array", 40);
        List<Entry> first = service.ranking();
        service.add("thread", 60);
        System.out.println("first=" + first);
        System.out.println("current=" + service.ranking());
    }

    private static final class Service {
        private final List<Entry> entries = new ArrayList<>();

        void add(String title, int viewCount) {
            entries.add(new Entry(title, viewCount));
        }

        List<Entry> ranking() {
            return entries.stream()
                    .sorted(Comparator.comparingInt(Entry::viewCount).reversed())
                    .toList();
        }
    }

    private record Entry(String title, int viewCount) {}
}

첫 ranking은 이후 add의 영향을 받지 않는 결과 List입니다.

내부 ArrayList 소유권을 노출하지 않고 표현 시점에 정렬합니다.

스냅샷과 동시 접근은 별개입니다. BoardSnapshotService는 한 스레드에서 추가하고 조회하는 예제입니다. ranking()이 독립적인 결과 목록을 반환해도 내부 ArrayList의 쓰기와 정렬용 순회를 여러 스레드에서 동시에 수행해도 안전해지는 것은 아닙니다. 그런 서비스에는 원본을 읽고 변경하는 동안의 접근 규칙이 추가로 필요합니다.

연습 문제

원본 String 배열을 바꾸어도 영향받지 않고 add와 정렬이 가능한 List를 만드세요.

목록 변경도 원본 배열에 반영되면 안 됩니다.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public final class IndependentMutableListSolution {
    public static void main(String[] args) {
        String[] source = {"thread", "array"};
        List<String> values = new ArrayList<>(Arrays.asList(source));
        source[0] = "changed";
        values.add("hash");
        values.sort(String::compareTo);
        System.out.println("source=" + Arrays.toString(source));
        System.out.println("values=" + values);
    }
}

변환 API를 고를 때는 크기 변경, set 허용, 원본 공유, null 허용을 표로 적습니다.

정렬은 원본 변경 여부와 동률 보존을 더 확인해야 안전한 컬렉션 변환이 됩니다.

추가 연습: 동점 보존과 검색 실패를 따로 판정하기

입력은 hash=90, set=90, queue=80의 세 Entry이며 제목은 모두 서로 다른, null이 아닌 문자열입니다. 점수 오름차순으로 먼저 비교하고 동점일 때 제목 오름차순으로 비교하는 TreeSet의 제목 순서와 크기를 구하세요. 별도의 정렬된 점수 목록 [80, 90, 90]에서 85를 검색했을 때 반환값과 삽입 위치도 구하세요. 마지막으로 90을 검색했을 때 특정 인덱스 하나를 정답으로 고정해도 되는지 설명하세요.

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

public class SortTieAndSearchSolution {
    record Entry(String title, int score) {}

    public static void main(String[] args) {
        var order = Comparator.comparingInt(Entry::score)
                .thenComparing(Entry::title);
        var entries = new TreeSet<Entry>(order);
        entries.addAll(List.of(new Entry("hash", 90),
                new Entry("set", 90), new Entry("queue", 80)));
        System.out.println("titles=" + entries.stream().map(Entry::title).toList());
        System.out.println("size=" + entries.size());

        var scores = List.of(80, 90, 90);
        int missing = Collections.binarySearch(scores, 85);
        int found = Collections.binarySearch(scores, 90);
        System.out.println("missing=" + missing);
        System.out.println("insertion=" + (-missing - 1));
        System.out.println("duplicate-index-valid=" + (found == 1 || found == 2));
        System.out.println("duplicate-score=" + scores.get(found));
    }
}