[Java] 배열 정렬하기

기본 타입(Primitive)의 배열

---

int, double, float등 기본 타입의 배열을 정렬하기 위한 방법은 다음과 같다.

 

오름차순

int[] arr = new int[]{9, 8, 2, 10, 4};

Arrays.sort(arr);

 

내림차순

내림차순의 경우 복잡해진다.

1. stream을 사용하는 방법

int[] arr = {5, 3, 8, 1, 9, 2};

// int[] 배열을 Integer[] 배열로 변환
Integer[] integerArray = Arrays.stream(arr).boxed().toArray(Integer[]::new);
// 배열을 내림차순으로 정렬
Arrays.sort(integerArray, Collections.reverseOrder());

• stream을 통해 객체 타입의 배열로 변환해 줬다.

 

2. stream을 사용하지 않고 객체 타입의 배열로 변환하는 방법

int[] arr = {5, 3, 8, 1, 9, 2};

// int[] 배열을 Integer[] 배열로 변환
Integer[] integerArray = new Integer[arr.length];
for (int i = 0; i < arr.length; i++) {
    integerArray[i] = arr[i];
}
// 배열을 내림차순으로 정렬
Arrays.sort(integerArray, Collections.reverseOrder());

 

3. 객체 타입 배열로 변환하지 않고 하는 방법

int[] arr = {5, 3, 8, 1, 9, 2};

// 배열을 오름차순으로 정렬
Arrays.sort(arr);

// 배열 뒤집어 주기
int n = arr.length;
for (int i = 0; i < n / 2; i++) {
    int temp = array[i];
    array[i] = array[n - 1 - i];
    array[n - 1 - i] = temp;
}

• 배열을 오름차순으로 정렬한 뒤 뒤집었다.

 

객체타입(Object) 배열

---

오름차순

Integer[] numbers = {3, 5, 1, 4, 2};

// 오름차순 정렬
Arrays.sort(numbers);

 

내림차순

Integer[] numbers = {3, 5, 1, 4, 2};

// 내림차순 정렬
Arrays.sort(numbers, Collections.reverseOrder());

• Arrays.sort()의 두번째 인자로 Collections.reverseOrder()를 사용하면 된다.

 

List<>

---

List도 객체타입 배열과 같다고 보면된다.

단 Collections.sort()를 쓴다.

오름차순

List<Integer> numbers = new ArrayList<>();
numbers.add(3);
numbers.add(5);
numbers.add(1);
numbers.add(4);
numbers.add(2);

// 오름차순 정렬
Collections.sort(numbers);

 

내림차순

List<Integer> numbers = new ArrayList<>();
numbers.add(3);
numbers.add(5);
numbers.add(1);
numbers.add(4);
numbers.add(2);

// 내림차순 정렬
Collections.sort(numbers, Collections.reverseOrder());

 

객체의 특정 속성으로 정렬하는 경우

예를 들어, 다음과 같은 Person 클래스가 있다고 치자.

public class Person {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

 

만약 name(문자열)를 기준으로  정렬한다고 하면

List<Person> people = new ArrayList<>();
people.add(new Person("John", 25));
people.add(new Person("Alice", 30));
people.add(new Person("Bob", 20));

// name 속성으로 오름차순 정렬 (람다식 사용)
people.sort((o1, o2) -> o1.getName().compareTo(o2.getName()));

// name 속성으로 내림차순 정렬 (람다식 사용)
people.sort((o1, o2) -> o2.getName().compareTo(o1.getName()));

 

만약 age(정수)를 기준으로 정렬한다고 하면

List<Person> people = new ArrayList<>();
people.add(new Person("John", 25));
people.add(new Person("Alice", 30));
people.add(new Person("Bob", 20));

// age 속성으로 오름차순 정렬 (람다식 사용)
people.sort((o1, o2) -> Integer.compare(o1.getAge(), o2.getAge()));
// age 속성으로 내림차순 정렬 (람다식 사용)
people.sort((o1, o2) -> Integer.compare(o2.getAge(), o1.getAge()));

 

 

Comparator

---

List<Person> people = new ArrayList<>();
people.add(new Person("John", 25));
people.add(new Person("Alice", 30));
people.add(new Person("Bob", 20));

// age 속성으로 오름차순 정렬 (람다식 사용)
people.sort((o1, o2) -> Integer.compare(o1.getAge(), o2.getAge()));
// age 속성으로 내림차순 정렬 (람다식 사용)
people.sort((o1, o2) -> Integer.compare(o2.getAge(), o1.getAge()));

위의 예시처럼 sort()의 인자로 Comparator를 흔히 다음과 같은 람다식으로 사용한다.

(o1, o2) -> { ... }

 

이때 규칙이 있다.

 

1. 만약 음수를 반환하면 앞에 인자가 뒤에 인자보다 앞에 있어야 한다.

2. 만약 양수를 반환하면 앞에 인자가 뒤에 인자보다 앞에 있어야 한다.

 

따라서,

1. 음수를 반환하면 두 요소의 위치를 바꾸지 않고 유지한다.

2. 양수를 반환하면 두 요소의 위치를 바꾼다.

 

이러한 규칙을 이용해서 오름차순 정렬 / 내림차순 정렬을 할 수 있다.

 

정수 배열

1. 오름차순 정렬

a - b가 양수일때만 둘의 위치를 바꾸는데 이는 a - b가 양수라면 a가 b보다 크다는 것이기 때문에 큰 값이 뒤에 있어야 하는 오름차순 정렬 특성상 위치를 바꿔야 한다.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        Integer[] numbers = {5, 3, 8, 1, 9, 2};

        // 오름차순 정렬
        Arrays.sort(numbers, (a, b) -> a - b);

        System.out.println("오름차순 정렬: " + Arrays.toString(numbers));
    }
}

 

2. 내림차순 정렬

b - a가 양수일때만 둘의 위치를 바꾸는데 이는 b-a가 양수라면 b가 a보다 크다는 것이기 때문에 큰 값이 앞에 있어야 하는 오름차순 정렬 특성상 위치를 바꿔야 한다.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        Integer[] numbers = {5, 3, 8, 1, 9, 2};

        // 내림차순 정렬
        Arrays.sort(numbers, (a, b) -> b - a);

        System.out.println("내림차순 정렬: " + Arrays.toString(numbers));
    }
}

 

문자열 배열

문자열 배열을 사전순으로 정렬하는 경우 흔히 compareTo() 메서드를 사용해서 정렬하곤 하는데

compareTo()메서드는 다음과 같은 특성을 갖고 있다.

str1.compareTo(str2)

(1) str1이 str2보다 작으면(사전상 앞에 있으면) 음수 반환

(2) str1이 str2와 같으면 0 반환

(3) str1이 str2보다 크면(사전상 뒤에 있으면) 양수 반환

이러한 특성을 사용해서 오름차순 정렬과 내림차순 정렬을 할 수 있다.

 

1. 오름차순 정렬(사전 순)

str1.compareTo(str2)가 양수 즉, str1이 str2보다 사전상 뒤에 있는 경우에만 위치를 바꾼다. 

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        String[] strings = {"mango", "apple", "banana"};

        // 오름차순 정렬(사전 순)
        Arrays.sort(strings, (str1, str2) -> str1.compareTo(str2));

		// "apple" - "banana" - "mango"
        System.out.println("오름차순 정렬(사전 순): " + Arrays.toString(strings));
    }
}

 

2. 내림차순 정렬(사전 역순)

str2.compareTo(str1)가 양수 즉, str1이 str2보다 사전상 앞에 있는 경우에만 위치를 바꾼다. 

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        String[] strings = {"mango", "apple", "banana"};

        // 내림차순 정렬(사전 역순)
        Arrays.sort(strings, (str1, str2) -> str2.compareTo(str1));

		// "mango" - "banana" - "apple"
        System.out.println("내림 정렬(사전 역순): " + Arrays.toString(strings));
    }
}