item 61 jihoon - JAVA-JIKIMI/EFFECTIVE-JAVA3 GitHub Wiki
-
๋ฐ์ดํฐ ํ์
- ๊ธฐ๋ณธ(Primitive) ํ์
- ์ฐธ์กฐ(Reference) ํ์
-
๊ธฐ๋ณธ ํ์ ์๋ ๋์ํ๋ ์ฐธ์กฐ ํ์ ์ด ํ๋์ฉ ์๊ณ , ์ด๋ฅผ
๋ฐ์ฑ๋ ๊ธฐ๋ณธ ํ์
์ด๋ผ๊ณ ํ๋ค.- Integer(int)
- Double(double)
- Boolean(boolean)
- ๊ธฐ๋ณธ ํ์ ์ ๊ฐ๋ง ๊ฐ์ง๊ณ ์์ผ๋, ๋ฐ์ฑ๋ ๊ธฐ๋ณธ ํ์ ์ ๊ฐ์ ๋ํด ์๋ณ์ฑ(identity)์ด๋ ์์ฑ์ ๊ฐ๋๋ค(๊ฐ์ด ๊ฐ์๋ ์๋ก ๋ค๋ฅด๋ค๊ณ ์๋ณ๋ ์ ์๋ค).
- ๊ธฐ๋ณธ ํ์ ์ ๊ฐ์ ์ธ์ ๋ ์ ํจํ๋, ๋ฐ์ฑ๋ ๊ธฐ๋ณธ ํ์ ์ ์ ํจํ์ง ์์ ๊ฐ(null)์ ๊ฐ์ง ์ ์๋ค.
- ๊ธฐ๋ณธ ํ์ ์ด ๋ฐ์ฑ๋ ๊ธฐ๋ณธ ํ์ ๋ณด๋ค ์๊ฐ๊ณผ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ฉด์์ ๋ ํจ์จ์ ์ด๋ค.
// ๋ฌธ์ ๊ฐ ์๋ ์ฝ๋1
Comparator<Integer> naturalOrder = (i, j) -> (j < j) ? -1 : (i == j ? 0 : 1);
naturalOrder.compare(new Integer(42), new Integer(42)); // 1
// TMI
naturalOrder.compare(Integer.valueOf(42), Integer.valueOf(42)); // 0
naturalOrder.compare(Integer.valueOf(123456789), Integer.valueOf(123456789)); // 1
์ฒซ ๋ฒ์งธ ๊ฒ์ฌ(i < j)์์๋ i์ j๊ฐ ์ฐธ์กฐํ๋ ์คํ ๋ฐ์ฑ๋ Integer ์ธ์คํด์ค๋ ๊ธฐ๋ณธ ํ์
๊ฐ์ผ๋ก ๋ณํ๋์ด ์ ๋์ํ๋ค.
๋ ๋ฒ์งธ ๊ฒ์ฌ(i == j)์์ ๋ '๊ฐ์ฒด ์ฐธ์กฐ'์ ์๋ณ์ฑ์ ๊ฒ์ฌํ๊ฒ ๋์ด ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ค.
i์ j๊ฐ ์๋ก ๋ค๋ฅธ Integer ์ธ์คํด์ค๋ผ์ ๋น๊ต ๊ฒฐ๊ณผ๊ฐ false๊ฐ ๋๊ณ , comparator๋ 1์ ๋ฆฌํดํ๋ค.
๋ฐ์ฑ๋ ๊ธฐ๋ณธ ํ์
์ == ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ๋ฉด ๋๊ฐ ๋ด๊ฐ ์ํ์ง ์๋ ๋ฐฉํฅ์ผ๋ก ๊ฐ๊ฒ ๋๋ค.
๊ธฐ๋ณธ ํ์ ์ ๋ค๋ฃจ๋ Comparator๊ฐ ํ์ํ๋ค๋ฉด Comparator.NaturalOrder()๋ฅผ ์ฌ์ฉํ์
List<Integer> values = Arrays.asList(212, 324, 435, 566, 133, 100, 121);
values.sort(Comparator.naturalOrder()); // 100, 121, 133, 212, 324, 435, 566 (์ค๋ฆ์ฐจ์)
// ๋ฌธ์ ๋ฅผ ์์ ํ Comparator
Comparator<Integer> naturalOrder = (iBoxed, jBoxed) -> {
int i = iBoxed, j = jBoxed; // ์คํ ๋ฐ์ฑ
return i < j ? -1 : (i == j ? 0 : 1);
}
// ๋ฌธ์ ๊ฐ ์๋ ์ฝ๋2
public class Unbelievable {
static Integer i;
public static void main(String[] args) {
if (i == 42)
System.out.println("Unbelievable");
}
}
i == 42๋ฅผ ๊ฒ์ฌํ ๋ NullPointerException์ ๋์ง๋ค. ์์ธ์ int๊ฐ ์๋๋ผ Integer์ธ i์ ์ด๊น๊ฐ์ด null์ด๋ผ๋ ๋ฐ ์๋ค.
i == 42์์ Integer์ int๋ฅผ ๋น๊ตํ๊ฒ ๋๊ณ , ๊ฑฐ์ ์์ธ ์์ด ๊ธฐ๋ณธ ํ์
๊ณผ ๋ฐ์ฑ๋ ๊ธฐ๋ณธ ํ์
์ ํผ์ฉํ ์ฐ์ฐ์์๋ ๋ฐ์ฑ๋ ๊ธฐ๋ณธ ํ์
์ ๋ฐ์ฑ์ด ์๋์ผ๋ก ํ๋ฆฐ๋ค.
๊ทธ๋ฆฌ๊ณ null ์ฐธ์กฐ๋ฅผ ์ธ๋ฐ์ฑํ๋ฉด NullPointerException์ด ๋ฐ์ํ๋ค.
// ํด๊ฒฐ
static int i;
// ๋ฌธ์ ๊ฐ ์๋ ์ฝ๋3
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์ ๋ฐ์ฑ๋ ๊ธฐ๋ณธ ํ์ ์ผ๋ก ์ ์ธํ์ฌ for๋ฌธ์ ๋ฐ๋ณต ํ์๋งํผ ๋ฐ์ฑ์ด ์ผ์ด๋ ์ฑ๋ฅ์ด ๋๋ ค์ง๋ค.
- ์ปฌ๋ ์
์ ์์, ํค, ๊ฐ
- ๋งค๊ฐ๋ณ์ํ ํ์
์ด๋ ๋งค๊ฐ๋ณ์ํ ๋ฉ์๋์ ํ์
๋งค๊ฐ๋ณ์๋ก๋ ๋ฐ์ฑ๋ ๊ธฐ๋ณธ ํ์
์ ์จ์ผ ํ๋ค(Java๊ฐ ํ์
๋งค๊ฐ๋ณ์๋ก ๊ธฐ๋ณธ ํ์
์ ์ง์ํ์ง ์๋๋ค).
- E.g.
Threadlocal<int> // ๋ถ๊ฐ๋ฅ Threadlocal<Integer> // ๊ฐ๋ฅ
- E.g.
- ๋งค๊ฐ๋ณ์ํ ํ์
์ด๋ ๋งค๊ฐ๋ณ์ํ ๋ฉ์๋์ ํ์
๋งค๊ฐ๋ณ์๋ก๋ ๋ฐ์ฑ๋ ๊ธฐ๋ณธ ํ์
์ ์จ์ผ ํ๋ค(Java๊ฐ ํ์
๋งค๊ฐ๋ณ์๋ก ๊ธฐ๋ณธ ํ์
์ ์ง์ํ์ง ์๋๋ค).
- ๋ฆฌํ๋ ์ ์ ํตํ ๋ฉ์๋ ํธ์ถํ ๋
- ๊ฐ๋ฅํ๋ฉด ๋ฐ์ฑ๋ ๊ธฐ๋ณธ ํ์ ๋ณด๋ค ๋ ๊ฐ๋จํ๊ณ ๋น ๋ฅธ ๊ธฐ๋ณธ ํ์ ์ ์ฌ์ฉํ๋ผ.
- ์คํ ๋ฐ์ฑ์ด ๋ฐ์ฑ๋ ๊ธฐ๋ณธ ํ์ ์ ์ฌ์ฉํ ๋์ ๋ฒ๊ฑฐ๋ก์์ ์ค์ฌ์ฃผ์ง๋ง, ๊ทธ ์ํ๊น์ง ์์ ์ฃผ์ง ์์ผ๋ ์ฃผ์ํด์ ์ฌ์ฉํ์.
- ์ฃผ์ํด์ผ ํ ์ฌํญ
- ๋ ๋ฐ์ฑ๋ ๊ธฐ๋ณธ ํ์ ์ == ์ฐ์ฐ์๋ก ๋น๊ตํ๋ค๋ฉด ์๋ณ์ฑ ๋น๊ต๊ฐ ์ด๋ค์ง๊ณ , ์ด๋ ์ํ๋ ๋ฐฉํฅ์ด ์๋ ๊ฐ๋ฅ์ฑ์ด ํฌ๋ค.
- ๊ฐ์ ์ฐ์ฐ์์ ๊ธฐ๋ณธ ํ์ ๊ณผ ๋ฐ์ฑ๋ ๊ธฐ๋ณธ ํ์ ์ ํผ์ฉํ๋ฉด ์ธ๋ฐ์ฑ์ด ์ด๋ค์ง๋ฉฐ, null ์ฐธ์กฐ๋ฅผ ์ธ๋ฐ์ฑํ๋ฉด NullpointerException์ด ๋ฐ์ํ๋ค.
- ๊ธฐ๋ณธ ํ์ ์ ๋ฐ์ฑํ๋ ์์ ์ '๋ถํ์ํ ๊ฐ์ฒด ์์ฑ'์ ํ๋ ๋ถ์์ฉ์ด ๋ฐ์ํ ์ ์๋ค.