์๋ฐ์ ๋ชจ๋ ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ ๋ฆฌํ ๊ฒ์ ์๋๊ณ , ์ฃผ๋ก ์ฌ์ฉํ๊ฒ ๋๋ ํด๋์ค์ ์ธํฐํ์ด์ค ์์ฃผ๋ก ์์ ๊ด๊ณ๋ฅผ ๊ทธ๋ ค๋ดค๋ค. (ํ๋ฆด ์๋ ์์) ํ์ด๋ผ์ดํธ ํ ์๋ฃ๊ตฌ์กฐ๋ง ์กฐ๊ธ ๋ ๋ค๋ค๋ณด๋ ค๊ณ ํ๋ค.
๋น์ฐํ์ง๋ง ํด๋์ค๋ ๊ธฐ๋ณธ ์๋ฃํ์ด ์๋๋ฏ๋ก, ์์ ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํด ํจํค์ง๋ฅผ ์ถ๊ฐํด์ผ ํ๋ค. ๋ชจ๋ java.util ํจํค์ง ํ์์ ์กด์ฌํ๋ค.
import java.util.*;
Array
๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ์๋ฃ๊ตฌ์กฐ ํด๋์ค
๋ฐฐ์ด์ ์ ๋ ฌ, ์ด์ง ํ์, ๋ฆฌ์คํธ ๋ณํ ๋ฑ์ method๋ฅผ ์ง์ํ๋ค.
Array์ sort()๋ Dual Pivot ํต ์ ๋ ฌ์ ์ฌ์ฉํ๋ค. (๋ด๊ฐ ์ง์ ๊ตฌํํ๋๊ฒ๋ณด๋ค ํจ์ฌ ์ฑ๋ฅ์ด ์ข๋ค๋ ๋ป์ด๋ค.)
asList()๋ Array๋ฅผ List๋ก ๋ณํํ๋ method์ด๋ค. ๊ทธ๋ฌ๋ ์ ๊ทผ ๊ฐ๋ฅํ ArrayList๊ฐ ์๋๋ผ ์กฐํ๋ง ๊ฐ๋ฅํ ์ ์ ๋ฆฌ์คํธ ํด๋์ค๋ฅผ ๋ฆฌํดํ๋ค.
List
Collection(object ์งํฉ ์ธํฐํ์ด์ค)๊ณผ Iterable(๋ฐ๋ณต์)๋ฅผ implementํ๋ ์ธํฐํ์ด์ค
๊ตฌํ ํด๋์ค๋ก๋ AbstractList, AbstractSequentialList, ArrayList, AttributeList, CopyOnWritArrayList, LinkedList, RoleList, RoleUnresolvedList, Stack, Vector๊ฐ ์๋ค.
List ๊ตฌํ์ฒด์ ๋๋ถ๋ถ์ ์ ํํ์์ ์ฌ์ฉํ๋ค. ํจ์จ์ด ๊ทธ๋ฆฌ ์ข์ง ์๋ค.
List๋ ์ฐธ์กฐ ์๋ฃํ(ํด๋์ค)์ ์งํฉ์ด๋ค. ๋ฐ๋ผ์ ๊ธฐ๋ณธ์๋ฃํ์ ํ์ ์ผ๋ก ๋ฐ์ ์ ์๋ค.
List<Integer> list; // O
List<int> list; // X
List๋ ์ค๋ณต์ ํ์ฉํ๋ค. ๊ฐ์ ์ฃผ์๋ฅผ ์ฐธ์กฐํ๋ ์์๋ฅผ ์ค๋ณตํ์ฌ ๋ฆฌ์คํธ์ ์ถ๊ฐํ ์ ์๋ค.
List<Integer> list = new ArrayList<Integer>();
list.add(0); // ์ฒซ๋ฒ์งธ ์์
list.add(0); // ๋๋ฒ์งธ ์์
ArrayList
List์ ๊ตฌํ ํด๋์ค
ํฌ๊ธฐ ์กฐ์ ์ด ๊ฐ๋ฅํ๋ฉฐ, ์์๋ก null์ ํ์ฉํ๋ค.
*๊ตฌ์กฐ์ ๋ณ๊ฒฝ์ด ๋๊ธฐํ๋์ง ์๋๋ค. ๋ค์ค ์ ๊ทผ์ด ํ์ํ ํ๊ฒฝ์์๋ ์ธ๋ถ์์ ๋๊ธฐํ ์์ ์ ํด์ฃผ๊ฑฐ๋, wrapper๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค.
*๊ตฌ์กฐ์ ๋ณ๊ฒฝ์ด๋, ๋ฆฌ์คํธ์ ์์๊ฐ ์ถ๊ฐ/์ญ์ ๋๋ ๋ฑ ๋ฆฌ์คํธ์ ํฌ๊ธฐ๊ฐ ๋ณํ๋ ์์ ์ ์๋ฏธํ๋ค. ์์์ ๊ฐ ๋ณ๊ฒฝ์ ๊ตฌ์กฐ์ ๋ณ๊ฒฝ์ด ์๋๋ค.
List<> list = Collections.synchronizedList(new ArrayList<>());
Stack
Last-In-First-Out
Vector ํด๋์ค์ ํ์ฅ: ํฌ๊ธฐ ์กฐ์ ์ด ๊ฐ๋ฅํ๋ฉฐ, ๊ตฌ์กฐ์ ๋ณ๊ฒฝ์ด ๋๊ธฐํ๋๋ค.
<์คํ์ ๋ํ์ ์ธ method>
stack.push(E item); // return item
stack.pop(); // return item, ์คํ์ด ๋น ๊ฒฝ์ฐ ์์ธ์ฒ๋ฆฌ
stack.peek(); // return item, ์คํ์ด ๋น ๊ฒฝ์ฐ ์์ธ์ฒ๋ฆฌ
stack.isEmpty(); // return boolean
stack.search(Object o); // return int(์์น), -1์ ํด๋น ์์ ์์
Stack์ ์ค๋ณต์ ํ์ฉํ๋ค.
Stack ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ ๊ฒ๋ณด๋ค, Deque์ ์ฌ์ฉํ์ฌ LIFO ์คํ์ ๊ตฌํํ๋ ๊ฒ์ด ๋ ์์ ์ ์ด๋ค.
Deque<T> stack = new ArrayDeque<T>();
Priority Queue
๋ด๋ถ ๊ท์น์ ๋ฐ๋ผ ์ ๋ ฌ๋๋ Heap ๊ตฌ์กฐ
PriorityQueue<T> pq = new PriorityQueue<>
(
new Comparator<T> {
// Item์ T ์๋ฃํ์ ๋น๊ต๊ฐ
public int compare(Item i1, Item i2){
return (i1.val == i2.val)?
Integer.compare(i1.val2, i2.val2):Integer.compare(i1.val, i2.val);
}
}
);
์ค๋ณต์ ํ์ฉํ๊ณ , null์ ํ์ฉํ์ง ์๋๋ค.
๋๊ธฐํ๋ฅผ ์ง์ํ์ง ์๋๋ค. ๋ฉํฐ ์ค๋ ๋ ํ๊ฒฝ์์ PQ์ ์ ๊ทผํ๋ ๊ฒฝ์ฐ, thread-safe ํ PriorityBlockingQueue ํด๋์ค๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค.
HashMap
Key-Value ์์ ์ ์ฅํ๋ ์๋ฃ๊ตฌ์กฐ
๋น์ ๋ ฌ, ์ค๋ณต ๋นํ์ฉ
Key์ Value์ null์ ํ์ฉ
๊ตฌ์กฐ์ ๋ณ๊ฒฝ์ ๋๊ธฐํ๋ฅผ ์ง์ํ์ง ์์ผ๋ฏ๋ก wrapper method๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค.
Map map = Collections.synchronizedMap(new HashMap<>());
Set
์ค๋ณต ๋นํ์ฉ, ํ๋์ null๋ง ํ์ฉ
TreeSet
- Set์ ๊ตฌํ ํด๋์ค๋ก ์ ๋ ฌ๋จ
HashSet
- Set์ ๊ตฌํ ํด๋์ค๋ก ์ ๋ ฌ๋์ง ์์
์ฐธ๊ณ ์๋ฃ
๐ฅ Array, ArrayList, List ๊ตฌํํ๋ฉด์ ๋งจ๋ ๋๊ฐ์ ๋ถ๋ถ ๊น๋จน์ ์ด์ ๊ฐ ์ด ๋ถ๋ถ ์ ๋ฆฌ๋ฅผ ์ ํด์์๋ค. ์์ผ๋ก๋ ํท๊ฐ๋ฆฌ์ง ๋ง์
'๐ ํ์ต๊ณผ ๊ฐ๋ฐ ๊ธฐ๋ก > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] Array๋ฅผ List<>๋ก ๋ฐ๊พธ๊ธฐ (0) | 2022.03.11 |
---|---|
[Java] ์ ๋ฐ์ดํฐ ํ์ (0) | 2022.03.11 |
[Java] ์ถ์ํด๋์ค, ์ธํฐํ์ด์ค (0) | 2021.07.02 |