Collections Framework
๐กCollections vs. Collection
- Collections : util ํด๋์ค
Collections.sort(list);โ
- Collection : ์ธํฐํ์ด์ค
Collections
์ปฌ๋ ์ ์ ์ํ ๋ฉ์๋(static)๋ฅผ ์ ๊ณต
๐ก ์ ์ฉํ static ๋ฉ์๋๋ฅผ ์ ๊ณตํ๋ ํด๋์ค
- Object : ๊ฐ์ฒด
- Arrays : ๋ฐฐ์ด
- Collections : ์ปฌ๋ ์
List
* ArrayList
์ฐ์์ ์ธ ๋ฐฐ์ด
์ฅ์ : ๊ตฌ์กฐ๊ฐ ๊ฐ๋จํ๊ณ ๋ฐ์ดํฐ๋ฅผ ์ฝ๋ ๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ด(์ ๊ทผ ์๊ฐ, access time)์ด ์งง๋ค.
๋จ์ :
- ํฌ๊ธฐ๋ฅผ ๋ณ๊ฒฝํ ์ ์๋ค.(ํฌ๊ธฐ๋ฅผ ๋ณ๊ฒฝํด์ผ ํ๋ ๊ฒฝ์ฐ ์๋ก์ด ๋ฐฐ์ด์ ์์ฑ ํ ๋ฐ์ดํฐ๋ฅผ ๋ณต์ฌํด์ผํจ.
ํฌ๊ธฐ ๋ณ๊ฒฝ์ ํผํ๊ธฐ ์ํด ์ถฉ๋ถํ ํฐ ๋ฐฐ์ด์ ์์ฑํ๋ฉด, ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ญ๋น๋จ.)
- ๋น์์ฐจ์ ์ธ ๋ฐ์ดํฐ์ ์ถ๊ฐ, ์ญ์ ์ ์๊ฐ์ด ๋ง์ด ๊ฑธ๋ฆฐ๋ค. (๊ทธ๋ฌ๋ ์์ฐจ์ ์ธ ๋ฐ์ดํฐ ์ถ๊ฐ(๋์ ์ถ๊ฐ)์ ์ญ์ (๋๋ถํฐ ์ญ์ )๋ ๋น ๋ฅด๋ค.
* LinkedList
๋ถ์ฐ์์ ๋ฐฐ์ด(์ฐธ์กฐ๋ก ์ด๋ฃจ์ด์ง)
๋ฐฐ์ด๊ณผ ๋ฌ๋ฆฌ ๋งํฌ๋ ๋ฆฌ์คํธ๋ ๋ถ์ฐ์์ ์ผ๋ก ์กด์ฌํ๋ ๋ฐ์ดํฐ๋ฅผ ์ฐ๊ฒฐ(Link)
์ฅ์ : ๋ฐ์ดํฐ ์ญ์ (๋จ ํ ๋ฒ์ ์ฐธ์กฐ ๋ณ๊ฒฝ๋ง์ผ๋ก ๊ฐ๋ฅ), ๋ฐ์ดํฐ ์ถ๊ฐ(ํ ๋ฒ์ Node๊ฐ์ฒด ์์ฑ๊ณผ ๋ ๋ฒ์ ์ฐธ์กฐ๋ณ๊ฒฝ๋ง์ผ๋ก ๊ฐ๋ฅ)
๋จ์ : ์ฐ๊ฒฐ๋ฆฌ์คํธ. ๋ฐ์ดํฐ ์ ๊ทผ์ฑ์ด ๋์จ
๋ฐฐ์ด์ฒ๋ผ ํ ๋ฒ์ ๋ฐ์ดํฐ๋ฅผ ์ ๊ทผํ ์ ์๋ ๊ฒ ์๋. ๋ถ์ฐ์์ ์ด๊ธฐ ๋๋ฌธ์
Doubly Linked List - ์ด์ค ์ฐ๊ฒฐ ๋ฆฌ์คํธ
์ด์ค ์ฐ๊ฒฐ๋ฆฌ์คํธ, ์ ๊ทผ์ฑ ํฅ์
์ฐ๊ฒฐ์ ์๋ค๋ก ํ๊ณ ์์.
๋ฐฐ์ด๋ณด๋ค ์ ๊ทผ์ฑ์ ์ฌ์ ํ ๋ฎ์
Doubly Circular Linked List ์ด์ค ์ํ ์ฐ๊ฒฐ๋ฆฌ์คํธ
์ํ์ผ๋ก ๋์ด ์์ด์ ๋ค์ ๋งจ์์ผ๋ก ๊ฐ ์ ์์
1. ์์ฐจ์ ์ผ๋ก ๋ฐ์ดํฐ ์ถ๊ฐ/์ญ์ - ArrayList๊ฐ ๋น ๋ฆ
2. ๋น์์ฐจ์ ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐ/์ญ์ - LinkendList๊ฐ ๋น ๋ฆ
3. ์ ๊ทผ์๊ฐ(access time) - ArrayList๊ฐ ๋น ๋ฆ
์ธ๋ฑ์ค๊ฐ n์ธ ๋ฐ์ดํฐ์ ์ฃผ์ = ๋ฐฐ์ด์ ์ฃผ์ + n * ๋ฐ์ดํฐ ํ์ ์ ํฌ๊ธฐ
์ปฌ๋ ์ | ์ฝ๊ธฐ(์ ๊ทผ์๊ฐ) | ์ถ๊ฐ / ์ญ์ | ๋น ๊ณ |
ArrayList | ๋น ๋ฅด๋ค | ๋๋ฆฌ๋ค | - ์์ฐจ์ ์ธ ์ถ๊ฐ/์ญ์ ๋ ๋น ๋ฆ - ๋นํจ์จ์ ์ธ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ |
LinkedList | ๋๋ฆฌ๋ค | ๋น ๋ฅด๋ค | ๋ฐ์ดํฐ๊ฐ ๋ง์ ์๋ก ์ ๊ทผ์ฑ์ด ๋จ์ด์ง |
Stack๊ณผ Queue
Iterator, ListIterator, Enumeration
์ปฌ๋ ์ ์ ์ ์ฅ๋ ๋ฐ์ดํฐ๋ฅผ ์ ๊ทผ(์ฝ์ด์ค๊ธฐ)ํ๋๋ฐ ์ฌ์ฉ๋๋ ์ธํฐํ์ด์ค
์ปฌ๋ ์ ์ ์ ์ฅ๋ ์์๋ค์ ์ฝ์ด์ค๋ ๋ฐฉ๋ฒ์ ํ์คํํ ๊ฒ
์ปฌ๋ ์ ์ iterator()๋ฅผ ํธ์ถํด์ iterator๋ฅผ ๊ตฌํํ ๊ฐ์ฒด๋ฅผ ์ป์ด์ ์ฌ์ฉ
ArrayList list = new ArrayList();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
ListIterator it = list.literator(); // 1ํ์ฉ
while(it.hasNext()) { // boolean hasNext() : ์ฝ์ด์ฌ ์์๊ฐ ์๋ ํ์ธ.
System.out.print(it.next()); // Object next() : ์ฝ์ด์จ๋ค.
// ์๋ฐฉํฅ์ผ๋ก ์งํํ๋ฉด์ ์ฝ์ด์จ๋ค.
}
while(it.hasPrevious()) {
System.out.print(it.next());
// ์ญ๋ฐฉํฅ์ผ๋ก ์งํํ๋ฉด์ ์ฝ์ด์จ๋ค.
}
// ๐ก ์ญ์
// Iterator์ remove()๋ ๋จ๋
์ผ๋ก ์ฐ์ผ ์ ์๊ณ , next()์ ๊ฐ์ด ์จ์ผํ๋ค.
// ํน์ ์์น์ ์์๋ฅผ ์ญ์ ํ๋ ๊ฒ์ด ์๋๋ผ ์ฝ์ด ์จ ๊ฒ์ ์ญ์ ํ๋ค.
// next() ํธ์ถ์์ด remove()๋ฅผ ํธ์ถํ๋ฉด, IllgalStateException์ด ๋ฐ์ํ๋ค.
ListIterator it = list.literator(); // Iterator์ ์ฌ์ฌ์ฉ์ด ์๋๋ฏ๋ก,๋ค์ ์ป์ด์์ผ ํ๋ค.(1ํ์ฉ)
ArrayList copy = new ArrayList(5);
while(it.hasNext()) {
copy.add(it.next());
it.remove();
}
Set
HashSet
- Set ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ๊ฐ์ฅ ๋ํ์ ์ธ ์ปฌ๋ ์ ์ด๋ฉฐ, Set ์ธํฐํ์ด์ค์ ํน์ง๋๋ก HashSet์ ์ค๋ณต๋ ์์๋ฅผ ์ ์ฅํ์ง ์๋๋ค.
- ์ ์ฅ์์๋ฅผ ์ ์งํ๊ณ ์ ํ๋ค๋ฉด LinkedHashSet์ ์ฌ์ฉํด์ผ ํ๋ค.
- HashSet์ ๊ฐ์ฒด๋ฅผ ์ ์ฅํ๊ธฐ ์ ์ ๊ธฐ์กด์ ๊ฐ์ ๊ฐ์ฒด๊ฐ ์๋์ง ํ์ธํ๋ค.
๊ฐ์ ๊ฐ์ฒด๊ฐ ์์ผ๋ฉด ์ ์ฅํ๊ณ , ์์ผ๋ฉด ์ ์ฅํ์ง ์๋๋ค.
for(int i = 0; i < objArr.length; i++){
set.add(objArr[i]);
// true/false ์ธ์ง ๊ฒฐ๊ณผ๊ฐ ๋์จ๋ค.์ด๊ฒ์ด ๊ฐ์ ๊ฐ์ฒด๊ฐ ์๋์ง ํ์ธํ๋ ๊ฒ์ด๋ค.
}
system.out.printIn(set);
- boolean add(Object o)๋ ์ ์ฅํ ๊ฐ์ฒด์ equals()์ hashCode()๋ฅผ ํธ์ถํ๋ค.
equals()์ hashCode()๊ฐ ์ค๋ฒ๋ผ์ด๋ฉ๋์ด ์์ด์ผ ํ๋ค.
TreeSet - ๋ฒ์ ํ์, ์ ๋ ฌ
- ์ด์ง ํ์(๊ฒ์) ํธ๋ฆฌ(binary search tree)๋ก ๊ตฌํ. ๋ฒ์ ํ์(from~to)๊ณผ ์ ๋ ฌ์ ์ ๋ฆฌํ๋ค.
- ์ด์ง ํธ๋ฆฌ๋ ๋ชจ๋ ๋ ธ๋๊ฐ ์ต์ 0๊ฐ์์ ์ต๋ 2๊ฐ์ ํ์๋ ธ๋๋ฅผ ๊ฐ๋๋ค. (ํ์๋ ธ๋๊ฐ 2๊ฐ๋ฅผ ๊ฐ์ง ์ ์๊ธฐ ๋๋ฌธ์ ์ด์ง(binary) ํธ๋ฆฌ์ด๋ค.
- ๊ฐ ์์(node)๊ฐ ๋๋ฌด(tree)ํํ๋ก ์ฐ๊ฒฐ(LinkedList์ ๋ณํ)ํ๋ค. (์์ ํ๋ํ๋๋ฅผ node๋ผ๊ณ ํ๋ค.)
- ๋ถ๋ชจ๋ณด๋ค ์์ ๊ฐ์ ์ผ์ชฝ, ํฐ ๊ฐ์ ์ค๋ฅธ์ชฝ์ ์ ์ฅํ๋ค. (์ด๋ฐ ์์๊ฐ ์์ผ๋ฉด, ๊ทธ๋ฅ '์ด์งํธ๋ฆฌ'์ด๋ค.)
๋จ์
- ๋ฐ์ดํฐ๊ฐ ๋ง์ ์ง์๋ก ์ถ๊ฐ/์ญ์ ์ ์๊ฐ์ด ๋ ๊ฑธ๋ฆฐ๋ค.(๋น๊ต ํ์๊ฐ ์ฆ๊ฐํ๊ธฐ ๋๋ฌธ์)
์ฅ์
- ๋์ ๋ฐฐ์ด์ด๋ LinkedList์ ๋นํด ๊ฒ์๊ณผ ์ ๋ ฌ๊ธฐ๋ฅ์ด ๋ ๋ฐ์ด๋๋ค.
๐ก TreeSet์ ์ ์ฅํ ๋ ์ด๋ฏธ ์ ๋ ฌํ๊ธฐ ๋๋ฌธ์ ์์ด์ฌ๋ ๋ฐ๋ก ์ ๋ ฌํ ํ์๊ฐ ์๋ค.
๐ก๋ฐ์ดํฐ ์ ์ฅ ๋น๊ต boolean add(Object o)
- TreeSet์ compare()๋ฅผ ํธ์ถํด์ ๋น๊ต
- HashSet์ equals(), hashCode()๋ก ๋น๊ต
-> ๋น๊ต ๋ฐฉ๋ฒ์ ์์๋ ค ์ฃผ๋ฉด, ์ค๋ฅ๊ฐ ๋ฌ๋ค.
Map
HashMap, Hashtable
- ์์X, ์ค๋ณต(ํคX, ๊ฐO)
๐กํด์ฑ(Hashing)์ด๋
ํด์ํจ์(Hash Function)๋ฅผ ์ด์ฉํ์ฌ ํด์ ํ ์ด๋ธ(Hash Table)์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๋ฐฉ๋ฒ์ด๋ค.
ํด์ฑ์์ ์ฌ์ฉํ๋ ์๋ฃ๊ตฌ์กฐ๋ ๋ฐฐ์ด๊ณผ ๋งํฌ๋๋ฆฌ์คํธ์ ์กฐํฉ์ด๋ฉฐ, ์์ธํ ๋ณด๋ฉด ๋ฐฐ์ด์ ์์์์ ๋งํฌ๋ ๋ฆฌ์คํธ๊ฐ ์ ์ฅ๋์ด ์๋ ๊ตฌ์กฐ์ด๋ค.
๐ก ํด์ ํ ์ด๋ธ(Hash Table)
- ํด์ ํ ์ด๋ธ์ ๋ฐฐ์ด(์ ๊ทผ์ฑ์ด ์ข๋ค)๊ณผ ๋งํฌ๋ ๋ฆฌ์คํธ(๋ณ๊ฒฝ์ ์ ๋ฆฌํ๋ค)๊ฐ ์กฐํฉ๋ ํํ.
- 2์ฐจ์ ๋ฐฐ์ด์ฒ๋ผ ์๊ฒจ์ ํ ์ด๋ธ์ด๋ผ๊ณ ํ๋ค.
- ์๋ ์ด๋ฏธ์ง์์ ์ผ์ชฝ์ด ํจ์จ์ด ์์ข์ ํด์ํ
์ด๋ธ, ์ค๋ฅธ์ชฝ์ด ์ด์์ ์ธ ํด์ํ
์ด๋ธ์ด๋ผ๊ณ ํ ์ ์๋ค.
- ์ค๋ฅธ์ชฝ์ ํด์ํ
์ด๋ธ์ ๋งํฌ๋๋ฆฌ์คํธ๊ฐ ๊ฐ ๋ฐฉ๋ง๋ค 1๊ฐ์ฉ ์๋ ํํ๋ฅผ ๊ฐ์ง๊ธฐ ๋๋ฌธ์, ๊ฒ์์๋๊ฐ ๋งค์ฐ ๋ฐ์ด๋๋ค.
- ์ด๋ฌํ ํด์ํ
์ด๋ธ์ ๊ตฌํํ๊ธฐ ์ํด์ ๊ฐ์ฅ ์ค์ํ ๊ฒ์ ํด์ํจ์์ด๋ค.
- ํด์ํจ์๊ฐ ๊ฐ๊ฐ์ key๋ง๋ค ๋ค๋ฅธ ํด์์ฝ๋๋ฅผ ๋ฐํํ๋๋ก ๊ตฌํํ๋ค๋ฉด, ์ด์์ ์ธ ํด์ํ
์ด๋ธ์ ๊ตฌ์กฐ๋ฅผ ๊ตฌํํ ์ ์์ ๊ฒ์ด๋ค.
๐กํด์ํ ์ด๋ธ์ ์ ์ฅ๋ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ค๋ ๊ณผ์
1. ํค๋ก ํด์ํจ์๋ฅผ ํธ์ถํด์ ํด์์ฝ๋๋ฅผ ์ป๋๋ค.
2. ํด์์ฝ๋(ํด์ํจ์์ ๋ฐํ๊ฐ)์ ๋์ํ๋ ๋งํฌ๋๋ฆฌ์คํธ๋ฅผ ๋ฐฐ์ด์์ ์ฐพ๋๋ค.
3. ๋งํฌ๋๋ฆฌ์คํธ์์ ํค์ ์ผ์นํ๋ ๋ฐ์ดํฐ๋ฅผ ์ฐพ๋๋ค.
** ํด์ํจ์๋ ๊ฐ์ ํน ๋ํด ํญ์ ๊ฐ์ ํด์์ฝ๋๋ฅผ ๋ฐํํด์ผ ํ๋ค.
** ์๋ก ๋ค๋ฅธ ํค์ผ์ง๋ผ๋ ๊ฐ์ ๊ฐ์ ํด์์ฝ๋๋ฅผ ๋ฐํํ ์๋ ์๋ค.
์ฐธ๊ณ : https://kor-shin.github.io/java/hashing/
๐ก๋ฐ์ดํฐ ์ ์ฅ
- List์ Set์ boolean add(Object o)๋ก ์ ์ฅ.
- Map์ Object put(Object key, Object vaule)๋ก ์ ์ฅ.
'๊ณต๋ถ > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] Iterator์ Comparable (0) | 2024.05.21 |
---|---|
[Java] DS vs. ADT (์๋ฃ ๊ตฌ์กฐ vs. ์ถ์ ๋ฐ์ดํฐ ํ์ ) (0) | 2024.05.17 |
[Java] Array ๋น์ทํ ์ฉ์ด ์ ๋ฆฌ(Arrays vs. ArrayList vs. Array vs. List) (0) | 2024.05.17 |
[Java] Object ํด๋์ค (0) | 2024.03.30 |
[Java] ์ ๊ทผ์ ์ด์ public, protected, default, private (0) | 2024.03.29 |