일반 정렬

오름차순, 내림차순 정렬

​int [] arr = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9 ,10};
Arrays.sort(arr);
​
Arrays.sort(arr, 시작 index, 끝 index + 1)
-> 시작 index 부터 끝 index까지 범위 안에서 정렬
​
Integer [] arr2 = Arrays.stream(arr).boxed().toArray(Integer[]::new);
-> toArray() 는 기본적으로 Object[]를 반환하기 때문에 
배열 생성자 참조를 넘겨 명시적으로 타입을 지정해야함.
Array.sort(arr2, Collections.reverseOrder());

int[] dec_arr = Arrays.stream(arr).boxed()
.sorted(Comparator.reverseOrder())
.mapToInt(Integer::intValue)
.toArray();

String 정렬

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        String str = "badc";
        char[] chars = str.toCharArray();
        Arrays.sort(chars);
        String sortedStr = new String(chars);
        System.out.println(sortedStr);
    }
}

단어정렬

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        String[] wordList = new String[n];
        for (int i = 0; i < n; i++) {
            wordLi
            st[i] = sc.next();
        }
        // Please write your code here.

        List<String> wdList = Arrays.asList(wordList);

        Collections.sort(wdList);

        for(String s : wdList)
            System.out.println(s);

    }
}

List<String> filteredSorted = Arrays.stream(words)
                .filter(word -> word.startsWith(t))
                .sorted()
                .collect(Collectors.toList());

List<String> filteredSorted = Arrays.stream(words)
                .filter(word -> word.startsWith(t))
                .sorted(Comparator.reverseOrder()) // 역순 정렬
                .collect(Collectors.toList());
                
// Stream<T> 인터페이스 내부
Stream<T> sorted();                            // Comparable 기반 오름차순
Stream<T> sorted(Comparator<? super T> comp);  // 커스텀 정렬

✅ 권장 방식 (간결, 명확)

Arrays.sort(arr, Comparator.reverseOrder());
Collections.sort(list, Comparator.reverseOrder());

⚠️ 옛날 방식 (Collections.reverseOrder()도 동작은 같지만 구식 스타일)

Collections.sort(list, Collections.reverseOrder());

📌 두 방식 모두 동작은 같습니다, 내부 구현도 동일한 ReverseComparator를 사용합니다.

✅ 예제 비교

1. Arrays.sort() - 배열 정렬

String[] arr = {"banana", "apple", "cat"};
Arrays.sort(arr); // 오름차순
Arrays.sort(arr, Comparator.reverseOrder()); // 내림차순

2. Collections.sort() - 리스트 정렬

List<String> list = Arrays.asList("banana", "apple", "cat");
Collections.sort(list); // 오름차순
Collections.sort(list, Comparator.reverseOrder()); // 내림차순

---

✅ 내부 동작 차이

정렬 대상	알고리즘
int[], double[], char[] 등 기본형 배열	Dual-Pivot QuickSort (매우 빠름)
T[] 객체 배열 (ex. String[])	TimSort (안정 정렬)
List<T>	TimSort (안정 정렬)

🔹 TimSort는 Java에서 안정 정렬이며, 정렬된 구간을 활용해 빠르게 동작합니다. 🔹 기본형 배열에서는 메모리를 아끼고 속도 빠른 QuickSort를 사용합니다.

---

✅ 언제 뭘 써야 하나?

상황	사용 예
배열을 정렬해야 할 때	Arrays.sort()
리스트를 정렬해야 할 때	Collections.sort() 또는 List.sort() (Java 8+)

✅ Java 8 이상에서는 list.sort()를 더 권장합니다. 이유는:

• 인터페이스가 더 깔끔함

• 람다와 Comparator 체이닝이 더 유연하게 가능함

---

✅ 마무리 예시: Java 8 스타일 리스트 정렬

list.sort(Comparator.comparing(String::length).reversed());