57. ์ง์ญ๋ณ์์ ๋ฒ์๋ฅผ ์ต์ํํ๊ธฐ
์ง์ญ๋ณ์์ ์ ํจ ๋ฒ์๋ฅผ ์ต์๋ก ์ค์ฌ ์ฝ๋ ๊ฐ๋ ์ฑ๊ณผ ์ ์ง๋ณด์์ฑ์ ๋์ด๊ณ ์ค๋ฅ ๊ฐ๋ฅ์ฑ์ ๋ฎ์ถ์
๐ ๊ทธ ๋ฐฉ๋ฒ์ "๊ฐ์ฅ ์ฒ์ ์ฐ์ผ ๋ ์ ์ธํ๊ธฐ" & ๋ฉ์๋๋ฅผ ์๊ฒ ์ ์งํ๊ณ ํ ๊ฐ์ง ๊ธฐ๋ฅ์ ์ง์คํ๊ธฐ
โณ๏ธ ์ง์ญ๋ณ์๋ฅผ ๋ฏธ๋ฆฌ ์ ์ธํด๋๋ฉด...?
- ๋ฏธ๋ฆฌ ์ ์ธํด๋๋ฉด ์ฝ๋๊ฐ ์ด์์ ํด์ ธ ๊ฐ๋ ์ฑ์ด ๋จ์ด์ง
- ๋ณ์๋ฅผ ์ค์ ๋ก ์ฌ์ฉํ๋ ์์ ์๋ ํ์ ๊ณผ ์ด๊น๊ฐ์ด ๊ธฐ์ต๋์ง ์์ ์ ์์
๐ ๊ฑฐ์ ๋ชจ๋ ์ง์ญ๋ณ์๋ ์ ์ธ๊ณผ ๋์์ ์ด๊ธฐํํด์ผ ํจ
๋ง์ฝ, ์ด๊ธฐํ์ ํ์ํ ์ ๋ณด๊ฐ ์ถฉ๋ถํ์ง ์๋ค๋ฉด ์ถฉ๋ถํด์ง ๋๊น์ง ์ ์ธ์ ๋ฏธ๋ค์ผ ํจ
๋ค๋ง try-catch ๋ฌธ์์๋ ์์ธ์ธ๋ฐ, ๋ณ์๋ฅผ ์ด๊ธฐํํ๋ ํํ์์์ ๊ฒ์ฌ ์์ธ๋ฅผ ๋์ง ๊ฐ๋ฅ์ฑ์ด ์๋ค๋ฉด try ๋ธ๋ก ์์์ ์ด๊ธฐํํด์ผ ํจ
๐ ๊ทธ๋ ์ง ์์ ์ ์์ธ๊ฐ ๋ธ๋ก์ ๋์ด ๋ฉ์๋์๊น์ง ์ ํ๋จ
๋ณ์ ๊ฐ์ try ๋ธ๋ก ๋ฐ๊นฅ์์๋ ์ฌ์ฉํด์ผํ๋ค๋ฉด try ๋ธ๋ก ์์์ ์ ์ธํด์ผ ํจ
public class Example {
public static void main(String[] args) {
int result; // try ๋ธ๋ก ๋ฐ๊นฅ์์ ์ ์ธ (๋ธ๋ก ๋ฐ๊นฅ์์ ์ฌ์ฉํด์ผ ํ๋ฏ๋ก)
try {
result = divide(10, 2); // ์ด๊ธฐํ ์ค ์์ธ ๋ฐ์ ๊ฐ๋ฅ
System.out.println("Result: " + result);
} catch (ArithmeticException e) {
result = 0; // ์์ธ ๋ฐ์ ์ ๊ธฐ๋ณธ๊ฐ์ผ๋ก ์ด๊ธฐํ
System.err.println("Cannot divide by zero. Defaulting result to: " + result);
}
// result๋ ์ฌ๊ธฐ์๋ ์ฌ์ฉํ ์ ์์
System.out.println("Final Result: " + result);
}
private static int divide(int a, int b) {
return a / b; // b๊ฐ 0์ผ ๊ฒฝ์ฐ ArithmeticException ๋ฐ์
}
}
โณ๏ธ ๋ฐ๋ณต ๋ณ์์ ๊ฐ์ ๋ฐ๋ณต๋ฌธ์ด ์ข ๋ฃ๋ ๋ค์๋ ์จ์ผํ๋ ์ํฉ์ด ์๋๋ผ๋ฉด while๋ฌธ๋ณด๋ค๋ for๋ฌธ ์ฐ๊ธฐ !
- ๋ฐ๋ณต์(Iterator)๋ฅผ ์ฌ์ฉํด์ผํ๋ ์ํฉ(๋ฐ๋ณต์์ remove ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค๊ฑฐ๋..)์ด๋ผ๋ฉด for-each๋ฌธ ๋์ ์ ํต์ ์ธ for๋ฌธ์ ์ฐ๋ ๊ฒ์ด ๋์
for(Iterator<Element> i = c.iterator(); i.hasNext(); ) {
Element e = i.next();
}
- while๋ฌธ ์ฌ์ฉ ์ ํ๋ก๊ทธ๋จ ์ค๋ฅ ๋ฐ์ ๊ฐ๋ฅ
Iterator<Element> i = c.iterator();
while(i.hasNext()) {
doSomething(i.next());
}
...
Iterator<Element> i2 = c2.iterator();
while(i.hasNext()) { // ๋ฒ๊ทธ ๋ฐ์
doSomething(i2.next());
}
๐ ๋ ๋ฒ์งธ while๋ฌธ์์ ๋ง์ฝ i์ ์ ํจ๋ฒ์๊ฐ ์์ง ๋๋์ง ์์๋ค๋ฉด ์์ ์ฝ๋๋ ์ปดํ์ผ๋ ์ ๋๊ณ , ์คํ ์ ์์ธ๋ ๋์ง์ง ์๋๋ค. ํ์ง๋ง c2๋ฅผ ์ํํ์ง ์๊ณ ๋๋๋ฏ๋ก c2๊ฐ ๋น์ด์๋ค๊ณ ์ฐฉ๊ฐํ ์ ์๋ค..๐ฅฒ
๋ง์ฝ for๋ฌธ์ ์ฌ์ฉํ๋ฉด ์ค๋ฅ๋ฅผ ์ปดํ์ผ ํ์์ ์ก์์ฃผ๋ฏ๋ก for๋ฌธ์ ์ฌ์ฉํ๋ ๊ฒ์ด ๋ ๋ซ๋ค !
for(Iterator<Element> i = c.iterator(); i.hasNext(); ) {
Element e = i.next();
...
}
...
// i๋ฅผ ์ฐพ์ ์ ์๋ค๋ ์ปดํ์ผ ์ค๋ฅ ๋ฐ์
for(Iterator<Element> i2 = c2.iterator(); i.hasNext(); ) {
Element e2 = i2.next();
...
}
58. ์ ํต์ ์ธ for๋ฌธ๋ณด๋ค๋ for-each ๋ฌธ ์ฌ์ฉํ๊ธฐ
for-each๋ฌธ์ ๋ช ๋ฃํ๊ณ , ์ ์ฐํ๊ณ , ๋ฒ๊ทธ๋ฅผ ์๋ฐฉํด์ฃผ๋ฉฐ ์ฑ๋ฅ ์ ํ๋ ์๋ค.
๊ฐ๋ฅํ ๋ชจ๋ ๊ณณ์์๋ for-each๋ฌธ์ ์ฌ์ฉํ์ !
for(Element e : elements) {
...
}
- ๋ฐ๋ณต์์ ์ธ๋ฑ์ค ๋ณ์๋ฅผ ์ฌ์ฉํ์ง ์์ผ๋ฏ๋ก ์ฝ๋๊ฐ ๊น๋ํด์ง๊ณ ์ค๋ฅ ๋ฐ์ ๊ฐ๋ฅ์ฑ๋ ์ค์ด๋ฆ
- ์ปฌ๋ ์ ์ ์ค์ฒฉํด ์ํํด์ผ ํ๋ค๋ฉด ๋์ฑ for-each๊ฐ ๋์
for(Iterator<Suit> i = suits.iterator(); i.hasNext(); ) {
Suit suit = i.next();
for(Iterator<Rank> j = ranks.iterator(); j.hasNext(); ) {
deck.add(new Card(suit, j.next()));
}
}
// ์ปฌ๋ ์
์ด๋ ๋ฐฐ์ด์ ์ค์ฒฉ ๋ฐ๋ณต
for(Suit suit : suits)
for(Rank rank : ranks)
deck.add(new Card(suit, rank));
โณ๏ธ for-each ๋ฌธ์ ์ฌ์ฉํ ์ ์๋ ์ํฉ
- ํ๊ดด์ ์ธ ํํฐ๋ง : ์ปฌ๋ ์
์ ์ํํ๋ฉด์ ์ ํ๋ ์์๋ฅผ ์ ๊ฑฐํด์ผ ํ๋ค๋ฉด ๋ฐ๋ณต์์ remove ๋ฉ์๋ ํธ์ถํด์ผ ํจ
๐ ์๋ฐ 8๋ถํฐ Collection์ removeIf ๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ ์ปฌ๋ ์ ์ ๋ช ์์ ์ผ๋ก ์ํ X - ๋ณํ : ๋ฆฌ์คํธ๋ ๋ฐฐ์ด์ ์ํํ๋ฉด์ ๊ทธ ์์์ ๊ฐ ์ผ๋ถ ๋๋ ์ ์ฒด๋ฅผ ๊ต์ฒดํด์ผ ํ๋ค๋ฉด ๋ฆฌ์คํธ์ ๋ฐ๋ณต์๋ ๋ฐฐ์ด์ ์ธ๋ฑ์ค๋ฅผ ์ฌ์ฉํด์ผ ํจ
- ๋ณ๋ ฌ ๋ฐ๋ณต : ์ฌ๋ฌ ์ปฌ๋ ์ ์ ๋ณ๋ ฌ๋ก ์ํํด์ผ ํ๋ค๋ฉด ๊ฐ๊ฐ์ ๋ฐ๋ณต์์ ์ธ๋ฑ์ค ๋ณ์๋ฅผ ์ฌ์ฉํด ์๊ฒฉํ๊ณ ๋ช ์์ ์ผ๋ก ์ ์ดํด์ผ ํจ
๐ ์์ ์ธ ๊ฐ์ง ์ํฉ์์๋ ์ผ๋ฐ์ ์ธ for๋ฌธ์ ์ฌ์ฉํ๋ฉด ๋๋ค.
59. ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ตํ๊ณ ์ฌ์ฉํ๊ธฐ
- ํต์ฌ์ ์ธ ์ผ๊ณผ ํฌ๊ฒ ๊ด๋ จ ์๋ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋๋ผ ์๊ฐ ํ๋นํ์ง ์์๋ ๋จ
- ๋ฐ๋ก ๋ ธ๋ ฅํ์ง ์์๋ ์ฑ๋ฅ์ด ์ง์ํด์ ๊ฐ์ ๋จ
- ๊ธฐ๋ฅ์ด ์ ์ ๋ง์์ง
- ์์ฑํ ์ฝ๋๊ฐ ๋ง์ ์ฌ๋์๊ฒ ๋ฏ์ต์ ์ฝ๋๊ฐ ๋จ ๐ ๋ ์ฝ๊ธฐ ์ข๊ณ , ์ ์ง๋ณด์ํ๊ธฐ ์ข๊ณ , ์ฌํ์ฉํ๊ธฐ ์ฌ์ด ์ฝ๋๊ฐ ๋จ
โณ๏ธ ์๋ฉด ์ข์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
- java.lang
- java.util
- java.util.concurrent ๐ ๋ฉํฐ์ค๋ ๋ ํ๋ก๊ทธ๋๋ฐ ์์ ์ ๋จ์ํํด์ฃผ๋ ๊ณ ์์ค์ ํธ์ ๊ธฐ๋ฅ ์ ๊ณต
- java.io
- ์ปฌ๋ ์ ํ๋ ์์ํฌ
- ์คํธ๋ฆผ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
60. ์ ํํ ๋ต์ด ํ์ํ๋ค๋ฉด float์ double์ ํผํ๊ธฐ
BigDecimal์ด ์ ๊ณตํ๋ 8๊ฐ์ง ๋ฐ์ฌ๋ฆผ ๋ชจ๋๋ฅผ ์ด์ฉํด ๋ฐ์ฌ๋ฆผ์ ์๋ฒฝํ ์ ์ด
๐ ๋ค๋ง ์ฝ๋ฉ ์์ ๋ถํธํจ๊ณผ ์ฑ๋ฅ ์ ํ ๊ฐ์ํด์ผ ํจ
์ฑ๋ฅ์ด ์ค์ํ๊ณ ์์์ ์ ์ง์ ์ถ์ ํ ์ ์์ผ๋ฉฐ ์ซ์๊ฐ ๋๋ฌด ํฌ์ง ์๋ค๋ฉด int๋ long ์ฌ์ฉ
๐ 9์๋ฆฌ ์ญ์ง์๋ก ํํํ ์ ์๋ค๋ฉด int, 18์๋ฆฌ ์ญ์ง์๋ก ํํํ ์ ์๋ค๋ฉด long, 18์๋ฆฌ๋ฅผ ๋์ด๊ฐ๋ฉด BigDecimal
- float๊ณผ double ํ์
์ ๊ธ์ต ๊ด๋ จ ๊ณ์ฐ๊ณผ ๋ง์ง ์์
- 1.03๋ฌ๋ฌ - 42์ผํธ = 1.03-0.42 = 0.6100000000000001 ๐ ๋ถ๋์์ ํ์ ์ฌ์ฉ
- ๊ธ์ต๊ณ์ฐ์๋ BigDecimal, int ๋๋ long ์ฌ์ฉํด์ผ ํจ
- ๋ค๋ง, BigDecimal์ ํจ์ฌ ๋ถํธํ๊ณ ๋๋ฆผ
int, long์ ๊ฐ์ ํฌ๊ธฐ๊ฐ ์ ํ๋๊ณ ์์์ ์ ์ง์ ๊ด๋ฆฌํด์ผ ํจ
'Java > ๐ Effective Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๐ Effective Java] ์ผ๋ฐ์ ์ธ ํ๋ก๊ทธ๋๋ฐ ์์น ไธญ (0) | 2024.11.20 |
---|---|
[๐Effective Java] ์ด๊ฑฐ ํ์ ๊ณผ ์ด๋ ธํ ์ด์ ไธ (1) | 2024.11.18 |
[๐ Effective Java] ์ด๊ฑฐ ํ์ ๊ณผ ์ด๋ ธํ ์ด์ ไธ (0) | 2024.11.10 |
[๐ Effective Java] ์ ๋ค๋ฆญ ไธ (0) | 2024.10.12 |
[๐ Effective Java] ํด๋์ค์ ์ธํฐํ์ด์ค ไธ (1) | 2024.10.06 |