ํฐ์คํ ๋ฆฌ ๋ทฐ
๐ List ์ปฌ๋ ์ ํด๋์ค
Collection ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ๋ชจ๋ List ์ปฌ๋ ์ ํด๋์ค๋ ๋ค์๊ณผ ๊ฐ์ ํน์ง์ ๊ฐ์ง๋๋ค.
1. ์์์ ์ ์ฅ ์์๊ฐ ์ ์ง๋๋ค.
2. ๊ฐ์ ์์์ ์ค๋ณต ์ ์ฅ์ ํ์ฉํ๋ค.
โ ๋ํ์ ์ธ List ์ปฌ๋ ์ ๋ฆฌ์คํธ์ ์ํ๋ ํด๋์ค
1. ArrayList<E>
2. LinkedList<E>
3. Vector<E>
4. Stack<E>
๐ ArrayList<E> ํด๋์ค
ArrayList ํด๋์ค๋ ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋๋ ์ปฌ๋ ์ ํด๋์ค ์ค ํ๋์ ๋๋ค.
์ฆ, ArrayList ํด๋์ค ์ญ์๋ Collection ์ธํฐํ์ด์ค๋ฅผ ์์๋ฐ์ ๊ตฌํ์ฒด์ด๋ค.
๊ทธ๋์ ๋ฐ๋ก Collection ์ธํฐํ์ด์ค์ ์ ์ธ๋์ด ์๋ ๋ฉ์๋๋ฅผ ๋ฐ๋ก ์ฌ์ฉ๊ฐ๋ฅํ๋ค.
ArrayList ํด๋์ค๋ ๋ฐฐ์ด์ ์ด์ฉํ๊ธฐ ๋๋ฌธ์ ์ธ๋ฑ์ค๋ฅผ ์ด์ฉํด ๋ฐฐ์ด ์์์ ๋น ๋ฅด๊ฒ ์ ๊ทผํ ์ ์์ต๋๋ค.
ํ์ง๋ง ๋ฐฐ์ด์ ์ฒ์๋ถํฐ ํฌ๊ธฐ๋ฅผ ์ง์ ํ๊ธฐ ๋๋ฌธ์ ํฌ๊ธฐ๋ฅผ ๋ณ๊ฒฝํ ์ ์๋ ์ธ์คํด์ค์ด๋ฏ๋ก
๋ง์ฝ ํฌ๊ธฐ๋ฅผ ๋๋ฆฌ๊ธฐ ์ํด์๋ ์๋ก์ด ๋ฐฐ์ด์ ์์ฑํ๊ณ ๊ธฐ์กด์ ์์๋ค์ ์ฎ๊ฒจ์ผ ํ๋ ๋ณต์กํ ๊ณผ์ ์ ๊ฑฐ์ณ์ผ ํฉ๋๋ค.
๋ฌผ๋ก ์ด ๊ณผ์ ์ ์๋์ผ๋ก ์ํ๋์ง๋ง, ์์์ ์ถ๊ฐ ๋ฐ ์ญ์ ์์ ์ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ๋งค์ฐ ๊ธธ์ด์ง๋ ๋จ์ ์ ๊ฐ์ง๊ฒ ๋ฉ๋๋ค.
๋ค์ ์์ ๋ ์ฌ๋ฌ ArrayList ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ ๋ฆฌ์คํธ๋ฅผ ์์ฑํ๊ณ ์กฐ์ํ๋ ์์ ์ ๋๋ค.
// ArrayList ์ญ์ ํด๋์ค์ด๊ธฐ ๋๋ฌธ์ ๋ณดํต ํด๋์ค๋ฅผ ์ธ์คํด์คํ ํ๋ฏ์ด ๊ฐ์ฒด๋ฅผ ๋ง๋ค๋ฉด ๋๋ค.
ArrayList<Integer> arrList = new ArrayList<Integer>();
// add() ๋ฉ์๋๋ฅผ ์ด์ฉํ ์์์ ์ ์ฅ
arrList.add(40);
arrList.add(20);
arrList.add(30);
arrList.add(10);
// for ๋ฌธ๊ณผ get() ๋ฉ์๋๋ฅผ ์ด์ฉํ ์์์ ์ถ๋ ฅ
for (int i=0; i<arrList.size(); i++) {
System.our.print(arrList.get(i) + " ");
}
// remove() ๋ฉ์๋๋ฅผ ์ด์ฉํ ์์์ ์ ๊ฑฐ
arrList.remove(1); // 1๋ฒ ์ธ๋ฑ์ค์ ๊ฐ์ ์ ๊ฑฐ
// Enhanced for๋ฌธ๊ณผ get() ๋ฉ์๋๋ฅผ ์ด์ฉํ ์์์ ์ถ๋ ฅ
for (int e : arrList) {
System.out.print(e + " ");
}
// Collections.sort() ๋ฉ์๋๋ฅผ ์ด์ฉํ ์์์ ์ ๋ ฌ
Collections.sort(arrList);
// iterator() ๋ฉ์๋์ get() ๋ฉ์๋๋ฅผ ์ด์ฉํ ์์์ ์ถ๋ ฅ
Iterator<Integer> iter = arrList.iterator();
while(iter.hasNext()) {
System.out.print(iter.next() + " ");
}
// set() ๋ฉ์๋๋ฅผ ์ด์ฉํ ์์์ ๋ณ๊ฒฝ
arrList.set(0, 20);
for (int e : arrList) {
System.out.prin(e + " ");
}
// size() ๋ฉ์๋๋ฅผ ์ด์ฉํ ์์์ ์ด ๊ฐ์
System.out.println("๋ฆฌ์คํธ์ ํฌ๊ธฐ: " + arrList.size());
์ ์์ ์ฒ๋ผ ์ปฌ๋ ์ ํด๋์ค์ ์์๋ฅผ ์ถ๋ ฅํ๋ ๋ฐฉ๋ฒ์๋ for ๋ฌธ๊ณผ enhanced for ๋ฌธ, iterator() ๋ฉ์๋๋ฅผ ์ด์ฉํ ๋ฐฉ๋ฒ ๋ฑ ๋ค์ํ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
โ List ์ธํฐํ์ด์ค ๋ฉ์๋
List ์ธํฐํ์ด์ค๋ Collection ์ธํฐํ์ด์ค๋ฅผ ์์๋ฐ์ผ๋ฏ๋ก, Collection ์ธํฐํ์ด์ค์์ ์ ์ํ ๋ฉ์๋๋ ๋ชจ๋ ์ฌ์ฉํ ์ ์์ต๋๋ค.
List ์ธํฐํ์ด์ค์์ ์ ๊ณตํ๋ ์ฃผ์ ๋ฉ์๋๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
๋ฉ์๋ | ์ค๋ช |
boolean add(E e) | ํด๋น ๋ฆฌ์คํธ(list)์ ์ ๋ฌ๋ ์์๋ฅผ ์ถ๊ฐํจ |
void add(int index, E e) | ํด๋น ๋ฆฌ์คํธ์ ํน์ ์์น์ ์ ๋ฌ๋ ์์๋ฅผ ์ถ๊ฐํจ |
void clear() | ํด๋น ๋ฆฌ์คํธ์ ๋ชจ๋ ์์๋ฅผ ์ ๊ฑฐํจ |
boolean contains(Object o) | ํด๋น ๋ฆฌ์คํธ๊ฐ ์ ๋ฌ๋ ๊ฐ์ฒด๋ฅผ ํฌํจํ๊ณ ์๋์ง๋ฅผ ํ์ธํจ |
boolean equals(Object o) | ํด๋น ๋ฆฌ์คํธ์ ์ ๋ฌ๋ ๊ฐ์ฒด๊ฐ ๊ฐ์์ง๋ฅผ ํ์ธํจ |
E get(int index) | ํด๋น ๋ฆฌ์คํธ์ ํน์ ์์น์ ์กด์ฌํ๋ ์์๋ฅผ ๋ฐํํจ |
boolean isEmpty() | ํด๋น ๋ฆฌ์คํธ๊ฐ ๋น์ด์๋์ง๋ฅผ ํ์ธํจ |
iterator<E> iterator() | ํด๋น ๋ฆฌ์คํธ์ ๋ฐ๋ณต์(iterator)๋ฅผ ๋ฐํํจ |
boolean remove(Object o) | ํด๋น ๋ฆฌ์คํธ์์ ์ ๋ฌ๋ ๊ฐ์ฒด๋ฅผ ์ ๊ฑฐํจ |
boolean(int index) | ํด๋น ๋ฆฌ์คํธ์ ํน์ ์์น์ ์กด์ฌํ๋ ์์๋ฅผ ์ ๊ฑฐํจ |
E set(int index E e) | ํด๋น ๋ฆฌ์คํธ์ ํน์ ์์น์ ์กด์ฌํ๋ ์์๋ฅผ ์ ๋ฌ๋ฐ์ ๊ฐ์ฒด๋ก ๋์ฒดํจ |
int size() | ํด๋น ๋ฆฌ์คํธ์ด ์์์ ์ด ๊ฐ์๋ฅผ ๋ฐํํจ |
Object[] toArray() | ํด๋น ๋ฆฌ์คํธ์ ๋ชจ๋ ์์๋ฅผ Object ํ์ ์ ๋ฐฐ์ด๋ก ๋ฐํํจ |
๐ ArrayList ๊ด๋ จ ์์ ์ฝ๋
๋ค์๊ณผ ๊ฐ์ ArrayList๊ฐ ์๋ค๊ณ ํฉ๋๋ค.
Integer[] arData = {40, 50, 90, 70, 10, 80, 20, 30, 100};
ArrayList<Integer> datas = new ArrayList<Integer>(Arrays.asList(arData));
1. ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๊ธฐ
์ฌ๊ธฐ์์ Collections ํด๋์ค์ sort ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ค๊ณ ํฉ๋๋ค.
๊ทธ๋ฐ๋ฐ ํด๋น ๋ฉ์๋์ ์ค๋ช ์ ๋ณด๊ฒ ๋๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
๋งค๊ฐ๋ณ์๋ก list ํ์ ์ ๋ฐ๋๋ค๊ณ ๋์ด์์ต๋๋ค.
๊ทธ๋ฐ๋ฐ ArrayList๋ List ํด๋์ค์ ์ํ๋ ํด๋์ค์ด๊ธฐ ๋๋ฌธ์
ArrayList๋ฅผ ๋ถ๋ชจ ํด๋์ค, List ํด๋์ค๋ฅผ ๋ถ๋ชจ ํด๋์ค๋ผ๊ณ ๋๋๋ค๋ฉด
์ ์บ์คํ (Up casring: ์์ ํ์ ์ ๋ถ๋ชจ ํ์ ์ผ๋ก)์ผ๋ก ArrayList๋ ๋งค๊ฐ๋ณ์๋ก ์ ๋ ฅ์ด ๊ฐ๋ฅํ ๊ฒ์ ๋๋ค.
Collections.sort(datas);
System.out.println(datas); // [10, 20, 30, 40, 50, 70, 80, 90, 100]
์ฐธ๊ณ ๋ก ArrayList์์๋ toString()์ ์ฌ์ ์ ํด๋์๊ธฐ ๋๋ฌธ์ ๊ฐ์ฒด๋ฅผ ์ถ๋ ฅํด๋ณด๋ฉด ๋ฐ๋ก ๊ฐ์ด ์ถ๋ ฅ๋ฉ๋๋ค.
2. ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๊ธฐ
sort()์ฒ๋ผ ๋ฐ๋ก ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ๋ฉ์๋์ ๋น์ทํ๊ฒ ๋ฐ๋ก ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ๋ฉ์๋๋ ์์ต๋๋ค.
๊ทธ๋ ๊ธฐ ๋๋ฌธ์ sort()๋ฅผ ํด์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ์ ํ ๋ค์ reverseํ์ฌ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ๋๋ก ์ ๋ ฌํด ์ฃผ๋ฉด ๋ฉ๋๋ค.
Collections.sort(datas);
Collections.reverse(datas);
System.out.println(datas); // [100, 90, 80, 70, 50, 40, 30, 20, 10]
3. ๋๋คํ๊ฒ ์๊ธฐ
Collections.shuffle(datas);
4. ์ถ๊ฐ(์ฝ์ )ํ๊ธฐ - 30 ๋ค์ 60 ์ฝ์ ํ๋ค
if(datas.contains(30)) {
datas.add(datas.indexOf(30)+1, 6);
}
System.out.println(datas); // [80, 90, 40, 30, 60, 10, 50, 100, 20, 70]
5. ์์ ํ๊ธฐ - 10์ 1๋ก ์์ ํ๋ค
if(datas.contains(10)) {
datas.set(datas.indexOf(10), 1);
}
6. ์ญ์ (๊ฐ์ผ๋ก ์ญ์ )ํ๊ธฐ - 20์ ์ญ์ ํ๋ค
remove() ๋ฉ์๋๋ฅผ ํตํด ๊ฐ์ผ๋ก ์ญ์ ๋ฅผ ํ๋ ค๊ณ ํ๋ค๋ฉด ๋งค๊ฐ๋ณ์๋ก ๊ฐ์ฒด(Object) ํ์ ์ ๊ฐ์ด์ด์ผ ํฉ๋๋ค.
๋ฐ๋ผ์ ๊ธฐ๋ณธ ํ์ ์ธ int๊ฐ ์๋๋ผ Integer.valueOf๋ฅผ ํตํด int๊ฐ์ ๋๊ฒจ Integer ํ์ ์ ๊ฐ๋๋ก ํด์ ๋งค๊ฐ๋ณ์๋ก ๋๊น๋๋ค.
if(datas.contains(20)) {
datas.remove(Integer.valueOf(20));
}
7. ์ญ์ (์ธ๋ฑ์ค๋ก ์ญ์ )ํ๊ธฐ - 50์ ์ญ์ ํ๋ค
if(datas.contains(50)) {
datas.remove(datas.indexOf(50));
}
'๋ฐฑ์๋ > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] ์๋ฐ์ Set ์ปฌ๋ ์ ํด๋์ค (0) | 2023.02.16 |
---|---|
[Java] ์๋ฐ์ Stream (0) | 2023.02.15 |
[Java] ์ปฌ๋ ์ ํ๋ ์์ํฌ(Collection Framework) - ๋ค์์ ๋ฐ์ดํฐ๋ฅผ ์ฝ๊ณ ํจ๊ณผ์ ์ผ๋ก ์ฒ๋ฆฌํ์ (0) | 2023.02.13 |
[Java] ์๋ฐ์ Wrapper ํด๋์ค์ ๋ํด ์์๋ณด์ (0) | 2023.02.09 |
[Java] ์๋ฐ์ Object ํด๋์ค์ ๋ํด ์์๋ณด์ (0) | 2023.02.09 |
- Total
- Today
- Yesterday
- ์๋ฐ์คํฌ๋ฆฝํธ ๊ธฐ์ด
- frontend
- ์๋ฐ์คํฌ๋ฆฝํธ
- ๋ฆฌ์กํธ
- ์คํ์ผ ์ปดํฌ๋ํธ styled-components
- ๋ฆฌ์กํธ ํ
- ๋จธ์ ๋ฌ๋
- TypeScript
- JSP
- ๋ํ๋ง
- react-query
- ๋ฐ์ดํฐ๋ถ์
- rtl
- CSS
- testing
- jest
- ํ๋ก์ ํธ ํ๊ณ
- ํ์ด์ฌ
- ํ์ ์คํฌ๋ฆฝํธ
- react
- ์ธํ๋ฐ
- ํ๋ก ํธ์๋
- ๋ฅ๋ฌ๋
- ํ๋ก ํธ์๋ ๊ณต๋ถ
- ํ๋ก ํธ์๋ ๊ธฐ์ด
- ์๋ฐ
- HTML
- next.js
- Python
- styled-components
์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | |||||
3 | 4 | 5 | 6 | 7 | 8 | 9 |
10 | 11 | 12 | 13 | 14 | 15 | 16 |
17 | 18 | 19 | 20 | 21 | 22 | 23 |
24 | 25 | 26 | 27 | 28 | 29 | 30 |