๐ฆ ์๋ฐ ๋ํผ ํด๋์ค(Wrapper Class): ์บ์ฑ๊ณผ ์คํ ๋ฐ์ฑ ์๋ฆฌ ์ด์ ๋ฆฌ
๋ชฉ์ฐจ
1. ์๋ฐ ๋ํผ ํด๋์ค(Wrapper Class)๋?
์๋ฐ์๋ int, char, double๊ณผ ๊ฐ์ ๊ธฐ๋ณธ ํ์
(Primitive Type)์ด ์์ต๋๋ค. ํ์ง๋ง ๊ฐ์ฒด ์งํฅ ํ๋ก๊ทธ๋๋ฐ์ ํ๋ค ๋ณด๋ฉด ์ด ๊ธฐ๋ณธ ํ์
๋ค์ '๊ฐ์ฒด'๋ก ๋ค๋ค์ผ ํ ๋๊ฐ ์์ต๋๋ค(์: ์ปฌ๋ ์
ํ๋ ์์ํฌ์ธ ArrayList์ ์ ์ฅํ ๋). ์ด๋ ๊ธฐ๋ณธ ํ์
์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ฒด๋ก ๊ฐ์ธ๋(Wrapping) ํด๋์ค๋ฅผ ๋ํผ ํด๋์ค๋ผ๊ณ ํฉ๋๋ค.
โ ๊ธฐ๋ณธ ํ์ → ๋ํผ ํด๋์ค ๋งค์นญ
| byte → Byte | short → Short | int → Integer | long → Long |
| float → Float | double → Double | char → Character | boolean → Boolean |
2. ์๋ฐ ๋ํผ ํด๋์ค ์บ์ฑ (Wrapper Class Caching)
(1) ์บ์ฑ์ ๊ฐ๋
์๋ฐ์ ๋ํผ ํด๋์ค๋ ํน์ ๋ฒ์ ๋ด์ ๊ฐ์ ๊ฐ์ง ๋, ๊ฐ์ฒด๋ฅผ ๋งค๋ฒ ์๋ก ์์ฑํ์ง ์๊ณ ๋ฏธ๋ฆฌ ๋ง๋ค์ด์ง ๊ฐ์ฒด๋ฅผ ์ฌ์ฌ์ฉํฉ๋๋ค. ์ด๋ฅผ ํตํด ๋ฉ๋ชจ๋ฆฌ ๋ญ๋น๋ฅผ ์ค์ด๊ณ ์คํ ์ฑ๋ฅ์ ๋์ด๋ ํจ๊ณผ๊ฐ ์์ต๋๋ค.
(2) ํด๋์ค๋ณ ์บ์ฑ ์ง์ ์ฌ๋ถ ๋ฐ ๋ฒ์
- ์บ์ฑ ์ง์
- Boolean: true์ false ์ ์ฒด.
- Byte: -128 ~ 127 (์ ๋ฒ์).
- Character: 0 ~ 127 (์์คํค ์ฝ๋ ๋ฒ์).
- Short, Integer, Long: ๊ธฐ๋ณธ์ ์ผ๋ก -128 ~ 127 ๋ฒ์.
- ์บ์ฑ ๋ฏธ์ง์: Float, Double (์ค์๋ ๊ฐ์ ๋ฒ์๊ฐ ๋ฌดํ๋์ ๊ฐ๊น์ ์บ์ฑ ํจ์จ์ด ๋จ์ด์ง).
(3) ์บ์ฑ ๋์ ์กฐ๊ฑด ๋ฐ ํน์ ๊ธฐ๋ฅ
- valueOf() ๋ฉ์๋ ํธ์ถ: ์บ์ฑ์
valueOf()ํธ์ถ ์ ๋ฐ์ํฉ๋๋ค. ์คํ ๋ฐ์ฑ ์์๋ ์ปดํ์ผ๋ฌ๊ฐ ์ด ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฏ๋ก ์บ์ฑ์ด ์ ์ฉ๋ฉ๋๋ค. - ์ฃผ์์ฌํญ:
new Integer(100)์ฒ๋ผ ์์ฑ์๋ฅผ ์ง์ ์ฌ์ฉํ๋ฉด ์บ์ฑ๋์ง ์๊ณ ํญ์ ์ ๊ฐ์ฒด๊ฐ ์์ฑ๋ฉ๋๋ค. - Integer ๋ฒ์ ํ๋: JVM ์ต์
-XX:AutoBoxCacheMax=<size>๋ฅผ ํตํด ์บ์ฑ ์ต๋๊ฐ์ ์ง์ ์ค์ ํ ์ ์์ต๋๋ค. (์: 1000 ์ค์ ์ 500๋ ๋์ผ ๊ฐ์ฒด ์ทจ๊ธ)
3. ์คํ ๋ฐ์ฑ(Autoboxing) & ์ธ๋ฐ์ฑ(Unboxing)
- ์คํ ๋ฐ์ฑ: ๊ธฐ๋ณธ ํ์ ๊ฐ์ ๋ํผ ํด๋์ค ๊ฐ์ฒด๋ก ์๋ ๋ณํ (์: int → Integer)
- ์ธ๋ฐ์ฑ: ๋ํผ ํด๋์ค ๊ฐ์ฒด๋ฅผ ๊ธฐ๋ณธ ํ์ ๊ฐ์ผ๋ก ์๋ ๋ณํ (์: Integer → int)
โ๏ธ ๋์ ์๋ฆฌ (๋ฐ์ดํธ ์ฝ๋์ ๋น๋ฐ)
์ปดํ์ผ๋ฌ๊ฐ ๋ด๋ถ์ ์ผ๋ก ๋ณํ ๋ฉ์๋๋ฅผ ์๋์ผ๋ก ์ถ๊ฐํด์ค๋๋ค.
- ์คํ ๋ฐ์ฑ: Integer.valueOf() ํธ์ถ ์ฝ๋ ์ถ๊ฐ
- ์ธ๋ฐ์ฑ: intValue(), longValue() ๋ฑ ํธ์ถ ์ฝ๋ ์ถ๊ฐ
4. ์ฃผ์ ์ฌํญ ๋ฐ ์ฑ๋ฅ ์ด์
โ ๏ธ ๋ถํ์ํ ๊ฐ์ฒด ์์ฑ
๋ํผ ํด๋์ค๋ ๋ถ๋ณ ๊ฐ์ฒด(Immutable)์ ๋๋ค. ์ฐ์ฐ ์๋ง๋ค ์๋ก์ด ๊ฐ์ฒด๊ฐ ์์ฑ๋์ด ๋ฉ๋ชจ๋ฆฌ ๋ญ๋น๋ฅผ ์ด๋ํฉ๋๋ค.
Integer sum = 0;
for (int i = 0; i < 1000; i++) {
sum += i;
// ์ธ๋ฐ์ฑ -> ์ฐ์ฐ -> ์คํ ๋ฐ์ฑ ๋ฐ์
// 1000๊ฐ์ ๊ฐ์ฒด ์์ฑ!
}
int sum = 0;
for (int i = 0; i < 1000; i++) {
sum += i;
}
// ๊ธฐ๋ณธ ํ์
์ ์ฌ์ฉํ์ฌ
// ์คํ ๋ฉ๋ชจ๋ฆฌ์์ ์ฐ์ฐ
โ๏ธ ๋น๊ต ์ฐ์ฐ ์ฃผ์ (== vs .equals())
- ๋ํผ ํด๋์ค ๊ฐ == ๋น๊ต: ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ๋น๊ตํฉ๋๋ค. ์บ์ฑ ๋ฒ์๋ฅผ ๋ฒ์ด๋๋ฉด ๊ฐ์ด ๊ฐ์๋
false๊ฐ ๋์ฌ ์ ์์ผ๋ฏ๋ก ๋ฐ๋์.equals()๋ฅผ ์ฌ์ฉํด์ผ ํฉ๋๋ค. - ๊ธฐ๋ณธ ํ์
๊ณผ์ ๋น๊ต: ํ์ชฝ์ด ๊ธฐ๋ณธ ํ์
์ด๋ฉด ์๋์ผ๋ก ์ธ๋ฐ์ฑ๋์ด ๊ฐ ๋น๊ต๊ฐ ์ํ๋ฉ๋๋ค. (
true๋ฐํ)
5. ์ถ๊ฐ ๊ฐ๋ : ์ ํ์ค ์๊ฐ (Syntax Sugar)
์คํ ๋ฐ์ฑ๊ณผ ์ธ๋ฐ์ฑ์ ์๋ฐ์ ๋ํ์ ์ธ ์ ํ์ค ์๊ฐ์ ๋๋ค. ๋ณต์กํ ์ฝ๋๋ฅผ ๊ฐ๊ฒฐํ๊ฒ ์์ฑํ๋๋ก ๋์ง๋ง, ๋ด๋ถ ๋์์ ๋ชจ๋ฅด๋ฉด ์ฑ๋ฅ ์ ํ๋ฅผ ์ผ์ผํฌ ์ ์์ต๋๋ค.
"์คํ์ด ์ด๋ป๊ฒ ๋ น์ ๋ค์ด๊ฐ๋์ง ์ดํดํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค."
์ปดํ์ผ๋ฌ๊ฐ Integer num = 10;์ Integer.valueOf(10);์ผ๋ก ๋ฐ๊พธ๋ ๊ณผ์ ์ ์์์ผ ๋ถํ์ํ ๊ฐ์ฒด ์์ฑ์ ๋ง๋ ์ต์ ํ๋ ์ฝ๋๋ฅผ ์งค ์ ์์ต๋๋ค.
์ถ์ฒ: ์๋ฐ ๋ํผ ํด๋์ค ์บ์ฑ ๋ฐ ์คํ ๋ฐ์ฑ ์๋ฆฌ ์ ๋ฆฌ ๊ฐ์ด๋
'โ Backend > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [Java] ๊ฐ๋น์ง ์ปฌ๋ ํฐ (Garbage Collector, GC) (0) | 2026.04.02 |
|---|---|
| [Java] ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ(OOP) (1) | 2026.04.02 |
| [์๋ฐ ์ค๊ธ] 11. Generic 1 (2) | 2024.11.06 |
| [์๋ฐ ์ค๊ธ] 10. ์์ธ ์ฒ๋ฆฌ 2 (1) | 2024.10.22 |
| [์๋ฐ ์ค๊ธ] 09. ์์ธ ์ฒ๋ฆฌ 1 (1) | 2024.10.21 |