๐ ๋ค์ด๊ฐ๋ฉฐ
๋ชจ๋ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์๋ ๋ฐ์ดํฐ ๊ฐ๋ค์ ๋ค๋ฃจ๊ธฐ ์ํ '์๋ฃ๊ตฌ์กฐ'๊ฐ ์กด์ฌํฉ๋๋ค. ์ปดํจํฐ ๊ณผํ์์์ '์๋ฃ๊ตฌ์กฐ'๋ ํจ์จ์ ์ธ ์ ๊ทผ ๋ฐ ์์ ์ ๊ฐ๋ฅ์ผ ํ๋ ์๋ฃ์ ์กฐ์ง, ๊ด๋ฆฌ, ์ ์ฅ์ ์๋ฏธํ๋ค. ๋ ์ ํํ ๋งํด, ์๋ฃ ๊ตฌ์กฐ๋ ๋ฐ์ดํฐ ๊ฐ์ ๋ชจ์, ๋ ๋ฐ์ดํฐ ๊ฐ์ ๊ด๊ณ, ๊ทธ๋ฆฌ๊ณ ๋ฐ์ดํฐ์ ์ ์ฉํ ์ ์๋ ํจ์๋ ๋ช ๋ น์ ์๋ฏธํ๋ค.
์ค๋ ํด๋น ํฌ์คํ ์์๋ ์๋ฐ ์ธ์ด์์ ์๋ฃ๊ตฌ์กฐ์ ๋ํด ์ดํด๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
๐ ์๋ฐ ์ปฌ๋ ์ ํ๋ ์์ํฌ(Java Collection Framework)
์๋ฐ์์๋ ๋ฐฐ์ด(Array)๋ฅผ ์ฌ์ฉํด์ ๊ฐ์ ์ ์ฅํ๊ณ ํด๋น ๊ฐ๋ค์ ๊ณ์ฐํ ์ ์์ต๋๋ค. ์ด๋ฌํ ๋ฐฐ์ด์ ๊ธฐ๋ณธ ํ์ ๋ฟ๋ง ์๋๋ผ ํด๋์ค ํ์ ์ ๋ฐฐ์ด๋ ๋ง๋ค ์ ์๊ธฐ ๋๋ฌธ์ ๊ฐ์ฒด ์ ์ฅ์๋ก ์ฌ์ฉ๋ ์ ์์ต๋๋ค. ํ์ง๋ง ๋ฐฐ์ด์ ์ ์ธ ์ ์ ํ ํฌ๊ธฐ(์ ์ฅ ์ฉ๋)์ ๋ณ๊ฒฝํ ์ ์๊ณ , ํญ๋ชฉ์ ์ ์ฅ, ์ญ์ , ์ถ๊ฐํ๋ ๋ฉ์๋๊ฐ ์๊ธฐ ๋๋ฌธ์ ์ง์ ์ธ๋ฑ์ค๋ฅผ ์ฌ์ฉํด์ผ ํฉ๋๋ค. ์ด๋ฌํ ๋ถํธํจ๋ค์ ๋ฐฐ์ด์ ์ฌ์ฉํ์ฌ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๊ธฐ ํ๋ค๊ฒ ๋ง๋ค๊ธฐ ๋๋ฌธ์ ์๋ฐ๋ ์ปฌ๋ ์ ํ๋ ์์ํฌ(Collection Framework)๋ฅผ ์ ๊ณตํฉ๋๋ค.
๋๋ฆฌ ์๋ ค์ ธ ์๋ ์๋ฃ๊ตฌ์กฐ(Data Structure)๋ฅผ ์ฌ์ฉํด์ ๊ฐ์ฒด๋ค์ ํจ์จ์ ์ผ๋ก ์ถ๊ฐ, ์ญ์ , ๊ฒ์ํ ์ ์๋๋ก ์ธํฐํ์ด์ค์ ๊ตฌํ ํด๋์ค๋ฅผ java.util ํจํค์ง์์ ์ ๊ณตํฉ๋๋ค. ์ด๋ค์ ์ด์นญํด์ ์ปฌ๋ ์ ํ๋ ์์ํฌ ๋ผ๊ณ ๋ถ๋ฆ ๋๋ค.
์ปฌ๋ ์ : ๊ฐ์ฒด์ ์ ์ฅ
ํ๋ ์์ํฌ : ์ฌ์ฉ ๋ฐฉ๋ฒ์ ์ ํด๋์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
์ค์ ๋ก ์ปฌ๋ ์ ํ๋ ์์ํฌ๋ ์ฌ์ฉ ๋ฐฉ๋ฒ์ ์ ์ํ ์ธํฐํ์ด์ค์ ์ค์ ๊ฐ์ฒด๋ฅผ ์ ์ฅํ๋ ๋ค์ํ ์ปฌ๋ ์ ํด๋์ค (๊ตฌํ ํด๋์ค) ๋ค์ ์ ๊ณตํฉ๋๋ค. ์ปฌ๋ ์ ํ๋ ์์ํฌ์ ์ฃผ์ ์ธํฐํ์ด์ค๋ก List, Set, Map ์ด ์์ต๋๋ค. ์๋์ ๊ทธ๋ฆผ์ ์ด๋ค ์ธํฐํ์ด์ค๋ก ์ฌ์ฉ ๊ฐ๋ฅํ ์ปฌ๋ ์ ํด๋์ค(๊ตฌํ ํด๋์ค)๋ฅผ ๋ณด์ฌ์ค๋๋ค.
๐ List
List ์ปฌ๋ ์ ์ ๋ฐฐ์ด๊ณผ ๋น์ทํ๊ฒ ๊ฐ์ฒด๋ฅผ ์ธ๋ฑ์ค๋ก ๊ด๋ฆฌํฉ๋๋ค. ๋ฐฐ์ด๊ณผ์ ์ฐจ์ด์ ์ ์ ์ฅ ์ฉ๋์ด ์๋์ผ๋ก ์ฆ๊ฐํ๋ฉฐ ๊ฐ์ฒด๋ฅผ ์ ์ฅํ ๋ ์๋ ์ธ๋ฑ์ค๊ฐ ๋ถ์ฌ๋๋ค๋ ๊ฒ์ ๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ถ๊ฐ, ์ญ์ , ๊ฒ์์ ์ํ ๋ค์ํ ๋ฉ์๋๋ค์ด ์ ๊ณต๋ฉ๋๋ค.
- ์ค๋ณต์ด ํ์ฉ๋๋ฉด์ ์ ์ฅ์์๊ฐ ์ ์ง๋๋ ๊ตฌ์กฐ๋ฅผ ์ ๊ณต
- ๊ตฌํ ํด๋์ค๋ก๋ Vector, ArrayList, LinkedList ๊ฐ ์์ผ๋ฉฐ ArrayList๊ฐ ๊ฐ์ฅ ๋๋ฆฌ ์ฌ์ฉ๋ฉ๋๋ค.
์ฃผ์ ๋ฉ์๋๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
List<String> list = ...;
list.add("ํ๊ธธ๋") // ๋งจ ๋์ ๊ฐ์ฒด ์ถ๊ฐ
list.add(1, "๊น์ฒ ์"); // ์ง์ ๋ ์ธ๋ฑ์ค์ ๊ฐ์ฒด ์ฝ์
String str = list.get(1); //์ธ๋ฑ์ค๋ก ๊ฐ์ฒด ๊ฒ์
list.remove(0); // ํด๋น ์ธ๋ฑ์ค์ ๊ฐ์ฒด ์ญ์
list.remove("๊น์ฒ ์"); // ํด๋น ๊ฐ์ฒด ์ญ์
list.size() // ํ์ฌ ์ ์ฅ๋์ด ์๋ ๊ฐ์ฒด ์๋ฅผ ๋ฆฌํดํฉ๋๋ค.
//๋ฆฌ์คํธ ๋ฐ๋ณต๋ฌธ ํ์ฉ
for(int i=0; i<list.size(); i++){
String str = list.get(i);
}
for(String str : list){
}
๐ ArrayList
ArrayList ๋ List ์ธํฐํ์ด์ค์ ๋ํ์ ์ธ ๊ตฌํ ํด๋์ค์ ๋๋ค. ์ค๋ฌด์์๋ ๊ฐ์ฅ ๋ง์ด ์ฐ์ด๋ ๊ตฌํ ํด๋์ค์ ๋๋ค.
List<String> list = new ArrayList<String>();
List<String> list = new ArrayList<>();
๋ ๊ฐ์ ์ฝ๋ ๋ชจ๋ String ์ ์ ์ฅํ๋ ArrayList ๊ฐ์ฒด๋ฅผ ์์ฑํฉ๋๋ค. ๋ค๋ง, ๋๋ฒ์งธ ์ฝ๋ฑ์ ๊ฐ์ด ArrayList์ E ํ์ ํ๋ผ๋ฏธํฐ๋ฅผ ์๋ตํ๋ฉด ์ผ์ชฝ List์ ์ง์ ๋ ํ์ ์ ๋ฐ๋ผ๊ฐ๋ฏ๋ก ์๋์ ๊ฐ์ด ์ฌ์ฉํ๋ ๊ฒ์ ์ถ์ฒ๋๋ฆฝ๋๋ค.
- ArrayList ์ ๊ฐ์ฒด๋ฅผ ์ถ๊ฐํ๋ฉด 0 ๋ฒ ์ธ๋ฑ์ค๋ถํฐ ์ฐจ๋ก๋๋ก ์ ์ฅ๋ฉ๋๋ค.
- ArrayList์์ ํน์ ์ธ๋ฑ์ค์ ๊ฐ์ฒด๋ฅผ ์ ๊ฑฐํ๋ฉด ๋ฐ๋ก ๋ค ์ธ๋ฑ์ค๋ถํฐ ๋ง์ง๋ง ์ธ๋ฑ์ค๊น์ง 1์นธ์ฉ ์์ผ๋ก ๋น๊ฒจ์ง๋๋ค.
- ArrayList์์ ํน์ ์ธ๋ฑ์ค์ ๊ฐ์ฒด๋ฅผ ์ฝ์ ํ๋ฉด ํด๋น ์ธ๋ฑ์ค๋ถํฐ ๋ง์ง๋ง ์ธ๋ฑ์ค๊น์ง ๋ชจ๋ 1์นธ์ฉ ๋ฐ๋ ค๋ฉ๋๋ค.
- โก ์ด๋ก ์ธํด ๊ฐ์ฒด์ ๋น๋ฒํ ์ฝ์ ๊ณผ ์ญ์ ๊ฐ ํ์ํ๋ค๋ฉด LinkedList๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ๋ ์ข์ต๋๋ค.
๐ Vector
Vector๋ ์ฌ์ค ์ด๋ฒ์ ์ปฌ๋ ์ ํ๋ ์์ํฌ๋ฅผ ์ ํด๋ณด๋ฉด์ ์ฒ์ ์๊ฒ ๋์์ต๋๋ค. ๊ทธ๋งํผ ์ค๋ฌด์์๋ ์ ํ์ฉํ์ง ์๋ ๊ฒ ๊ฐ์๋ฐ ๊ทธ๋๋ ํน์ง๋ค์ ๊ฐ๋จํ๊ฒ ์์๋ณด๊ณ ๊ฐ๊ฒ ์ต๋๋ค.
List<E> list = new Vector<E>();
List<E> list = new Vector<>();
ArrayList ์ ๋ค๋ฅธ ์ ์ Vector๋ ๋๊ธฐํ๋ ๋ฉ์๋๋ก ๊ตฌ์ฑ๋์ด ์๊ธฐ ๋๋ฌธ์ ๋ฉํฐ ์ค๋ ๋๊ฐ ๋์์ Vector์ ๋ฉ์๋๋ค์ ์คํํ ์ ์๊ณ , ํ๋์ ์ค๋ ๋๊ฐ ๋ฉ์๋ ์คํ์ ์๋ฃํด์ผ๋ง ๋ค๋ฅธ ์ค๋ ๋๊ฐ ๋ฉ์๋๋ฅผ ์คํํ ์ ์๋ค๋ ๊ฒ์ ๋๋ค. ๊ทธ๋์ ๋ฉํฐ ์ค๋ ๋ ํ๊ฒฝ์์ ์์ ํ๊ฒ ๊ฐ์ฒด๋ฅผ ์ถ๊ฐ, ์ญ์ ํ ์ ์์ต๋๋ค. ์ด๊ฒ์ ์ค๋ ๋ ์์ ํ๋ค๊ณ ํํํฉ๋๋ค.
๐ LinkedList
LinkedList๋ ๋ ๋ค๋ฅธ List์ ๊ตฌํ ํด๋์ค์ด๊ธฐ ๋๋ฌธ์ ArrayList์ ์ฌ์ฉ ๋ฐฉ๋ฒ์ ๋๊ฐ์๋ฐ ๋ด๋ถ ๊ตฌ์กฐ๊ฐ ์์ ํ ๋ค๋ฆ ๋๋ค. ArrayList๋ ๋ด๋ถ ๋ฐฐ์ด์ ๊ฐ์ฒด๋ฅผ ์ ์ฅํด์ ๊ด๋ฆฌํ์ง๋ง LinkedList๋ ์ธ์ ์ฐธ์กฐ๋ฅผ ๋งํฌํด์ ์ฒด์ธ์ด ์ฎ์ธ๊ฒ๊ณผ ๊ฐ์ ํํ๋ก ๊ด๋ฆฌํฉ๋๋ค.
๊ทธ๋ฌ๋ฏ๋ก ํน์ ์ธ๋ฑ์ค์ ๊ฐ์ฒด๋ฅผ ์ ๊ฑฐํ๋ฉด ์๋ค ๋งํฌ๋ง ๋ณ๊ฒฝ๋๊ณ ๋๋จธ์ง ๋งํฌ๋ ๋ณ๊ฒฝ๋์ง ์์ต๋๋ค. ํน์ ์ธ๋ฑ์ค์ ๊ฐ์ฒด๋ฅผ ์ฝ์ ํ ๋์๋ ๋ง์ฐฌ๊ฐ์ง์ ๋๋ค.
List<E> list = new LinkedList<E>();
List<E> list = new LinkedList<>();
์ด๋ก ์ธํด ๋ง์ง๋ง ์ธ๋ฑ์ค๋ถํฐ(์์ฐจ์ ์ผ๋ก) ์ถ๊ฐ ๋๋ ์ญ์ ํ๋ ๊ฒฝ์ฐ๋ ArrayList ๊ฐ ๋น ๋ฅด์ง๋ง, ์ค๊ฐ์ ์ถ๊ฐ, ์ญ์ ํ๋ ๊ฒฝ์ฐ๋ ์๋ค ๋งํฌ ์ ๋ณด๋ง ๋ณ๊ฒฝํ๋ฏ๋ก ๋๋ LinkedList๊ฐ ๋ ๋น ๋ฆ ๋๋ค.
๊ตฌ๋ถ | ์์ฐจ์ ์ผ๋ก ์ถ๊ฐ/์ญ์ | ์ค๊ฐ์ ์ถ๊ฐ/์ญ์ | ๊ฒ์ |
ArrayList | ๋น ๋ฅด๋ค | ๋๋ฆฌ๋ค | ๋น ๋ฅด๋ค |
LinkedList | ๋๋ฆฌ๋ค | ๋น ๋ฅด๋ค | ๋๋ฆฌ๋ค |
๐ Set ์ปฌ๋ ์
Set ์ปฌ๋ ์ ์ List์ ์ ์ฌํ์ง๋ง ์ค๋ณต์ด ํ์ฉ๋์ง ์๊ณ ์ ์ฅ ์์๊ฐ ์ ์ง๋์ง ์์ต๋๋ค.
๊ตฌํ ํด๋์ค๋ก๋ HashSet, LinkedHashSet, EnumSet, TreeSet, CopyOnWriteArraySet ๋ฑ์ด ์์ผ๋ฉฐ HashSet์ด ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋ฉ๋๋ค.
Set<String> set = ...;
set.add("ํ๊ธธ๋"); //๊ฐ์ฒด ์ถ๊ฐ
set.add("๊น์ฒ ์");
set.remove("ํ๊ธธ๋"); //๊ฐ์ฒด ์ญ์
Set ์ปฌ๋ ์ ์ ์ธ๋ฑ์ค๋ก ๊ฐ์ฒด๋ฅผ ๊ฒ์ํด์ ๊ฐ์ ธ์ค๋ ๋ฉ์๋๊ฐ ์๊ณ ์ ์ฒด ๊ฐ์ฒด๋ฅผ ๋์์ผ๋ก ํ ๋ฒ์ฉ ๋ฐ๋ณตํด์ ๊ฐ์ ธ์ค๋ ๋ฐ๋ณต์๋ฅผ ์ ๊ณตํฉ๋๋ค. ๋ฐ๋ณต์๋ Iterator ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ๊ฐ์ฒด๋ฅผ ๋งํ๋๋ฐ, iterator() ๋ฉ์๋๋ฅผ ํธ์ถํ๋ฉด ์ป์ ์ ์์ต๋๋ค.
Set<String> set = ...;
Iterator<String> iterator = set.iterator();
๋ฆฌํด ํ์ | ๋ฉ์๋ | ์ค๋ช |
boolean | hasNext() | ๊ฐ์ ธ์ฌ ๊ฐ์ฒด๊ฐ ์์ผ๋ฉด true๋ฅผ ๋ฆฌํดํ๊ณ ์์ผ๋ฉด false ๋ฅผ ๋ฆฌํดํฉ๋๋ค. |
E | next() | ์ปฌ๋ ์ ์์ ํ๋์ ๊ฐ์ฒด๋ฅผ ๊ฐ์ ธ์ต๋๋ค. |
void | remove() | Set ์ปฌ๋ ์ ์์ ๊ฐ์ฒด๋ฅผ ์ ๊ฑฐํฉ๋๋ค. |
Iterator ์์ ํ๋์ ๊ฐ์ฒด๋ฅผ ๊ฐ์ ธ์ฌ๋๋ next() ๋ฅผ ํตํด ๊ฐ์ ธ์ค๋๋ฐ ๊ฐ์ด ์๋์ง hasNext()๋ก ํ์ธํ๊ณ ๊ฐ์ ธ์ค๋ฉด ์ข์ต๋๋ค.
Set<String> set = ...;
Iterator<String> iterator = set.iterator();
while(iterator.hasNext()){
//String ๊ฐ์ฒด ํ๋๋ฅผ ๊ฐ์ ธ์ด
String str = iterator.next();
}
๐ Map ์ปฌ๋ ์
Map ์ปฌ๋ ์ ์ ํค ์ ๋ฐธ๋ฅ๋ก ๊ตฌ์ฑ๋ Map.Entry ๊ฐ์ฒด๋ฅผ ์ ์ฅํ๋ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๊ณ ์์ต๋๋ค. Entry๋ Map ์ธํฐํ์ด์ค ๋ด๋ถ์ ์ ์ธ๋ ์ค์ฒฉ ์ธํฐํ์ด์ค์ ๋๋ค. ์ฌ๊ธฐ์ ํค์ ๊ฐ์จ ๋ชจ๋ ๊ฐ์ฒด์ ๋๋ค.
ํค๋ ์ค๋ณต ์ ์ฅ๋ ์ ์์ง๋ง ๊ฐ์ ์ค๋ณต ์ ์ฅ๋ ์ ์์ต๋๋ค. ๋ง์ฝ ๊ธฐ์กด์ ์ ์ฅ๋ ํค์ ๋์ผํ ํค๋ก ๊ฐ์ ์ ์ฅํ๋ฉด ๊ธฐ์กด์ ๊ฐ์ ์์ด์ง๊ณ ์๋ก์ด ๊ฐ์ผ๋ก ๋์ฒด๋ฉ๋๋ค.
Map<String, Integer> map = ...;
map.put("ํ๊ธธ๋" , 30); //๊ฐ์ฒด ์ถ๊ฐ
int score = map.get("ํ๊ธธ๋"); //๊ฐ์ฒด ์ฐพ๊ธฐ
map.remove("ํ๊ธธ๋"); //๊ฐ์ฒด ์ญ์
์ ์ฅ๋ ๊ฐ์ฒด๋ฅผ ๋์์ผ๋ก ํ๋์ฉ ์ป๊ณ ์ถ์ ๊ฒฝ์ฐ์๋ ๋๊ฐ์ง ๋ฐฉ๋ฒ์ด ์ฌ์ฉ ๊ฐ๋ฅํฉ๋๋ค.
์ฒซ๋ฒ์งธ๋ keySet() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด๊ณ ๋ ๋ฒ์งธ๋ entrySet() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ๋๋ค.
Map<K, V> map = ...;
Set<K> keySet - map.keySet();
Iterator<K> keyIterator = keySet.iterator();
while(keyIterator.hasNext()){
K key = keyIterator.next();
V value = map.get(key);
}
Set<Map.Entry<K, V>> entrySet = map.entryset();
Iterator<Map.Entry<K, V>> entryIterator = entrySet.iterator();
while(entryIterator.hasNext()){
Map.Entry<K, V> entry = entryIterator.next();
K key = entry.getKey();
V value = entry.getValue();
}
์ฐธ๊ณ : ์ฑ - ํผ์ ๊ณต๋ถํ๋ ์๋ฐ
https://st-lab.tistory.com/142
์๋ฐ [JAVA] - ์๋ฐ ์ปฌ๋ ์ ํ๋ ์์ํฌ (Java Collections Framework)
์๋ง ํ๋ก๊ทธ๋๋ฐ์ ์ ๊ณตํ๋ค๋ฉด '์๋ฃ๊ตฌ์กฐ'๋ผ๋ ๋จ์ด๋ฅผ ๋ค์ด๋ณธ ์ ์ด ์์ ๊ฒ์ด๋ค. ์๋ฃ๊ตฌ์กฐ๋ Data Structure๋ผ๊ณ ํ๋๋ฐ, ์ง์ญํ๋ฉด ๋ฐ์ดํฐ ๊ตฌ์กฐ. ์ข ๋ ์์ธํ๊ฒ ์ค๋ช ํ์๋ฉด '์ผ๋ จ์ ์ผ์ ํ์ ๋ค์
st-lab.tistory.com
'Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Java ์์์ ์์ธ์ฒ๋ฆฌ (0) | 2023.06.03 |
---|---|
[Mockito & JUnit] @Mock ๊ณผ @InjectMock (0) | 2023.03.28 |
[Java] ์ ๊ทผ ์ ํ์๋ ๋ฌด์์ธ๊ฐ (0) | 2023.03.08 |
[Java] extends ์ implements ์ ์ฐจ์ด (0) | 2023.01.10 |
[Java] AtomicInteger ์ฌ์ฉํ๊ธฐ (0) | 2023.01.07 |