[Java vs Python] 형변환/비교/정렬 한 장 정리

NANO·2026년 9월 30일

Java comparator python 알고리즘 정렬 코딩테스트 형변환

[알고리즘 Cheat Sheet] 한 장 정리

목록 보기

2/10

알고리즘 Cheat Sheet 시리즈는 코딩 테스트를 풀다가 "이거 자바에선 뭐였지?", "파이썬은 어떻게 했더라?" 싶을 때 바로 펼쳐 보려고 만든 개인 참고용 정리입니다.
Java와 Python을 나란히 놓고, 문법 차이 때문에 실수하기 쉬운 부분만 짧게 정리합니다.

이번 주제는 형변환, 비교, 정렬입니다.
입력을 파싱하고, 값을 비교하고, 원하는 기준으로 정렬하는 건 거의 모든 문제에서 반복되는 작업이므로 꼭! 숙지할 필요가 있습니다.

1. 형변환

문자열 ↔ 숫자

변환	자바	파이썬
문자열 → 정수	`Integer.parseInt("123")`	`int("123")`
문자열 → 실수	`Double.parseDouble("3.14")`	`float("3.14")`
정수 → 문자열	`String.valueOf(123)` / `Integer.toString(123)`	`str(123)`
실수 → 문자열	`String.valueOf(3.14)` / `Double.toString(3.14)`	`str(3.14)`
정수 → 실수	`double d = 123;` (자동) / `(double) i`	`float(123)`
실수 → 정수	`(int) 3.14` → `3`	`int(3.14)` → `3`

int i = Integer.parseInt("123");
double d = Double.parseDouble("3.14");
String s = String.valueOf(123);
int t = (int) 3.99;   // 3 (소수점 버림)

i = int("123")
d = float("3.14")
s = str(123)
t = int(3.99)          # 3 (소수점 버림)

문자 ↔ 숫자 (코테 단골)

변환	자바	파이썬
숫자 문자 → 정수	`'7' - '0'` → `7`	`int('7')` → `7`
정수 → 숫자 문자	`(char) (7 + '0')` → `'7'`	`str(7)` → `'7'`
문자 → 아스키 코드	`(int) 'a'` → `97`	`ord('a')` → `97`
아스키 코드 → 문자	`(char) 97` → `'a'`	`chr(97)` → `'a'`
알파벳 인덱스	`c - 'a'`	`ord(c) - ord('a')`

형변환 체크포인트

소수 문자열을 바로 정수로 바꾸면 에러가 난다.
자바 Integer.parseInt("3.14") → NumberFormatException, 파이썬 int("3.14") → ValueError.
실수로 바꾼 뒤 정수로 변환해야 한다: (int) Double.parseDouble("3.14"), int(float("3.14")).
(int), int()는 반올림이 아니라 0 방향 버림이다. (int) -3.7과 int(-3.7)은 둘 다 -3이다.
내림이 필요하면 Math.floor() / math.floor(), 반올림은 Math.round() / round()를 쓴다.
파이썬 round()는 사사오입이 아니다. 은행가 반올림이라 round(2.5)는 2, round(3.5)는 4다.
나눗셈 결과 타입이 다르다.

연산	자바	파이썬
`7 / 2`	`3` (정수끼리면 정수)	`3.5` (항상 실수)
정수 몫	`7 / 2` → `3`	`7 // 2` → `3`
음수 몫	`-7 / 2` → `-3` (0 방향)	`-7 // 2` → `-4` (내림)
음수 나머지	`-7 % 2` → `-1`	`-7 % 2` → `1`

2. 비교

비교 상황	자바	파이썬
기본형 비교	`Integer.compare(x, y)` `Character.compare(c1, c2)` `Double.compare(d1, d2)`	`x < y`, `x == y` 연산자 그대로
객체 기본 기준	`x.compareTo(y)`	`x < y` (문자열은 사전순)
문자열 같은지	`s1.equals(s2)`	`s1 == s2`

compare / compareTo의 반환값은 음수(앞이 작음), 0(같음), 양수(앞이 큼) 이다.

비교 체크포인트

자바에서 문자열은 ==로 비교하면 안 된다. ==는 값이 아니라 참조(주소)를 비교한다. 반드시 equals()를 쓴다.
Integer 객체도 ==로 비교하면 안 된다. -128 ~ 127 범위만 캐시되어 있어서 그 밖의 값은 같은 숫자여도 false가 나올 수 있다. equals()나 intValue()로 비교한다.
비교 함수에 a - b를 쓰지 말자. 정수는 오버플로우가 날 수 있고(Integer.MIN_VALUE - 1), 실수는 int로 잘리면서 오차가 생긴다. Integer.compare(a, b)를 쓴다.

3. 정렬

기본 정렬

상황	자바	파이썬
배열 오름차순	`Arrays.sort(arr)`	`arr.sort()`
리스트 오름차순	`Collections.sort(list)` / `list.sort(null)`	`lst.sort()`
새 리스트로 정렬	`stream().sorted()`	`sorted(lst)`
내림차순	`Arrays.sort(arr, Collections.reverseOrder())`	`arr.sort(reverse=True)`

기준을 정해서 정렬

상황	자바 (람다)	파이썬 (`key`)
오름차순	`(a, b) -> a.compareTo(b)`	기본값
내림차순	`(a, b) -> b.compareTo(a)`	`reverse=True`
길이순	`(a, b) -> Integer.compare(a.length(), b.length())`	`key=len`
첫 원소 기준	`(a, b) -> Integer.compare(a[0], b[0])`	`key=lambda x: x[0]`
1순위 오름, 2순위 내림	아래 코드 참고	`key=lambda x: (x[0], -x[1])`

자바는 (a, b) 순서면 오름차순, (b, a)로 뒤집으면 내림차순으로 외우면 된다.

// 2차원 배열: 첫 번째 값 오름차순, 같으면 두 번째 값 내림차순
Arrays.sort(arr, (a, b) -> {
    if (a[0] != b[0]) return Integer.compare(a[0], b[0]);
    return Integer.compare(b[1], a[1]);
});

// Comparator 체이닝으로도 가능
list.sort(Comparator.comparing((int[] a) -> a[0])
                    .thenComparing(a -> a[1], Comparator.reverseOrder()));

arr.sort(key=lambda x: (x[0], -x[1]))

파이썬은 튜플을 key로 주면 앞 원소부터 차례로 비교한다. 숫자 기준 내림차순은 -만 붙이면 된다.

특수 정렬: 이어 붙였을 때 가장 큰 수

["3", "30", "34", "5", "9"] → "9534330" 처럼 두 값을 붙여 보고 더 큰 쪽을 앞에 두는 정렬이다.

String[] strs = {"3", "30", "34", "5", "9"};
Arrays.sort(strs, (a, b) -> (b + a).compareTo(a + b));
String answer = String.join("", strs);   // "9534330"

from functools import cmp_to_key

strs = ["3", "30", "34", "5", "9"]
strs.sort(key=cmp_to_key(lambda a, b: int(b + a) - int(a + b)))
answer = "".join(strs)                   # "9534330"

파이썬은 key만 받기 때문에, 두 값을 직접 비교하는 함수는 cmp_to_key로 감싸야 한다.

정렬 체크포인트

자바 int[]는 람다나 reverseOrder()로 정렬할 수 없다. 비교자를 받는 Arrays.sort는 Integer[], String[], int[][] 같은 객체 배열에만 쓸 수 있다.
int[]를 내림차순으로 정렬하려면 박싱하거나, 오름차순 정렬 후 뒤에서부터 읽는다.
```
Integer[] boxed = Arrays.stream(arr).boxed().toArray(Integer[]::new);
Arrays.sort(boxed, Collections.reverseOrder());
```
파이썬 list.sort()는 None을 반환한다. arr = arr.sort()라고 쓰면 arr이 None이 된다. 새 리스트가 필요하면 sorted()를 쓴다.
두 언어 모두 객체 정렬은 안정 정렬이다. 기준 값이 같으면 원래 순서가 유지되므로, 정렬을 여러 번 나눠서 해도 된다.