[Java] 사용자 정의 정렬: Anonymous Class, sort(), compareTo(), compareToIgnoreCase()

💡익명클래스

---

class MyComparator implements Comparator<Integer>{
	@Override
	public int compare(Integer o1, Integer o2) {
		if (o1 > o2) {
			return 1;
		} else if (o1 < o2) {
			return -1;
		} else {
			return 0;
		}
	}
}

o1 vs o2

위 익명 클래스는 요소끼리의 비교를 해서 자리를 바꿀지 말지를 결정하는 부분이다.

boolean은 2가지 상황밖에 판단을 못 하므로 Integer 숫자형으로 반환한다.

 

1. 오름차순

• a. o1이 더 크면 > 양수 반환 > 1을 반환하는 경우가 많음
• b. o2가 더 크면 > 음수 반환 > -1
• c. 같으면 > 0 반환
          

2. 내림차순

• a. o1이 더 크면 > 음수 반환 > -1
• b. o2가 더 크면 > 양수 반환 > 1
• c. 같으면 > 0 반환

 

💡정수형 정렬

---

Integer[] nums = {1, 5, 2, 4, 3};
System.out.println(Arrays.toString(nums));

// 오름차순 정렬
Arrays.sort(nums); // Quick Sort
System.out.println(Arrays.toString(nums));

// 오름차순 정렬
Arrays.sort(nums, new MyComparator());
System.out.println(Arrays.toString(nums));

 

💡실수형 정렬

---

Double[] num2 = { 2.5, 7.1, 4.5, 2.8, 6.4 };

// 오름차순 정렬
Arrays.sort(num2, new Comparator<Double>() {
    @Override
    public int compare(Double o1, Double o2) {
        /*
        if (o1 < o2) {
            return 1;
        } else if (o1 > o2) {
            return -1;
        } else {
            return 0;
        }
        */
        return (int)Math.ceil(o2 - o1);
    }
});
System.out.println(Arrays.toString(num2));

 

💡문자형 정렬

---

String txt1 = "단풍나무";
String txt2 = "조팝나무";
int n = 0;

// 오름차순 정렬
for (int i=0; i<3; i++) {
    char c1 = txt1.charAt(i);
    char c2 = txt2.charAt(i);

    if (c1 > c2) {
        n = 1;
        break;
    } else if (c1 < c2) {
        n = -1;
        break;
    }
}
System.out.println(n);

 

compareTo()

System.out.println(txt1.compareTo(txt2));

 

compareToIgnoreCase()

txt1 = "AAA";
txt2 = "aaa";
System.out.println(txt1.compareToIgnoreCase(txt2));

compareToIgnoreCase() 메소드는 대소문자를 구분하지 않는다.

 

문자열 정렬

String[] names = { "칠엽수", "단풍나무", "담쟁이덩굴", "쥐똥나무", "조팝나무", "은행나무", "벚나무"};

// 오름차순 정렬
Arrays.sort(names);
System.out.println(Arrays.toString(names));

Arrays.sort(names, new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        // return o1.compareTo(o2); // 오름차순 정렬

        // return o2.compareTo(o1); // 내림차순 정렬

        // return o1.length() - o2.length(); // 글자수 정렬

        // 글자수 정렬
        if (o1.length() > o2.length()) {
            return 1;
        } else if (o1.length() < o2.length()) {
            return -1;
        } else {
            // 2차 정렬 기준
            return o2.compareTo(o1);
        }
    }
});
System.out.println(Arrays.toString(names));

// 오름차순 정렬 결과
[단풍나무, 담쟁이덩굴, 벚나무, 은행나무, 조팝나무, 쥐똥나무, 칠엽수]

// 내림차순 정렬 결과
[칠엽수, 쥐똥나무, 조팝나무, 은행나무, 벚나무, 담쟁이덩굴, 단풍나무]

// 글자수 정렬 결과
[칠엽수, 벚나무, 단풍나무, 쥐똥나무, 조팝나무, 은행나무, 담쟁이덩굴]

// 2차 정렬 기준 결과
[칠엽수, 벚나무, 쥐똥나무, 조팝나무, 은행나무, 단풍나무, 담쟁이덩굴]

 

💡날짜시간 정렬

---

Calendar[] dates = new Calendar[5];
		
for (int i=0; i<dates.length; i++) {
    dates[i] = Calendar.getInstance();
}

dates[0].add(Calendar.DATE, 7);
dates[1].add(Calendar.DATE, -2);
dates[2].add(Calendar.DATE, 1);
dates[3].add(Calendar.DATE, 0);
dates[4].add(Calendar.DATE, 3);

// 오름차순 정렬
Arrays.sort(dates);
for (int i=0; i<dates.length; i++) {
    System.out.printf("%tF\n", dates[i]);
}
System.out.println();

// 내림차순 정렬
Arrays.sort(dates, new Comparator<Calendar>() {
    @Override
    public int compare(Calendar o1, Calendar o2) {
        return o2.compareTo(o1);
    }
});
for (int i=0; i<dates.length; i++) {
    System.out.printf("%tF\n", dates[i]);
}
System.out.println();

// 요일순정렬
Arrays.sort(dates, new Comparator<Calendar>() {
    @Override
    public int compare(Calendar o1, Calendar o2) {
        // 일(1) ~ 토(7)
        return o1.get(Calendar.DAY_OF_WEEK) - o2.get(Calendar.DAY_OF_WEEK);
    }
});
for (int i=0; i<dates.length; i++) {
    System.out.printf("%tF\n", dates[i]);
}
System.out.println();

// 오름차순 정렬 결과
2023-08-07
2023-08-09
2023-08-10
2023-08-12
2023-08-16

// 내림차순 정렬 결과
2023-08-16
2023-08-12
2023-08-10
2023-08-09
2023-08-07

// 요일순 정렬 결과
2023-08-07
2023-08-16
2023-08-09
2023-08-10
2023-08-12

 

💡객체 정렬

---

// 객체 멤버 정렬
class Score {
	private String name;
	private int kor;
	private int math;
	private int eng;
	
	// 생성자
	public Score(String name, int kor, int math, int eng) {
		this.name = name;
		this.kor = kor;
		this.math = math;
		this.eng = eng;
	}

	public String getName() {
		return name;
	}

	public int getKor() {
		return kor;
	}

	public int getMath() {
		return math;
	}

	public int getEng() {
		return eng;
	}

	@Override
	public String toString() {
		return "Score [name=" + name + ", kor=" + kor + ", math=" + math + ", eng=" + eng + "]";
	}
}

Score[] list = new Score[5];

list[0] = new Score("Lee", 100, 90, 80);
list[1] = new Score("Kim", 80, 55, 90);
list[2] = new Score("Yu", 75, 65, 85);
list[3] = new Score("Park", 85, 95, 75);
list[4] = new Score("Hong", 90, 80, 90);

System.out.println(Arrays.toString(list));

// 이름순 정렬
Arrays.sort(list, new Comparator<Score>() {
    @Override
    public int compare(Score o1, Score o2) {
        return o1.getName().compareTo(o2.getName());
    }
});
System.out.println(Arrays.toString(list)); // ClassCastException

// 성적순 정렬
Arrays.sort(list, new Comparator<Score>() {
    @Override
    public int compare(Score o1, Score o2) {
        // return o2.getKor() - o1.getKor();
        return (o2.getKor() + o2.getEng() + o2.getMath()) - (o1.getKor() + o1.getEng() + o1.getMath());
    }
});
System.out.println(Arrays.toString(list));

// 성적 배열 생성
[Score [name=Lee, kor=100, math=90, eng=80], Score [name=Kim, kor=80, math=55, eng=90], Score [name=Yu, kor=75, math=65, eng=85], Score [name=Park, kor=85, math=95, eng=75], Score [name=Hong, kor=90, math=80, eng=90]]

// 이름순 정렬 결과
[Score [name=Hong, kor=90, math=80, eng=90], Score [name=Kim, kor=80, math=55, eng=90], Score [name=Lee, kor=100, math=90, eng=80], Score [name=Park, kor=85, math=95, eng=75], Score [name=Yu, kor=75, math=65, eng=85]]

// 성적순 정렬 결과
[Score [name=Lee, kor=100, math=90, eng=80], Score [name=Hong, kor=90, math=80, eng=90], Score [name=Park, kor=85, math=95, eng=75], Score [name=Kim, kor=80, math=55, eng=90], Score [name=Yu, kor=75, math=65, eng=85]]

 

💡컬렉션 정렬

---

ArrayList<Integer> list = new ArrayList<Integer>();

// 난수 발생
for (int i=0; i<10; i++) {
    list.add((int)(Math.random() * 100)); // 0~99
}
System.out.println(list);

// 오름차순 정렬
Collections.sort(list);
System.out.println(list);

// 내림차순 정렬
Collections.sort(list, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
});
System.out.println(list);

// 컬렉션만의 내림차순 방법
list.sort(new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
});
System.out.println(list);

// 난수 발생 결과
[35, 69, 12, 89, 85, 42, 44, 1, 56, 45]

// 오름차순 정렬 결과
[1, 12, 35, 42, 44, 45, 56, 69, 85, 89]

// 내림차순 정렬 결과
[89, 85, 69, 56, 45, 44, 42, 35, 12, 1]

// 컬렉션만의 내림차순 정렬 결과
[89, 85, 69, 56, 45, 44, 42, 35, 12, 1]