junghyunlyoo boxingUnboxing - GANGNAM-JAVA/JAVA-STUDY GitHub Wiki
- ๊ธฐ๋ณธ ํ์ : int, double, boolean ๋ฑ
- ์ฐธ์กฐ ํ์ : String, List ๋ฑ
๊ธฐ๋ณธ ํ์ ์ 1:1๋์์ผ๋ก '์ฐธ์กฐ ํ์ '์ ํ๋์ฉ ๊ฐ์ง๊ณ ์๋ค.
์ด๋ฅผ '๋ฐ์ฑ๋ ๊ธฐ๋ณธ ํ์ ' ์ด๋ผ๊ณ ๋ถ๋ฅธ๋ค. (Integer,Double,Boolean ๋ฑ)
int num = 10;
Integer integer = new Integer(num); //@Deprecated(since="9")
int newNum = integer.intValue();
๊ทธ๋ฆฌ๊ณ jdk 1.5๋ถํฐ ์ง์๋๋ ์คํ ๋ฐ์ฑ๊ณผ ์คํ ์ธ๋ฐ์ฑ ๋๋ถ์ ๊ธฐ๋ณธ ํ์ ๊ณผ ๋ฐ์ฑ๋ ๊ธฐ๋ณธ ํ์ ์ ํธํ๊ฒ ๊ตฌ๋ถ ์์ด ์ฌ์ฉํ ์ ์๋ค.
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(10);
int integer = list.get(0);
๊ธฐ๋ณธ ํ์ ์ ๊ฐ๋ง ๊ฐ์ง๊ณ ์์ง๋ง, ๋ฐ์ฑ๋ ๊ธฐ๋ณธ ํ์ ์ ๊ฐ์ ๋ํด ์๋ณ์ฑ ์ด๋ผ๋ ์์ฑ๋ ๊ฐ๋๋ค.
(๊ฐ ๊ฐ์ฒด๋ ์ธ์ ๋ ์์ ๋ง์ ์ฃผ์๊ฐ์ ๊ฐ์ง ๊ณ ์ ์ ์กด์ฌ)
๋๊ฐ์ ๋ฐ์ฑ๋ ๊ธฐ๋ณธ ํ์ ์ ๊ฐ(value)์ด ๊ฐ์๋ ๊ฒฐ๊ตญ ์๋ก ๋ค๋ฅด๋ค๋ ๊ฒ์ ์๋ฏธํ๋ค.
'์ฒซ ๋ฒ์งธ ์ฐจ์ด'๋ฅผ ์ฃผ์ํ์ง ์์ผ๋ฉด?
๋ค์์ Integer ๊ฐ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ๋น๊ต์๋ค.
์๋ ์ฝ๋๋ Exception์ ์ผ์ผํค์ง ์๋๋ค. ๋์ฑ ์น๋ช ์ ์ด๊ฒ, ์๋ชป ๊ณ์ฐ๋ ๊ฒฐ๊ณผ๋ฅผ ์์ฐ์ค๋ฝ๊ฒ ์ ์์ ์ผ๋ก ์ฒ๋ฆฌํด๋ฒ๋ฆฐ๋ค.
Comparator<Integer> naturalOrder = (i,j) -> (i < j) ? -1 : (i == j ? 0 : 1);
naturalOrder.compare(new Integer(42), new Integer(42));
๋ Integer์ '๊ฐ'์ด ๊ฐ์์ 0์ด ์ถ๋ ฅ๋ผ์ผ ํ์ง๋ง ์ค์ ๋ก๋ 1์ด ์ถ๋ ฅ๋๋ค.
์ฐธ์กฐ ํ์ (๋ฐ์ฑ๋ ๊ธฐ๋ณธ ํ์ )๊ฐ์ '==' ์ฐ์ฐ์ ๊ฐ ๊ฐ์ฒด์ ์ฃผ์๋ฅผ ๋น๊ตํ๊ธฐ ๋๋ฌธ์
์๋ํ ๊ฐ์ด ์ถ๋ ฅ๋์ง ์๋๋ค...
์ด๋ ๊ฒ ํ๋ฉด ์ ๋๋ก ๊ณ์ฐํ ์ ์๋ค.
//๋น๊ต ๋์์ธ ์์ ๊ฐ์๊ฐ ์ ์ ๊ฒฝ์ฐ
Integer integer1 = 5;
Integer integer2 = 5;
//int๋ก ์คํ ์ธ๋ฐ์ฑ ํ ๋น๊ต
integer1.compareTo(integer2);
=================================
//๋น๊ต ๋์์ธ ์์ ๊ฐ์๊ฐ ๋ง์ ๊ฒฝ์ฐ
List<Integer> values = Arrays.asList(1, 2, 3);
//naturalOrder ๋ฉ์๋๊ฐ Comparable<Object>์ ๊ตฌํํ ๊ฐ์ฒด์
//compareTo๋ฅผ ์ฌ์ฉํ๋๋ก ๊ฐ์ ํ๋ค.
//์ฐธ๊ณ ๋ก ArrayList๋ binarySort ๋ฐฉ์์ ์ฌ์ฉํ๋ค
values.sort(Comparator.naturalOrder());
์ด ํน์ง์ ๊ฐ๊ณผํ๋ค๋ฉด ์ค๋ฅ๊ฐ ๋์ง๋ ๋ชจ๋ฅด๋ ๋์ฐธ์ฌ๊ฐ ์ผ์ด๋ ์ ์๋ค!
๊ธฐ๋ณธ ํ์ ์ ๊ฐ์ ์ธ์ ๋ ์ ํจํ ๊ฐ์ด ๋ค์ด๊ฐ๋ค.
ํ์ง๋ง ๋ฐ์ฑ๋ ๊ธฐ๋ณธ ํ์ ์ ์ฐธ์กฐ ํ์ ์ด๊ธฐ ๋๋ฌธ์ ์ ํจํ์ง ์์ ๊ฐ, ์ฆ null์ด ๋ค์ด๊ฐ ์ ์๋ค.
'๋ ๋ฒ์งธ ์ฐจ์ด'๋ฅผ ์ฃผ์ํ์ง ์์ผ๋ฉด?
public class Unbelievable {
static Integer i;
public static void main(String[] args) {
if (i == 42)
System.out.println("๋ฏฟ์ ์ ์๊ตฐ!");
}
}
์๋ฌด๊ฒ๋ ์ถ๋ ฅ์ด ๋์ง ์๋ ๊ฒ์ ์๋ํ ์ฝ๋๊ฒ ์ง๋ง, ์์ฝ๊ฒ๋(?) ๊ทธ ์ ์ ์๋ฌ๊ฐ ๋ฐ์ํ๋ค.
i == 42 ๋ฅผ ํ ๋, null ์ฐธ์กฐ๋ฅผ ์ธ๋ฐ์ฑํ๊ฒ ๋๋ฉด์ NPE๊ฐ ํฐ์ง๋ค.
i์ ํ์ ์ Integer์์ int๋ก ๋ฐ๊ฟ์ผ ํ๋ค!
๊ธฐ๋ณธ ํ์ ์ด ๋ฐ์ฑ๋ ๊ธฐ๋ณธ ํ์ ๋ณด๋ค ์๊ฐ๊ณผ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ฉด์์ ๋ ํจ์จ์ ์ด๋ค.
'์ธ ๋ฒ์งธ ์ฐจ์ด'๋ฅผ ์ฃผ์ํ์ง ์์ผ๋ฉด?
public static void main(String[] args) {
Long sum = 0L;
for (long i = 0; i <= Integer.MAX_VALUE; i++) {
sum += i;
}
System.out.println(sum);
}
์ ์ฝ๋๋ ๋ฐ์ฑ๊ณผ ์ธ๋ฐ์ฑ์ด ๋ฐ๋ณตํด์ ์ผ์ด๋๊ธฐ ๋๋ฌธ์ ์ฒด๊ฐ๋ ์ ๋๋ก ์ฑ๋ฅ์ด ๋๋ฆฌ๋ค. ( sum = sum + i )
๊ธฐ๋ณธ ํ์ ์ด ๊ฐ๋จํ๊ณ ๋น ๋ฅด๊ณ ์ ๊ฒฝ์ ๋ ์จ๋ ๋๋, ์ฌ๋งํ๋ฉด ๊ธฐ๋ณธ ํ์ ์ ์ฌ์ฉํ์.
์ฐธ๊ณ ๋ก ์๋์ ๊ฒฝ์ฐ์ ๋ฐ์ฑ๋ ๊ธฐ๋ณธ ํ์ ์ ์ฌ์ฉํ๋ค.
- ๋งค๊ฐ๋ณ์ํ ํ์ (List ๋ฑ)
- ๋งค๊ฐ๋ณ์ํ ๋ฉ์๋์ ํ์ ๋งค๊ฐ๋ณ์(T, E ๋ฑ)
- ๋ฆฌํ๋ ์