๋ชฉ์ฐจ
Java๋ก ํ๋ก๊ทธ๋๋ฐ์ ํ๋ค ๋ณด๋ฉด ๋ค์ํ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ณ ์ฒ๋ฆฌํด์ผ ํ ์ผ์ด ์์ฃผ ์๊น๋๋ค.
ํ์ง๋ง ๊ณ ์ ๋ ํฌ๊ธฐ์ ๋ฐฐ์ด๋ง์ผ๋ก๋ ์ ์ฐํ๊ฒ ๋์ํ๊ธฐ ์ด๋ ต์ฃ .
Java๋ ์ด๋ฐ ํ๊ณ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ์ปฌ๋ ์ ํ๋ ์์ํฌ(Collection Framework)๋ผ๋ ๊ฐ๋ ฅํ ๋๊ตฌ๋ฅผ ์ ๊ณตํฉ๋๋ค.
์ด๋ฒ ๊ธ์์๋ ์ปฌ๋ ์ ํ๋ ์์ํฌ์ ์ ์ฒด ๊ตฌ์กฐ์ ํต์ฌ ์ธํฐํ์ด์ค์ธ List, Set, Map์ ๊ฐ๋ ๊ณผ ์ฐจ์ด์ ์ ์ ๋ฆฌํด๋ณด๊ฒ ์ต๋๋ค.
๐ฆ ์ปฌ๋ ์ ํ๋ ์์ํฌ๋?
์ปฌ๋ ์ ํ๋ ์์ํฌ๋ ์๋ฃ๊ตฌ์กฐ + ์๊ณ ๋ฆฌ์ฆ + ํ์คํ๋ ์ธํฐํ์ด์ค๋ฅผ ํตํฉํ Java์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์งํฉ์ ๋๋ค.
๋ฐฐ์ด๋ณด๋ค ํจ์ฌ ์ ์ฐํ๊ณ ๊ฐ๋ ฅํ ๊ตฌ์กฐ๋ฅผ ์ ๊ณตํ๋ฉฐ, ๋ค์๊ณผ ๊ฐ์ ์ฅ์ ์ ๊ฐ์ง๋๋ค
- ๋์ ํฌ๊ธฐ ์กฐ์ : ๋ฐํ์์ ํฌ๊ธฐ๋ฅผ ์ ์ฐํ๊ฒ ๋ณ๊ฒฝ ๊ฐ๋ฅ
- ๋ด์ฅ ์๊ณ ๋ฆฌ์ฆ ์ ๊ณต: ์ ๋ ฌ, ๊ฒ์ ๋ฑ์ ์๊ณ ๋ฆฌ์ฆ์ด ์ด๋ฏธ ๊ตฌํ๋์ด ์์
- ์ผ๊ด๋ ์ธํฐํ์ด์ค: ๋ค์ํ ๊ตฌํ์ฒด๋ฅผ ๋์ผํ ๋ฐฉ์์ผ๋ก ์ฒ๋ฆฌ ๊ฐ๋ฅ
- ๊ฒ์ฆ๋ ์๋ฃ๊ตฌ์กฐ ์ฌ์ฌ์ฉ: ์์ ์ฑ๊ณผ ์์ฐ์ฑ ํฅ์
์ปฌ๋ ์ ํ๋ ์์ํฌ์ ๊ตฌ์ฑ ์์๋ ๋ค์๊ณผ ๊ฐ์ด ๋๋ฉ๋๋ค
๊ตฌ์ฑ ์์ | ์ค๋ช |
์ธํฐํ์ด์ค | List, Set, Map ๋ฑ ํต์ฌ ๊ท์ฝ ์ ์ |
๊ตฌํ ํด๋์ค | ArrayList, HashSet, HashMap ๋ฑ ๊ธฐ๋ฅ ์ ๊ณต |
์ ํธ๋ฆฌํฐ ํด๋์ค | Collections, Arrays ๋ฑ์ ํตํ ์ ๋ ฌ/๋ณต์ฌ/๊ฒ์ ์ง์ |
๐ ๊ณตํต ์ธํฐํ์ด์ค ๊ตฌ์กฐ
์ปฌ๋ ์ ์ ์๋์ ๊ฐ์ ๊ณ์ธต ๊ตฌ์กฐ๋ฅผ ๋ฐ๋ฆ ๋๋ค
Collection (์ต์์ ์ธํฐํ์ด์ค)
โโโ List (์์๊ฐ ์๊ณ ์ค๋ณต ํ์ฉ)
โ โโโ ArrayList
โ โโโ LinkedList
โ โโโ Vector
โโโ Set (์ค๋ณต ํ์ฉํ์ง ์์)
โ โโโ HashSet
โ โโโ LinkedHashSet
โ โโโ TreeSet
โโโ Queue (FIFO ๊ตฌ์กฐ)
โโโ LinkedList
โโโ PriorityQueue
Map (๋ณ๋ ์ธํฐํ์ด์ค - Key-Value ์)
โโโ HashMap
โโโ LinkedHashMap
โโโ TreeMap
๐ก Map์ Collection ์ธํฐํ์ด์ค๋ฅผ ์์ํ์ง ์๊ณ ๋ ๋ฆฝ์ ์ผ๋ก ๊ตฌ์ฑ๋ฉ๋๋ค.
๐งฉ List, Set, Map ๊ฐ๋ ๋น๊ต
๐ List
- ์์ ์์, ์ค๋ณต ํ์ฉ
- ์ธ๋ฑ์ค๋ฅผ ํตํ ์ ๊ทผ ๊ฐ๋ฅ
- ๋์ ํฌ๊ธฐ ์กฐ์
- ๋ํ ๊ตฌํ์ฒด: ArrayList, LinkedList
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Apple"); // ์ค๋ณต ํ์ฉ
System.out.println(list.get(0)); // "Apple" (์ธ๋ฑ์ค๋ก ์ ๊ทผ)
System.out.println(list.size()); // 3
๐ Set
- ์ค๋ณต ํ์ฉ X
- ์์ ๋ฏธ๋ณด์ฅ (๊ตฌํ์ฒด์ ๋ฐ๋ผ ๋ค๋ฆ)
- ์ธ๋ฑ์ค ์ ๊ทผ ๋ถ๊ฐ
- ์งํฉ ์ฐ์ฐ ๊ฐ๋ฅ (ํฉ์งํฉ, ๊ต์งํฉ ๋ฑ)
- ๋ํ ๊ตฌํ์ฒด: HashSet, TreeSet
Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Apple"); // ์ค๋ณต - ์ถ๊ฐ๋์ง ์์
System.out.println(set.size()); // 2 (์ค๋ณต ์ ๊ฑฐ๋จ)
// set.get(0); // ์ค๋ฅ! Set์ ์ธ๋ฑ์ค ์ ๊ทผ ๋ถ๊ฐ
๐๏ธ Map
- Key-Value ์์ผ๋ก ์ ์ฅ
- Key๋ ์ค๋ณต ๋ถ๊ฐ, Value๋ ์ค๋ณต ๊ฐ๋ฅ
- ๋น ๋ฅธ ๊ฒ์ ์ฑ๋ฅ
- ๋ํ ๊ตฌํ์ฒด: HashMap, TreeMap
Map<String, Integer> map = new HashMap<>();
map.put("Apple", 1000);
map.put("Banana", 1500);
map.put("Apple", 1200); // ๊ธฐ์กด ๊ฐ ์
๋ฐ์ดํธ
System.out.println(map.get("Apple")); // 1200
โ๏ธ ์ฃผ์ ํน์ง ๋น๊ต
ํน์ฑ |
List | Set | Map |
์ค๋ณต ํ์ฉ | โ | โ | Key: โ, Value: โ |
์์ ์ ์ง | โ | ๊ตฌํ์ฒด์ ๋ฐ๋ผ ๋ค๋ฆ | ๊ตฌํ์ฒด์ ๋ฐ๋ผ ๋ค๋ฆ |
์ธ๋ฑ์ค ์ ๊ทผ | โ | โ | โ (Key๋ก ์ ๊ทผ) |
์ฃผ์ ๊ตฌํ์ฒด | ArrayList, LinkedList | HashSet, TreeSet | HashMap, TreeMap |
์ฌ์ฉ ๋ชฉ์ | ์์ฐจ ๋ฐ์ดํฐ, ์ธ๋ฑ์ฑ | ์ค๋ณต ์ ๊ฑฐ, ๊ณ ์ ๋ฐ์ดํฐ ๊ด๋ฆฌ | ๋น ๋ฅธ ์กฐํ, ์ฐ๊ด ๋ฐ์ดํฐ ์ ์ฅ |
์ ๊ทผ ๋ฐฉ์ | ์ธ๋ฑ์ค(index)๋ก ์ ๊ทผ | Iterator๋ก ์ ๊ทผ | key๋ก value ์กฐํ |
๐ ์ธ์ ์ด๋ค ์ธํฐํ์ด์ค๋ฅผ ์จ์ผ ํ ๊น?
List๊ฐ ์ ํฉํ ๊ฒฝ์ฐ
- ๋ฐ์ดํฐ์ ์์๊ฐ ์ค์ํ ๋
- ์ค๋ณต ๋ฐ์ดํฐ๋ฅผ ํ์ฉํด์ผ ํ ๋
- ์ธ๋ฑ์ค๋ฅผ ํตํด ์ง์ ์ ๊ทผํด์ผ ํ ๋
์: ์ฌ์ฉ์ ์์ ์ด๋ ฅ, ์ผํ ์ฅ๋ฐ๊ตฌ๋ ๋ชฉ๋ก
Set์ด ์ ํฉํ ๊ฒฝ์ฐ
- ์ค๋ณต ์๋ ์ ์ผํ ๊ฐ๋ง ์ ์ฅํ๊ณ ์ถ์ ๋
- ์ํ์ ์งํฉ ์ฐ์ฐ์ด ํ์ํ ๊ฒฝ์ฐ
์: ํ๊ทธ ๋ชฉ๋ก, ๋ฐฉ๋ฌธํ ํ์ด์ง ๊ธฐ๋ก
Map์ด ์ ํฉํ ๊ฒฝ์ฐ
- ๋ฐ์ดํฐ๋ฅผ Key-Value ์์ผ๋ก ์ ์ฅํด์ผ ํ ๋
- ๋น ๋ฅธ ๊ฒ์์ด ์ค์ํ ๋
์: ์ฌ์ฉ์ ID → ์ฌ์ฉ์ ์ ๋ณด, ์ํ๋ช → ๊ฐ๊ฒฉ
๐ ๋ง๋ฌด๋ฆฌ
์ด๋ฒ ๊ธ์์๋ Java์ ์ปฌ๋ ์ ํ๋ ์์ํฌ์ ํต์ฌ ์ธํฐํ์ด์ค์ธ List, Set, Map์ ๋ํด ์์๋ณด์์ต๋๋ค.
์ปฌ๋ ์ ํ๋ ์์ํฌ๋ ์๋ฐ ๊ฐ๋ฐ์์ ๊ฐ์ฅ ๊ธฐ๋ณธ์ด ๋๋ ํต์ฌ ๋๊ตฌ์ ๋๋ค.
์ด๋ฐ ์ปฌ๋ ์ ๋ค์ ์ ํ์ฉํ๋ฉด ๋ค์ํ ๋ฐ์ดํฐ๋ฅผ ํจ์จ์ ์ผ๋ก ๊ด๋ฆฌํ๊ณ ์ฒ๋ฆฌํ ์ ์์ต๋๋ค. ํนํ ๋์ฉ๋ ๋ฐ์ดํฐ ์ฒ๋ฆฌ๋ ๋ณต์กํ ๋น์ฆ๋์ค ๋ก์ง ๊ตฌํ์์ ๋งค์ฐ ์ ์ฉํ์ฃ .
ํต์ฌ์ธ List, Set, Map์ ๊ฐ๊ฐ์ ์ฉ๋์ ๋ฐ๋ผ ์ฌ๋ฐ๋ฅด๊ฒ ์ฌ์ฉ๋์ด์ผ ํฉ๋๋ค:
- ๋ฐ์ดํฐ์ ์์๊ฐ ์ค์ํ๊ณ ์ค๋ณต์ ํ์ฉํด์ผ ํ๋ค๋ฉด → List
- ์ค๋ณต ์์ด ๊ณ ์ ํ ๊ฐ๋ง ์ ์ฅํ๊ณ ์ถ๋ค๋ฉด → Set
- ํ๋์ ํค๋ก ๊ฐ์ ์ฐ๊ฒฐํด ์ ์ฅํ๊ณ ์ถ๋ค๋ฉด → Map
๋ค์ ๊ธ์์๋ List์ Set์ ๋ํ ๊ตฌํ์ฒด์ธ ArrayList, LinkedList, HashSet, TreeSet์ ํน์ง๊ณผ ์ฐจ์ด๋ฅผ ๊ตฌ์ฒด์ ์ผ๋ก ๋น๊ตํด๋ณด๊ฒ ์ต๋๋ค.
๊ถ๊ธํ ์ ์ด๋ ๋ ์๊ณ ์ถ์ ๋ด์ฉ์ด ์๋ค๋ฉด ๋๊ธ๋ก ๋จ๊ฒจ์ฃผ์ธ์ ๐
'โจ๏ธ Language > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] HashMap vs TreeMap vs LinkedHashMap, ์ด๋ค ์ํฉ์์ ์จ์ผ ํ ๊น? (1) | 2025.06.11 |
---|---|
[Java] ArrayList vs LinkedList, HashSet vs TreeSet ๋น๊ต (2) | 2025.06.04 |
[Java] Math, Random, Arrays ์ ํธ ํด๋์ค ์์ ์ ๋ฆฌ! (1) | 2025.05.27 |
[Java] Wrapper ํด๋์ค - ๊ธฐ๋ณธํ์ ๊ฐ์ฒด์ฒ๋ผ! (0) | 2025.05.21 |
[Java] String vs StringBuilder vs StringBuffer (0) | 2025.05.20 |