Java Collection Framework
Collection
์ปจํ ์ด๋๋ผ๊ณ ๋ ํ๋ ์ปฌ๋ ์ ์ ๋จ์ํ ์ฌ๋ฌ ์์๋ฅผ ๋จ์ผ ๋จ์๋ก ๊ทธ๋ฃนํํ๋ ๊ฐ์ฒด์ ๋๋ค. ์ปฌ๋ ์ ์ ์ง๊ณ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅ, ๊ฒ์, ์กฐ์ ๋ฐ ์ ๋ฌํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค. ์ปฌ๋ ์ ์ ์ง๊ณ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅ, ๊ฒ์, ์กฐ์ ๋ฐ ์ ๋ฌํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ํฌ์ปค ํธ๋(์นด๋ ๋ชจ์), ๋ฉ์ผ ํด๋(๋ฌธ์ ๋ชจ์) ๋๋ ์ ํ๋ฒํธ๋ถ(์ ํ ๋ฒํธ์ ๋ํ ์ด๋ฆ ๋งคํ)์ ๊ฐ์ ์์ฐ ๊ทธ๋ฃน์ ํ์ฑํ๋ ๋ฐ์ดํฐ ํญ๋ชฉ์ ๋ํ๋ ๋๋ค.
Data structure
์ผ๋ฐ์ ์ผ๋ก ๋ฐ์ดํฐ์ ๋ํ ํจ์จ์ ์ธ ์ ๊ทผ์ ์ํด ์ ํ๋๋ ๋ฐ์ดํฐ ๊ตฌ์ฑ, ๊ด๋ฆฌ ๋ฐ ์ ์ฅ ํ์์ ๋๋ค. ๋ณด๋ค ์ ํํ๊ฒ๋ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ ๋ฐ์ดํฐ ๊ฐ๋ค๊ณผ ๊ทธ๋ค ์ฌ์ด์ ๊ด๊ณ ๋ฐ ๋ฐ์ดํฐ์ ์ ์ฉ๋ ์ ์๋ ๊ธฐ๋ฅ์ด๋ ์ฐ์ฐ์ ์งํฉ์ด๋ค.
What Is a Collections Framework?
์ปฌ๋ ์ ํ๋ ์์ํฌ๋ ์ปฌ๋ ์ ์ ํํํ๊ณ ์กฐ์ํ๊ธฐ ์ํ ํตํฉ ์ํคํ ์ฒ์ ๋๋ค. ๋ชจ๋ ์ปฌ๋ ์ ํ๋ ์์ํฌ์๋ ๋ค์์ด ํฌํจ๋ฉ๋๋ค.
Interfaces: ์ปฌ๋ ์ ์ ๋ํ๋ด๋ ์ถ์ ๋ฐ์ดํฐ ์ ํ์ ๋๋ค. ์ธํฐํ์ด์ค๋ฅผ ์ฌ์ฉํ๋ฉด ์ปฌ๋ ์ ์ ํํ์ ์ธ๋ถ ์ฌํญ๊ณผ ๋ ๋ฆฝ์ ์ผ๋ก ์กฐ์ํ ์ ์์ต๋๋ค. ๊ฐ์ฒด ์งํฅ ์ธ์ด์์ ์ธํฐํ์ด์ค๋ ์ผ๋ฐ์ ์ผ๋ก ๊ณ์ธต ๊ตฌ์กฐ๋ฅผ ํ์ฑํฉ๋๋ค.
Implementations: ์ปฌ๋ ์ ์ธํฐํ์ด์ค์ ๊ตฌ์ฒด์ ์ธ ๊ตฌํ์ ๋๋ค. ๋ณธ์ง์ ์ผ๋ก ์ด๋ค์ ์ฌ์ฌ์ฉ ๊ฐ๋ฅํ ๋ฐ์ดํฐ ๊ตฌ์กฐ์ ๋๋ค.
Algorithms: ์ปฌ๋ ์ ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋ ๊ฐ์ฒด์์ ๊ฒ์ ๋ฐ ์ ๋ ฌ๊ณผ ๊ฐ์ ์ ์ฉํ ๊ณ์ฐ์ ์ํํ๋ ๋ฉ์๋์ ๋๋ค. ์๊ณ ๋ฆฌ์ฆ์ ๋คํ์ฑ(polymorphic)์ด๋ผ๊ณ ํฉ๋๋ค. ์ฆ, ์ ์ ํ ์ปฌ๋ ์ ์ธํฐํ์ด์ค์ ๋ค์ํ ๊ตฌํ์์ ๋์ผํ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค. ๋ณธ์ง์ ์ผ๋ก ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฌ์ฉ ๊ฐ๋ฅํ ๊ธฐ๋ฅ์ ๋๋ค.
ํต์ฌ Collection Interfaces
Collection
Collection ๊ณ์ธต ๊ตฌ์กฐ์ root์ ๋๋ค. Collection์ ์์๋ก ์๋ ค์ง ๊ฐ์ฒด์ ๊ทธ๋ฃน๋๋ค. Collection ์ธํฐํ์ด์ค๋ ๋ชจ๋ collections์ด ๊ตฌํํ๋ ์ต์ ๊ณตํต ์์์ด๋ฉฐ ์ต๋ ์ผ๋ฐ์ฑ์ด ํ์ํ ๋ collections์ ์ ๋ฌํ๊ณ ์กฐ์ํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค. ์ผ๋ถ ์ ํ์ ์ปฌ๋ ์ ์ ์ค๋ณต ์์๋ฅผ ํ์ฉํ๊ณ ์ผ๋ถ๋ ํ์ฉํ์ง ์์ต๋๋ค. ์ผ๋ถ๋ ์ ๋ ฌ๋์ฌ ์๊ณ ์ผ๋ถ๋ ์ ๋ ฌ๋์ฌ ์์ง ์๋ค. Java ํ๋ซํผ์ ์ด ์ธํฐํ์ด์ค์ ์ง์ ์ ์ธ ๊ตฌํ์ ์ ๊ณตํ์ง ์์ง๋ง Set ๋ฐ List์ ๊ฐ์ ๋ณด๋ค ๊ตฌ์ฒด์ ์ธ ํ์ ์ธํฐํ์ด์ค์ ๊ตฌํ์ ์ ๊ณตํฉ๋๋ค.
Set
์ค๋ณต ์์๋ฅผ ํฌํจํ ์ ์๋ ์ปฌ๋ ์ ์ ๋๋ค. ์ด ์ธํฐํ์ด์ค๋ ์ํ์ ์งํฉ ์ถ์ํ๋ฅผ ๋ชจ๋ธ๋งํ๊ณ ํฌ์ปค ํธ๋๋ฅผ ๊ตฌ์ฑํ๋ ์นด๋, ํ์์ ์ผ์ ์ ๊ตฌ์ฑํ๋ ๊ณผ์ ๋๋ ๊ธฐ๊ณ์์ ์คํ๋๋ ํ๋ก์ธ์ค์ ๊ฐ์ ์งํฉ์ ๋ํ๋ด๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
List
์ ๋ ฌ๋ ์ปฌ๋ ์ (์ํ์ค๋ผ๊ณ ๋ ํจ). Lists์๋ ์ค๋ณต ์์๊ฐ ํฌํจ๋ ์ ์์ต๋๋ค. List์ ์ฌ์ฉ์๋ ์ผ๋ฐ์ ์ผ๋ก list์์ ๊ฐ ์์๊ฐ ์ฝ์ ๋๋ ์์น๋ฅผ ์ ํํ๊ฒ ์ ์ดํ ์ ์์ผ๋ฉฐ ์ ์ ์ธ๋ฑ์ค(์์น)๋ก ์์์ ์ก์ธ์คํ ์ ์์ต๋๋ค.
Queue
์ฒ๋ฆฌํ๊ธฐ ์ ์ ์ฌ๋ฌ ์์๋ฅผ ๋ณด์ ํ๋ ๋ฐ ์ฌ์ฉ๋๋ ์ปฌ๋ ์ ์ ๋๋ค. ๊ธฐ๋ณธ Collection operations ์ธ์๋ Queue๋ ์ถ๊ฐ ์ฝ์ , ์ถ์ถ ๋ฐ ๊ฒ์ฌ operations์ ์ ๊ณตํฉ๋๋ค.
Queues์ ์ผ๋ฐ์ ์ผ๋ก ๋ฐ๋์ ๊ทธ๋ฐ ๊ฒ์ ์๋์ง๋ง FIFO(์ ์ ์ ์ถ) ๋ฐฉ์์ผ๋ก ์์๋ฅผ ์ ๋ ฌํฉ๋๋ค. ์์ธ ์ค์๋ ์ ๊ณต๋ comparator ๋๋ ์์์ natural ์์์ ๋ฐ๋ผ ์์๋ฅผ ์ ๋ ฌํ๋ priority queues์ด ์์ต๋๋ค. ์ฌ์ฉ๋ ์์๊ฐ ๋ฌด์์ด๋ queue์ ํค๋๋ remove ๋๋ poll ํธ์ถ์ ์ํด ์ ๊ฑฐ๋๋ ์์์ ๋๋ค. FIFO queue์์ ๋ชจ๋ ์ ์์๋ queue์ ๋์ ์ฝ์ ๋ฉ๋๋ค. ๋ค๋ฅธ ์ข ๋ฅ์ queues์ ๋ค๋ฅธ ๋ฐฐ์น ๊ท์น์ ์ฌ์ฉํ ์ ์์ต๋๋ค. ๋ชจ๋ Queue ๊ตฌํ์ ์์ ์ง์ ์์ฑ์ ์ง์ ํด์ผ ํฉ๋๋ค.
Deque
์ฒ๋ฆฌํ๊ธฐ ์ ์ ์ฌ๋ฌ ์์๋ฅผ ๋ณด์ ํ๋ ๋ฐ ์ฌ์ฉ๋๋ ์ปฌ๋ ์ ์ ๋๋ค. ๊ธฐ๋ณธ Collection operations ์ธ์๋ Deque๋ ์ถ๊ฐ ์ฝ์ , ์ถ์ถ ๋ฐ ๊ฒ์ฌ operations์ ์ ๊ณตํฉ๋๋ค.
Deques๋ FIFO(์ ์ ์ ์ถ) ๋ฐ LIFO(ํ์ ์ ์ถ) ๋ฐฉ์์ ๋ชจ๋ ์ฌ์ฉํ ์ ์์ต๋๋ค. deque์์ ๋ชจ๋ ์ ์์๋ ์์ชฝ ๊ธ์์ ์ฝ์ , ๊ฒ์ ๋ฐ ์ ๊ฑฐ๋ ์ ์์ต๋๋ค.
Map
ํค๋ฅผ ๊ฐ์ ๋งคํํ๋ ๊ฐ์ฒด์ ๋๋ค. Map์๋ ์ค๋ณต ํค๊ฐ ํฌํจ๋ ์ ์์ต๋๋ค. ๊ฐ ํค๋ ์ต๋ ํ๋์ ๊ฐ์ ๋งคํํ ์ ์์ต๋๋ค.
SortedSet
์์๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ์งํ๋ Set์ ๋๋ค. ์ ๋ ฌ์ ํ์ฉํ๊ธฐ ์ํด ๋ช ๊ฐ์ง ์ถ๊ฐ ์์ ์ด ์ ๊ณต๋ฉ๋๋ค.Sorted sets์ ๋จ์ด ๋ชฉ๋ก ๋ฐ ํ์ ๋ชฉ๋ก๊ณผ ๊ฐ์ด naturally ์ ๋ ฌ๋ ์งํฉ์ ์ฌ์ฉ๋ฉ๋๋ค.
SortedMap
์ค๋ฆ์ฐจ์ ํค ์์๋ก ๋งคํ์ ์ ์ง ๊ด๋ฆฌํ๋ Map์ ๋๋ค. ์ด๊ฒ์ SortedSet์ Map ์๋ ๋ก๊ทธ์ ๋๋ค. ์ ๋ ฌ๋ Map์ ์ฌ์ ๋ฐ ์ ํ๋ฒํธ๋ถ์ ๊ฐ์ด ์์ฐ์ค๋ฝ๊ฒ ์ ๋ ฌ๋ ํค/๊ฐ ์ ๋ชจ์์ ์ฌ์ฉ๋ฉ๋๋ค.
๊ตฌ์กฐ

Benefits of the Java Collections Framework
Java ์ปฌ๋ ์ ํ๋ ์์ํฌ๋ ๋ค์๊ณผ ๊ฐ์ ์ด์ ์ ์ ๊ณตํฉ๋๋ค.
ํ๋ก๊ทธ๋๋ฐ ๋ ธ๋ ฅ์ ๊ฐ์: Collections Framework๋ ์ ์ฉํ ๋ฐ์ดํฐ ๊ตฌ์กฐ์ ์๊ณ ๋ฆฌ์ฆ์ ์ ๊ณตํจ์ผ๋ก์จ ํ๋ก๊ทธ๋จ ์๋์ ํ์ํ ๋ฎ์ ์์ค์ "๋ฐฐ๊ด"์ด ์๋ ํ๋ก๊ทธ๋จ์ ์ค์ํ ๋ถ๋ถ์ ์ง์คํ ์ ์๋๋ก ํด์ค๋๋ค.
ํ๋ก๊ทธ๋จ ์๋ ๋ฐ ํ์ง ํฅ์: ์ด ์ปฌ๋ ์ ํ๋ ์์ํฌ๋ ์ ์ฉํ ๋ฐ์ดํฐ ๊ตฌ์กฐ ๋ฐ ์๊ณ ๋ฆฌ์ฆ์ ๊ณ ์ฑ๋ฅ, ๊ณ ํ์ง ๊ตฌํ์ ์ ๊ณตํฉ๋๋ค. ๊ฐ ์ธํฐํ์ด์ค์ ๋ค์ํ ๊ตฌํ์ ์ํธ ๊ตํ ๊ฐ๋ฅํ๋ฏ๋ก ์ปฌ๋ ์ ๊ตฌํ์ ์ ํํ์ฌ ํ๋ก๊ทธ๋จ์ ์ฝ๊ฒ ์กฐ์ ํ ์ ์์ต๋๋ค. ์์ ๋ง์ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ์์ฑํ๋ ๋ฒ๊ฑฐ๋ก์์์ ๋ฒ์ด๋ ํ๋ก๊ทธ๋จ์ ํ์ง๊ณผ ์ฑ๋ฅ์ ๊ฐ์ ํ๋ ๋ฐ ๋ ๋ง์ ์๊ฐ์ ํ ์ ํ ์ ์์ต๋๋ค.
๊ด๋ จ ์๋ APIs ๊ฐ์ ์ํธ ์ด์ฉ์ฑ์ ํ์ฉ: Collection ์ธํฐํ์ด์ค๋ APIs๊ฐ Collection์ ์๋ค๋ก ์ ๋ฌํ๋ ์ ๋ฌธ์ธ์ด์ ๋๋ค. ๋ด ๋คํธ์ํฌ ๊ด๋ฆฌ API๊ฐ ๋ ธ๋ ์ด๋ฆ ๋ชจ์์ ์ ๊ณตํ๊ณ GUI ๋๊ตฌ ํคํธ๊ฐ ์ด ๋จธ๋ฆฌ๊ธ ๋ชจ์์ ์์ํ๋ ๊ฒฝ์ฐ API๋ ๋ ๋ฆฝ์ ์ผ๋ก ์์ฑ๋์๋๋ผ๋ ์ํํ๊ฒ ์ํธ ์ด์ฉ๋ฉ๋๋ค.
์๋ก์ด APIs๋ฅผ ๋ฐฐ์ฐ๊ณ ์ฌ์ฉํ๊ธฐ ์ํ ๋ ธ๋ ฅ ๊ฐ์: ๋ง์ API๋ ์์ฐ์ค๋ฝ๊ฒ ์ ๋ ฅ์ ๋ํ ์ปฌ๋ ์ ์ ๊ฐ์ ธ์ ์ถ๋ ฅ์ผ๋ก ์ ๊ณตํฉ๋๋ค. ๊ณผ๊ฑฐ์๋ ์ด๋ฌํ ๊ฐ API์ ์ปฌ๋ ์ ์กฐ์์ ์ ๋ดํ๋ ์์ ํ์ API๊ฐ ์์์ต๋๋ค. ์ด๋ฌํ ์์ ์ปฌ๋ ์ ํ์ API ๊ฐ์๋ ์ผ๊ด์ฑ์ด ๊ฑฐ์ ์์๊ธฐ ๋๋ฌธ์ ์ฒ์๋ถํฐ ํ๋์ฉ ๋ฐฐ์์ผ ํ๊ณ ์ฌ์ฉํ ๋ ์ค์ํ๊ธฐ ์ฌ์ ์ต๋๋ค. ํ์ค collection ์ธํฐํ์ด์ค๊ฐ ๋ฑ์ฅํ๋ฉด์ ๋ฌธ์ ๊ฐ ์ฌ๋ผ์ก์ต๋๋ค.
์๋ก์ด API ์ค๊ณ ๋ ธ๋ ฅ ๊ฐ์: ๋์์ด๋์ ๊ตฌํ์๋ ์ปฌ๋ ์ ์ ์์กดํ๋ API๋ฅผ ๋ง๋ค ๋๋ง๋ค ๋ฐํด๋ฅผ ์ฌ๋ฐ๋ช ํ ํ์๊ฐ ์์ต๋๋ค. ๋์ ํ์ค ์ปฌ๋ ์ ์ธํฐํ์ด์ค๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
์ํํธ์จ์ด ์ฌ์ฌ์ฉ ์ด์ง: ํ์ค ์ปฌ๋ ์ ์ธํฐํ์ด์ค๋ฅผ ์ค์ํ๋ ์๋ก์ด ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ ๋ณธ์ง์ ์ผ๋ก ์ฌ์ฌ์ฉ์ด ๊ฐ๋ฅํฉ๋๋ค. ์ด๋ฌํ ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋ ๊ฐ์ฒด์์ ์๋ํ๋ ์๋ก์ด ์๊ณ ๋ฆฌ์ฆ๋ ๋ง์ฐฌ๊ฐ์ง์ ๋๋ค.
ArrayList VS Vector
synchronization
no
synchronized
size growth
increases only by half of its length
doubles its size
iteration
can only use Iterator
can use iterator and Enumeration
performance
faster
slower(due to synchronization)
framework
Collections
legacy class
Arrays VS Collection
1
๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ ๊ณ ์ ๋์ด ์์ผ๋ฏ๋ก ์ผ๋จ ๋ฐฐ์ด์ ๋ง๋ค๋ฉด ์๊ตฌ ์ฌํญ์ ๋ฐ๋ผ ๋๋ฆฌ๊ฑฐ๋ ์ค์ผ ์ ์์ต๋๋ค.
์ปฌ๋ ์ ์ ์ฐ๋ฆฌ์ ์๊ตฌ ์ฌํญ์ ๋ฐ๋ผ ๋ณธ์ง์ ์ผ๋ก ํ์ฅ ํ ์ ์์ต๋๋ค. ํฌ๊ธฐ๋ฅผ ๋๋ฆฌ๊ฑฐ๋ ์ค์ผ ์ ์์ต๋๋ค.
2
๊ธฐ๋ณธ ์ ํ(boolean, byte, short, int, long ๋ฑ)๊ณผ ๊ฐ์ฒด ์ ํ์ ๋ชจ๋ ๋ณด์ ํ ์ ์์ต๋๋ค.
๊ฐ์ฒด ์ ํ๋ง ๋ณด์ ํ ์ ์์
3
๋ฐฐ์ด์๋ ๊ธฐ๋ณธ ๋ฐ์ดํฐ ๊ตฌ์กฐ๊ฐ ์์ต๋๋ค. ์๋ฐ์์ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ก ์ฌ์ฉ๋๋ ๋ฐฐ์ด ์์ฒด์ ๋๋ค.
๋ชจ๋ Collection ํด๋์ค์๋ ๊ธฐ๋ณธ ๋ฐ์ดํฐ ๊ตฌ์กฐ๊ฐ ์์ต๋๋ค.
4
๋ฐฐ์ด์๋ ์ ํธ๋ฆฌํฐ ๋ฉ์๋๊ฐ ์์ต๋๋ค
๋ชจ๋ Collection์ ์ ํธ๋ฆฌํฐ ๋ฉ์๋๋ฅผ ์ ๊ณตํฉ๋๋ค.
Why Collection ?
๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ ๊ณ ์ ๋์ด ์์ผ๋ฉฐ ๊ฐ๋ฐ ๋จ๊ณ์์๋ ํญ์ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ์ ์ํ ์ ์์ต๋๋ค. ์๊ตฌ ์ฌํญ์ ๋ฐ๋ผ ํฌ๊ธฐ๋ฅผ ๋๋ ค์ผ ํฉ๋๋ค. ์ปฌ๋ ์ ์ ํฌ๊ธฐ๊ฐ ๊ณ ์ ๋์ด ์์ง ์๊ณ ํ์ฅ ๊ฐ๋ฅํฉ๋๋ค(์ต๋ ํฌ๊ธฐ์ ๋๋ฌํ๋ฉด ํฌ๊ธฐ๊ฐ ์ฆ๊ฐํจ).
๋ฐฐ์ด์ ํ ๊ฐ์ง ์ ํ์ ์์๋ง ๋ณด์ ํ ์ ์์ต๋๋ค. ์ปฌ๋ ์ ์ ๋ค์ํ ์ ํ์ ์์๋ฅผ ๋ณด์ ํ ์ ์์ต๋๋ค.
์ ๋ ฌ, ๊ฒ์ ๋ฑ์ ์ํ ๋ฐฐ์ด์ ๊ธฐ๋ณธ ๋ฉ์๋ ์ง์์ ์์ง๋ง ์ปฌ๋ ์ ์๋ ๊ธฐ๋ณธ ์ ํธ๋ฆฌํฐ ๋ฉ์๋ ์ง์์ด ์์ด ๊ฐ๋ฐ์๊ฐ ํธ๋ฆฌํ๊ฒ ์ฌ์ฉํ ์ ์์ต๋๋ค. ์ฝ๋ฉ ์๊ฐ์ด ๋จ์ถ๋ฉ๋๋ค.
์๊ฐ ๋ณต์ก๋
ArrayList VS LinkedList
Add/remove element in the beginning
O(n)
O(1)
Add/remove element in the middle
O(n)
O(1)
Add/remove element in the end
O(1)
O(1)
Get i-th element (random access)
O(1)
O(n)
Find element
O(n), O(log(n)) if sorted
O(n)
Traversal order
์ฝ์ ๋ ๋๋ก
์ฝ์ ๋ ๋๋ก
Set์ ๊ตฌํ์ฒด
Add element
amoritize O(1)
amoritize O(1)
O(log(n))
O(1)
Remove element
amoritize O(1)
amoritize O(1)
O(log(n))
O(1)
Find Element
O(1)
O(1)
O(log(n))
O(1)
Traversal order
๋ฌด์์, ํด์ ํจ์์ ์ํด ํฉ์ด์ง
์ฝ์ ๋ ๋๋ก
์์ ๋น๊ต ๊ธฐ์ค์ ๋ฐ๋ผ ์ ๋ ฌ๋จ
enum ๊ฐ์ ์ ์ ์์์ ๋ฐ๋ผ
Map์ ๊ตฌํ์ฒด
Add element
amoritize O(1)
amoritize O(1)
O(log(n))
O(1)
Remove element
amoritize O(1)
amoritize O(1)
O(log(n))
O(1)
Find element
O(1)
O(1)
O(log(n))
O(1)
Traversal order
๋ฌด์์, ํด์ ํจ์์ ์ํด ํฉ์ด์ง
์ฝ์ ๋ ๋๋ก
์์ ๋น๊ต ๊ธฐ์ค์ ๋ฐ๋ผ ์ ๋ ฌ๋จ
enum ๊ฐ์ ์ ์ ์์์ ๋ฐ๋ผ
Reference
https://github.com/JaeYeopHan/Interview_Question_for_Beginner/tree/master/Java#collection
https://www.baeldung.com/java-arraylist-vs-vector
https://www.geeksforgeeks.org/difference-between-arrays-and-collection-in-java/
https://en.wikipedia.org/wiki/Data_structure
https://www.baeldung.com/java-choose-list-set-queue-map
https://docs.oracle.com/javase/tutorial/collections/intro/index.html
Last updated
Was this helpful?