๐ JAVA/์ดํํฐ๋ธ ์๋ฐ

clone ์ฌ์ ์๋ ์ฃผ์ํด์ ์งํํ๋ผ(2) - [3์ฅ. ๋ชจ๋ ๊ฐ์ฒด์ ๊ณตํต ๋ฉ์๋(์์ดํ 13)]
์ด์ ๊ธ์ ํตํด ๋ถ๋ณ ๊ฐ์ฒด์์ clone์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ์์๋ณด์๋ค. ์ด๋ฒ์๋ ๊ฐ๋ณ ๊ฐ์ฒด์์ clone์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ์์๋ณด์. ๊ฐ๋ณ ๊ฐ์ฒด๋ฅผ ๋ณต์ ํ๋ 3๊ฐ์ง ๋ฐฉ๋ฒ์ ์ดํด๋ณด์. 1. ๋ฐฐ์ด ๋ณต์ฌ๋ฅผ ์ด์ฉํ๋ ๊ฒฝ์ฐ ๐จโ๐ public class Stack implements Cloneable{ private Object[] elements; private int size = 0; private static final int DEFAULT_INITIAL_CAPACITY = 16; public Stack() { this.elements = new Object[DEFAULT_INITIAL_CAPACITY]; } public void push(Object e) { ensureCapacity(); elements[..

clone ์ฌ์ ์๋ ์ฃผ์ํด์ ์งํํ๋ผ(1) - [3์ฅ. ๋ชจ๋ ๊ฐ์ฒด์ ๊ณตํต ๋ฉ์๋(์์ดํ 13)]
์ด๋ฒ ๊ธ์์๋ clone์ ์ฌ์ ์ ํ ๋ ์ด๋ค ์ ์ ์ฃผ์ํด์ ์ฌ์ ์ ํด์ผ ํ๋์ง ์์๋ณด๊ณ ์ ํ๋ค. clone์ ๊ธฐ๋ณธ์ ์ธ ์ฌ์ฉ๋ฐฉ๋ฒ๋ณด๋ค๋ ์ฃผ์์ ์ ์ด์ ์ด ๋ง์ถฐ์ ธ ์์ผ๋ฏ๋ก clone์ ๊ธฐ๋ณธ์ ์ธ ์ฌ์ฉ๋ฐฉ๋ฒ์ ์๊ณ ์ถ๋ค๋ฉด ์ด์ ๊ธ์ ์ฐธ๊ณ ํ๊ธฐ ๋ฐ๋๋ค. clone์ ์ฌ์ ์ํ ๋ ํฌ๊ฒ 2๊ฐ์ง ์ํฉ์ผ๋ก ๊ตฌ๋ถํ ์ ์๋ค. ์ฒซ ๋ฒ์งธ๋ ๋ถ๋ณ ๊ฐ์ฒด์์์ clone์ด๊ณ ๋ ๋ฒ์งธ๋ ๊ฐ๋ณ ๊ฐ์ฒด์์์ clone์ด๋ค. ๋จผ์ ๋ถ๋ณ ๊ฐ์ฒด์ clone์ ์ฌ์ ์ํ ๋ ์ฃผ์์ ์ ์ดํด๋ณด๊ณ , ๋ค์ ๊ธ์ ํตํด ๊ฐ๋ณ ๊ฐ์ฒด์ clone์ ์ฌ์ ์ํ ๋ ์ฃผ์์ ์ ์ดํด๋ณด๋๋ก ํ์. 1. clone ๊ท์ฝ ๐ฉโ๐พ clone์ ์ค๋ฒ๋ผ์ด๋ฉํด์ ์ฐ๋ฆฌ๊ฐ ๋ง๋ ํด๋์ค์ ์ฌ์ ์๋ฅผ ํ ๋ ๋ค์๊ณผ ๊ฐ์ ์กฐ๊ฑด(๊ท์ฝ)์ ๋ง์กฑํ๊ฒ ๋ง๋ค์ด์ผ ํ๋ค. ์๋์ 3๊ฐ์ง ๊ท์ฝ์ ๊ธฐ์ตํ๊ณ ์ด๋ป๊ฒ..

toString์ ํญ์ ์ฌ์ ์ํ๋ผ - [3์ฅ. ๋ชจ๋ ๊ฐ์ฒด์ ๊ณตํต ๋ฉ์๋(์์ดํ 12)]
1. toString์ ์ฌ์ ์ ํด์ผ ํ๋ ์ด์ ๐ง 1. Object์ toString ๋ฉ์๋์ ๊ธฐ๋ณธ ํ์ Object์ ๊ธฐ๋ณธ toString ๋ฉ์๋๋ 'ํด๋์ค์ด๋ฆ@16์ง์๋ก ํ์ํ ํด์ฌ์ฝ๋'๋ฅผ ๋ฐํํด ์ค๋ค. test.Test@15db9742์ด ํ๋์ ์์์ด๋ค. ์ด๋ ์ฐ๋ฆฌ๊ฐ ์์ฑํ ํด๋์ค์์ toString์ผ๋ก ๋ฐํ๋ฐ์ ์ ์ ํ ๊ฐ์ ํํ๊ฐ ์๋๋ค. ๋ํ, Object.class์ ์ ์๋ toString์ ์ดํด๋ณด๋ฉด ์๋์ ๋ด์ฉ์ ํ์ธํ ์ ์๋ค. The result should be a concise but informative representation that is easy for a person to read. ๊ฐ๊ฒฐํ๋ฉด์ ์ฌ๋์ด ์ฝ๊ธฐ ์ฌ์ด ํํ์ ์ ์ตํ ์ ๋ณด๋ฅผ ๋ฐํํด๋ผ It is recommended ..

equals๋ฅผ ์ฌ์ ์ํ๋ ค๊ฑฐ๋ hashCode๋ ์ฌ์ ์ํ๋ผ(2) - [3์ฅ. ๋ชจ๋ ๊ฐ์ฒด์ ๊ณตํต ๋ฉ์๋(์์ดํ 11)]
์์์ ์ดํด๋ณธ ๊ฒ์ฒ๋ผ ์ข์ ํด์ ํจ์๋ผ๋ฉด ์๋ก ๋ค๋ฅธ ์ธ์คํด์ค์ ๋ค๋ฅธ ํด์ ์ฝ๋๋ฅผ ๋ฐํํ๋ค. ์ด์์ ์ธ ํด์ ํจ์๋ ์ฃผ์ด์ง (์๋ก ๋ค๋ฅธ) ์ธ์คํด์ค๋ค์ 32๋นํธ ์ ์ ๋ฒ์์ ๊ท ์ผํ๊ฒ ๋ถ๋ฐฐํด์ผ ํ๋ค. ์ด์์ ์๋ฒฝํ๊ฒ ์คํํ๊ธฐ๋ ์ด๋ ต์ง๋ง ๋น์ทํ๊ฒ ๋ง๋ค๊ธฐ๋ ๊ทธ๋ค์ง ์ด๋ ต์ง ์๋ค. ํด๋น ๊ธ์ ํตํด ํด์ ์ฝ๋๋ฅผ ๊ตฌํํ๋ 4๊ฐ์ง ๋ฐฉ๋ฒ๊ณผ ์ฃผ์ ์ฌํญ์ ์์๋ณด์. 1. ์ ํ์ ์ธ hashCode ๊ตฌํ ๐ฅ ํต์ฌ ํ๋ ์ค์ ํ๋๋ฅผ ๊ณจ๋ผ์ hashCode๋ฅผ ๊ตฌํ๋ค. ๊ธฐ๋ณธ ํ์ (primitive type) ํ๋๋ผ๋ฉด ํด๋น ํ์ ์ hashCode๋ผ๋ ๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ ๊ตฌํ๋ฉด ๋๋ค. (Type.hashCode(f)) ์ฐธ์กฐ ํ์ (reference tyep) ํ๋๋ผ๋ฉด ํด๋น ํ์ ์ hashCode๋ฅผ ํธ์ถํด์ ๊ตฌํ๋ค. (Point๋ผ๋ ํ์ ์ ์ฌ์ฉํ..

equals๋ฅผ ์ฌ์ ์ํ๋ ค๊ฑฐ๋ hashCode๋ ์ฌ์ ์ํ๋ผ(1) - [3์ฅ. ๋ชจ๋ ๊ฐ์ฒด์ ๊ณตํต ๋ฉ์๋(์์ดํ 11)]
equals๋ฅผ ์ฌ์ ์ํ ํด๋์ค ๋ชจ๋์์ hashCode๋ ์ฌ์ ์ํด์ผ ํ๋ค. ๊ทธ๋ ์ง ์์ผ๋ฉด hashCode ์ผ๋ฐ ๊ท์ฝ์ ์ด๊ธฐ๊ฒ ๋์ด ํด๋น ํด๋์ค์ ์ธ์คํด์ค๋ฅผ HashMap์ด๋ HashSet ๊ฐ์ ์ปฌ๋ ์ ์ ์์๋ก ์ฌ์ฉํ ๋ ๋ฌธ์ ๋ฅผ ์ผ์ผํฌ ๊ฒ์ด๋ค. ๋ค์์ Object ๋ช ์ธ์์ ๋ฐ์ทํ hashCode์ ๋ํ ๊ท์ฝ์ด๋ค. equals ๋น๊ต์ ์ฌ์ฉ๋๋ ์ ๋ณด๊ฐ ๋ณ๊ฒฝ๋์ง ์์๋ค๋ฉด hashCode๋ ๋งค๋ฒ ๊ฐ์ ๊ฐ์ ๋ฆฌํดํด์ผ ํ๋ค. ์ ๋ณด๊ฐ ๋ณ๊ฒฝ๋๊ฑฐ๋, ์ ํ๋ฆฌ์ผ์ด์ ์ ๋ค์ ์คํํ๋ค๋ฉด ๊ฐ์ด ๋ฌ๋ผ์ง ์ ์๋ค. ๋ ๊ฐ์ฒด์ ๋ํ equals๊ฐ ๊ฐ๋ค๋ฉด, hashCode์ ๊ฐ๋ ๊ฐ์์ผ ํ๋ค. ๋ ๊ฐ์ฒด์ ๋ํ equals๊ฐ ๋ค๋ฅด๋๋ผ๋, hashCode์ ๊ฐ์ ๊ฐ์ ์ ์๋ค. ํ์ง๋ง, ํด์ ํ ์ด๋ธ ์ฑ๋ฅ์ ๊ณ ๋ คํด ๋ค๋ฅธ ๊ฐ์ ๋ฆฌํดํ๋ ๊ฒ์ด ์ข..

equals๋ ์ผ๋ฐ ๊ท์ฝ์ ์ง์ผ ์ฌ์ ์ํ๋ผ(3) - [3์ฅ. ๋ชจ๋ ๊ฐ์ฒด์ ๊ณตํต ๋ฉ์๋(์์ดํ 10)]
์ด๋ฒ ๊ธ์์๋ ์ง๊ธ๊น์ง์ ๋ด์ฉ์ ์ข ํฉํด์ ์์ง์ equals ๋ฉ์๋ ๊ตฌํ ๋ฐฉ๋ฒ๊ณผ ์ฃผ์ ์ฌํญ์ ๋ํด์ ์์๋ณด๊ณ ์ ํ๋ค. 1. equals ๊ตฌํ ๋ฐฉ๋ฒ == ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํด ์ ๋ ฅ์ด ์๊ธฐ ์์ ์ ์ฐธ์กฐ์ธ์ง ํ์ธํ๋ค. instanceof ์ฐ์ฐ์๋ก ์ ๋ ฅ์ด ์ฌ๋ฐ๋ฅธ ํ์ ์ธ์ง ํ์ธํ๋ค. ์ ๋ ฅ์ ์ฌ๋ฐ๋ฅธ ํ์ ์ผ๋ก ํ๋ณํํ๋ค. ์ ๋ ฅ ๊ฐ์ฒด์ ์๊ธฐ ์์ ์ ๋์๋๋ 'ํต์ฌ' ํ๋๋ค์ด ๋ชจ๋ ์ผ์นํ๋์ง ํ๋์ฉ ๊ฒ์ฌํ๋ค. float์ double์ ์ ์ธํ ๊ธฐ๋ณธ ํ์ ํ๋๋ == ์ฐ์ฐ์๋ก ๋น๊ตํ๊ณ , ์ฐธ์กฐ ํ์ ํ๋๋ ๊ฐ๊ฐ์ equals ๋ฉ์๋๋ก, float๊ณผ double ํ๋๋ ๊ฐ๊ฐ ์ ์ ๋ฉ์๋์ธ Float.compare(float, float)์ Double.compare(double, double)๋ก ๋น๊ตํ๋ค. (float์ doubl..

equals๋ ์ผ๋ฐ ๊ท์ฝ์ ์ง์ผ ์ฌ์ ์ํ๋ผ(2) - [3์ฅ. ๋ชจ๋ ๊ฐ์ฒด์ ๊ณตํต ๋ฉ์๋(์์ดํ 10)]
์ด๋ฒ ๊ธ์์๋ equals ๋ฉ์๋๋ฅผ ์ฌ์ ์ํ ๋ ๋ฐ๋์ ์ง์ผ์ผ ํ๋ ์ผ๋ฐ ๊ท์ฝ 5๊ฐ์ง๋ฅผ ์กฐ๊ธ ๋ ์์ธํ ์์๋ณด๊ณ ์ ํ๋ค. 1. ๋ฐ์ฌ์ฑ(reflexivity) A.equals(A) == true ๋ฐ์ฌ์ฑ์ ๋จ์ํ ๋งํ๋ฉด ๊ฐ์ฒด๋ ์๊ธฐ ์์ ๊ณผ ๊ฐ์์ผ ํ๋ค๋ ๋ป์ด๋ค. ์ด ์๊ฑด์ ์ผ๋ถ๋ฌ ์ด๊ธฐ๋ ๊ฒฝ์ฐ๊ฐ ์๋๋ผ๋ฉด ๋ง์กฑ์ํค์ง ๋ชปํ๊ธฐ๊ฐ ๋ ์ด๋ ค์ ๋ณด์ธ๋ค. 2. ๋์นญ์ฑ(symmetry) A.equals(B) = B.equals(A) ๋์นญ์ฑ์ ๋ ๊ฐ์ฒด๋ ์๋ก์ ๋ํ ๋์น ์ฌ๋ถ์ ๋๊ฐ์ด ๋ตํด์ผ ํ๋ค๋ ๋ป์ด๋ค. ๋์๋ฌธ์๋ฅผ ๊ตฌ๋ณํ์ง ์๋ ๋ฌธ์์ด์ ๊ตฌํํ ๋ค์ ํด๋์ค๊ฐ ์๋ค๊ณ ํ์. public final class CaseInsensitiveString { private final String s; public CaseInsens..

equals๋ ์ผ๋ฐ ๊ท์ฝ์ ์ง์ผ ์ฌ์ ์ํ๋ผ(1) - [3์ฅ. ๋ชจ๋ ๊ฐ์ฒด์ ๊ณตํต ๋ฉ์๋(์์ดํ 10)]
๊ผญ ํ์ํ ๊ฒฝ์ฐ๊ฐ ์๋๋ฉด equals๋ฅผ ์ฌ์ ์ํ์ง ๋ง์. equlas ๋ฉ์๋๋ ์ฌ์ ์ํ๊ธฐ ์ฌ์ ๋ณด์ด์ง๋ง ๊ณณ๊ณณ์ ํจ์ ์ด ๋์ฌ๋ฆฌ๊ณ ์์ด์ ์์นซํ๋ฉด ๋์ฐํ ๊ฒฐ๊ณผ๋ฅผ ์ด๋ํ๊ธฐ ๋๋ฌธ์ด๋ค. ์ด๋ฒ ๊ธ์์๋ 'equals๋ฅผ ์ฌ์ ์ ํ์ง ์์๋ ๋๋ 4๊ฐ์ง ์ํฉ'๊ณผ '๋ง์ฝ equals ์ฌ์ ์๋ฅผ ํด์ผ ํ๋ค๋ฉด, ๋ง์กฑํด์ผ ํ๋ 5๊ฐ์ง ๊ท์ฝ'์ ๋ํด์ ์์๋ณผ ๊ฒ์ด๋ค. 1. ์ฌ์ ์ ํ์ง ์์๋ ๋๋ 4๊ฐ์ง ์ํฉ ๐ฉ 1. ๊ฐ ์ธ์คํด์ค๊ฐ ๋ณธ์ง์ ์ผ๋ก ๊ณ ์ ํ ๊ฒฝ์ฐ ๐ด ์ฑ๊ธํค, ENUM ๋ฑ ๊ฐ ์ธ์คํด์ค๊ฐ ๋ณธ์ง์ ์ผ๋ก ๊ณ ์ ํ ๊ฒฝ์ฐ equals๋ฅผ ์ฌ์ ์ ํ์ง ์์๋ ๋๋ค. 2. ์ธ์คํด์ค์ '๋ ผ๋ฆฌ์ ๋์น์ฑ(logical equality)'์ ๊ฒ์ฌํ ์ผ์ด ์๋ ๊ฒฝ์ฐ ๐ด ์ค๊ณ์๊ฐ ๋ ผ๋ฆฌ์ ๋์น์ฑ ๋ฐฉ์์ ์ํ์ง ์๊ฑฐ๋ ์ ์ด์ ํ์ํ์ง ์๋ค๊ณ ํ๋จํ๋ ๊ฒฝ..

try-finally ๋ณด๋ค๋ try-with-resources๋ฅผ ์ฌ์ฉํ๋ผ - [2์ฅ ๊ฐ์ฒด ์์ฑ๊ณผ ํ๊ดด(์์ดํ 9)]
์ ํต์ ์ผ๋ก ์์์ด ์ ๋๋ก ๋ซํ์ ๋ณด์ฅํ๋ ์๋จ์ผ๋ก try-finally๊ฐ ์ฐ์๋ค. ํ์ง๋ง ์๋์ 2๊ฐ์ง ๋ฌธ์ ์ ์ผ๋ก ์ธํด try-with-resources์ ์ฌ์ฉ์ด ๊ถ์ฅ๋๋ค. ๋ณต์์ ์์์ ์ฒ๋ฆฌํ๊ฒ ๋๋ฉด ์ฝ๋๊ฐ ์ง์ ๋ถํด์ง๋ค. ์คํ ์ถ์ ๋ด์ญ์ ์ด์ ์ ์์ธ์ ๊ดํ ์ ๋ณด๋ ๋จ์ง ์๊ฒ ๋์ด, ์ค์ ์์คํ ์์์ ๋๋ฒ๊น ์ ๋ชน์ ์ด๋ ต๊ฒ ํ๋ค. try-with-resources์ ์ฅ์ ๋ค์ ํตํด ํด๋น ๊ธฐ๋ฅ์ ์์๋ณด์. ์ฅ์ 1. ์ฝ๋๋ฅผ ๊ฐ๊ฒฐํ๊ฒ ์์ฑํ ์ ์๋ค. try-finally์ ๊ธฐ๋ณธ๊ตฌ์กฐ๋ ์๋์ ๊ฐ๋ค. static String firstLineOfFile(String path) throws IOException { BufferedReader br = new BufferedReader(new FileReader(p..

finalizer์ cleaner ์ฌ์ฉ์ ํผํ๋ผ - [2์ฅ ๊ฐ์ฒด ์์ฑ๊ณผ ํ๊ดด(์์ดํ 8)]
์๋ฐ๋ finalizer์ cleaner๋ผ๋ ๋ ๊ฐ์ง ๊ฐ์ฒด ์๋ฉธ์๋ฅผ ์ ๊ณตํ๋ค. ํ์ง๋ง ์ฌ๋ฌ ๊ฐ์ง ๋ฌธ์ ์ ์ผ๋ก ์ธํด ์ฌ์ฉ์ด ์์ ๋๋ค. ํด๋น ๊ธ์์ ๋ฌธ์ ์ ๋ค๊ณผ ์ ์ ํ ์ฐ์์์ ๋ํด์ ์์๋ณด์. ๐ข๋ฌธ์ ์ 1. finalizer์ cleaner๋ ์ฆ์ ์ํ๋๋ค๋ ๋ณด์ฅ์ด ์๋ค. finalizer๋ cleaner๋ฅผ ์ผ๋ง๋ ์ ์ํ ์ํํ ์ง๋ ์ ์ ์ผ๋ก ๊ฐ๋น์ง ์ปฌ๋ ํฐ ์๊ณ ๋ฆฌ์ฆ์ ๋ฌ๋ ธ์ผ๋ฉฐ, ์ด๋ ๊ฐ๋น์ง ์ปฌ๋ ํฐ ๊ตฌํ๋ง๋ค ์ฒ์ฐจ๋ง๋ณ์ด๋ค. finalizer๋ cleaner ์ํ ์์ ์ ์์กดํ๋ ํ๋ก๊ทธ๋จ์ ๋์ ๋ํ ๋ง์ฐฌ๊ฐ์ง๋ค. ๐ข๋ฌธ์ ์ 2. finalizer์ cleaner๋ ์คํ๋์ง ์์ ์๋ ์๋ค. ์ด๋ ์ ๊ทผํ ์ ์๋ ์ผ๋ถ ๊ฐ์ฒด์ ๋ธ๋ฆฐ ์ข ๋ฃ ์์ ์ ์ ํ ์ํํ์ง ๋ชปํ ์ฑ ํ๋ก๊ทธ๋จ์ด ์ค๋จ๋ ์๋ ์๋ค๋ ์๊ธฐ๋ค. ๋ฐ๋ผ์ ํ๋ก๊ทธ๋จ..

๋ค ์ด ๊ฐ์ฒด ์ฐธ์กฐ๋ฅผ ํด์ ํ๋ผ - [2์ฅ ๊ฐ์ฒด ์์ฑ๊ณผ ํ๊ดด(์์ดํ 7)]
์๋ฐ์์๋ ๊ฐ๋น์ง ์ปฌ๋ ํฐ๊ฐ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ๋ฅผ ๋์์ค๋ค. ํ์ง๋ง ๊ฐ๋น์ง, ์ปฌ๋ ํฐ๊ฐ ์๋ค๊ณ ํด๋ ๋ฉ๋ชจ๋ฆฌ ๋์๊ฐ ๋ฐ์ํ์ง ์๋ ๊ฒ์ ์๋๋ค. ์ด๋ฒ ๊ธ์์๋ ๋ค ์ด ๊ฐ์ฒด ์ฐธ์กฐ๋ฅผ ํด์ ํ์ฌ ๋ฉ๋ชจ๋ฆฌ ๋์๋ฅผ ๋ฐฉ์งํ ์ ์๋ 3๊ฐ์ง ์ํฉ์ ์์๋ณด๊ณ ์ ํ๋ค. 1. Stack์์์ ๋ฉ๋ชจ๋ฆฌ ๋์ & ํด๊ฒฐ์ฑ public class Stack{ private Object[] elements; private int size = 0; private static final int DEFAULT_INITIAL_CAPACITY = 16; public Stack(){ elements = new Object[DEFAULT_INITIAL_CAPACITY]; } public void push(Object e){ ensureCapacity(); el..

๋ถํ์ํ ๊ฐ์ฒด ์์ฑ์ ํผํ๋ผ - [2์ฅ ๊ฐ์ฒด ์์ฑ๊ณผ ํ๊ดด(์์ดํ 6)]
ํด๋น ์ฅ์์๋ ๋ถํ์ํ๊ฒ ๊ฐ์ฒด ์์ฑ์ ํ๋ 3๊ฐ์ง ๊ฒฝ์ฐ๋ฅผ ๋งํด์ฃผ๊ณ ์๋ค. ํ๋์ฉ ์์๋ณด์. 1. ๋ฌธ์์ด public static void main(String[] args){ String hello1 = "hello"; String hello2 = new String("hello"); String hello3 = "hello"; System.out.println(hello1 == hello2); // false // ๋ค๋ฅธ ์ธ์คํด์ค System.out.println(hello1.equals(hello2)); // true // ๊ฐ์ ๋ฌธ์์ด System.out.println(hello1 == hello3); // true // ๊ฐ์ ์ธ์คํด์ค System.out.println(hello1.equals(hell..