๐ ์๋ฃ๊ตฌ์กฐ - ArrayList, LinkedList ๋ํด ์ค๋ช ํ์์ค.
10) ์๋ฃ๊ตฌ์กฐ - ArrayList, LinkedList
List
์ด๋ค ์์๊ฐ ์๋ ๋ฐ์ดํฐ์ ์งํฉ
- ArrayList, LinkedList๊ฐ ์์.
ex) ์ฌ๋ฆผํฝ์์ ๋ง๋ผํค์ ํ์ ๋, 1๋ฑ๋ถํฐ ๋ฆฌ์คํธ๋ฅผ ์ญ ์ ์ฅ
ArrayList
์ฐ์์
์ธ ๊ณต๊ฐ์ ์์ฐจ์ ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์ฅ
๋ฐฐ์ด ๊ธฐ๋ฐ ์๋ฃ ๊ตฌ์กฐ
๋ง์ฝ ๋ก๋ ๋ฒํธ๋ฅผ ์ ์ฅํ๋ค๊ณ ํ์ ๋ 4, 12, 5, 43, 28, 31, 24
๊ฐ ๋์๋ค๊ณ ํ์ ๋
ArrayList
์ ์ฅ์ : indexing์ด ๊ฐ๋ฅํ๋ค.
๊ทธ๋ ๋ค๋ฉด idx[4] = 28
์์ ์ ์ ์๋ค.
- ์ฝ๊ธฐ์ ๊ฒ์์ด ๋น ๋ฅด๋ค.
ArrayList
์ ๋จ์ : ์ถ๊ฐ / ์ญ์ ๊ฐ ์ด๋ ต๋ค.
๋ง์ฝ idx[2]๋ฅผ ์ญ์ ํ๋ค๋ฉด ๋ค์ ์ซ์๋ค์ด ํ ์นธ์ฉ ์์ผ๋ก ์์ผ๋๊ธฐ ๋๋ฌธ์ ์ค๋๊ฑธ๋ฆฐ๋ค.
์ฆ, ์ค๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ ํ๊ฑฐ๋ ์ญ์ ํ ๋๋ ๋ฐฐ์ด์ ์ฌ๋ฐฐ์ด ํ๋ฏ๋ก ์๊ฐ์ด ์ค๋๊ฑธ๋ฆฌ๊ณ ์ค๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ์ญ์ ํ๋ฉด ๋น ๊ณต๊ฐ์ด ๋จ๊ฒ๋์ด ๊ณต๊ฐ ๋ญ๋น๊ฐ ๋ฐ์ํ ์ ์๋ค.
ArrayList
๋ ๋ด๋ถ์์ ๋ฐฐ์ด์ ์ฌ์ฉํด ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ค. ์ด๊ธฐ ํฌ๊ธฐ๊ฐ ๊ณ ์ ๋์ด ์๊ณ ๋ฐฐ์ด์ด ๊ฝ ์ฐจ๋ฉด ์๋ก์ด ๋ ํฐ ๋ฐฐ์ด์ ์์ฑํ ํ ๊ธฐ์กด ๋ฐ์ดํฐ๋ฅผ ๋ณต์ฌํ์ฌ ํ์ฅํ๋ค.
์ฆ, ์ฌ์ด์ฆ๊ฐ ๊ณ ์ ๋์ด ์์ด์ ๋ง์ฝ ์ฌ์ด์ฆ๋ฅผ ๋๋ฆฌ๋ ค๋ฉด ๋ณต์ฌ๋ฅผ ํตํด ์ฌ์ด์ฆ๋ฅผ ๋๋ ค์ผ ๋๋ค.
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
31
32
33
34
35
36
37
38
39
40
41
42
43
import java.util.ArrayList;
public class ArrayListExample {
public static void main(String[] args) {
// ArrayList ์ ์ธ
ArrayList<String> arrayList = new ArrayList<>();
// ์์ ์ถ๊ฐ
arrayList.add("Apple");
arrayList.add("Banana");
arrayList.add("Cherry");
System.out.println("ArrayList after additions: " + arrayList);
// ํน์ ์์น์ ์์ ์ถ๊ฐ
arrayList.add(1, "Orange"); // 1๋ฒ์งธ ์์น์ "Orange" ์ถ๊ฐ
System.out.println("ArrayList after inserting 'Orange' at index 1: " + arrayList);
// ์์ ์ญ์
arrayList.remove("Banana"); // "Banana" ์ญ์
System.out.println("ArrayList after removing 'Banana': " + arrayList);
// ์ธ๋ฑ์ค๋ก ์์ ์ญ์
arrayList.remove(1); // ์ธ๋ฑ์ค 1์ ์๋ ์์ ์ญ์
System.out.println("ArrayList after removing element at index 1: " + arrayList);
// ์์ ์์
arrayList.set(0, "Mango"); // 0๋ฒ์งธ ์ธ๋ฑ์ค์ ์์๋ฅผ "Mango"๋ก ๋ณ๊ฒฝ
System.out.println("ArrayList after setting 'Mango' at index 0: " + arrayList);
// ํน์ ์์ ์ฐพ๊ธฐ
boolean containsCherry = arrayList.contains("Cherry");
System.out.println("Contains 'Cherry': " + containsCherry);
// ๋ฆฌ์คํธ ํฌ๊ธฐ ํ์ธ
int size = arrayList.size();
System.out.println("ArrayList size: " + size);
// ๋ฆฌ์คํธ๊ฐ ๋น์ด ์๋์ง ํ์ธ
boolean isEmpty = arrayList.isEmpty();
System.out.println("Is ArrayList empty: " + isEmpty);
}
}
LinkedList
๋น์ฐ์์
์ธ ๊ณต๊ฐ์ ์์๋๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์ฅ
๋ ธ๋์ ํฌ์ธํฐ๋ฅผ ์ด์ฉํ ๋์ ์๋ฃ ๊ตฌ์กฐ
๊ฐ ๋
ธ๋๊ฐ ์๊ณ ์ข์ธก์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๊ณต๊ฐ์ด๊ณ ์ฐ์ธก์ ๋ค์ ๋
ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ(Next) ๊ตฌ์กฐ์ด๋ค. ๋ฐ๋ผ์ ๋์ผํ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ ๋ ArrayList
๋ณด๋ค ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ ๋ง์ด ์ฌ์ฉํ๋ค.
ํ์ง๋ง ๋์ ์๋ฃ ๊ตฌ์กฐ์ด๋ฏ๋ก ๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐํ ๋๋ง๋ค ํฌ์ธํฐ๋ฅผ ์ฐ๊ฒฐํ๋ ๋ฐฉ์์ผ๋ก ํฌ๊ธฐ๋ฅผ ์กฐ์ ํ ์ ์์ด ArrayList
์ฒ๋ผ ๋ฐฐ์ด์ ๋ณต์ฌํ์ฌ ํฌ๊ธฐ๋ฅผ ํ์ฅํ๋ ๊ณผ์ ์ด ํ์ํ์ง ์๋ค.
LinkedList
์ฅ์ : ์ถ๊ฐ / ์ญ์ ๊ฐ ์ฝ๋ค.
์์ ๊ทธ๋ฆผ์ ์๋ฅผ ๋ค์ด B์ C ์ฌ์ด G๋ฅผ ์ถ๊ฐํ๋ค๊ณ ํ ๋ ์ฝ๊ฒ A -> B -> G -> C -> D
๋ฅผ ๋ง๋ค ์ ์๋ค.
LinkedList
๋จ์ : ์์น๋ฅผ ํ์ํ๋ ๊ฒ ArrayList์ ๋นํด ์ค๋๊ฑธ๋ฆฐ๋ค.
- ์ธ๋ฑ์ค๋ก ์ ๊ทผํ ์ ์์ผ๋ฉฐ ์ํ๋ ๋ฐ์ดํฐ๋ฅผ ์ฐพ์ผ๋ ค๋ฉด ์ฒ์๋ถํฐ ๋ ธ๋๋ฅผ ์์ฐจ์ ์ผ๋ก ํ์ํด์ผํ๋ค. ๊ทธ๋์ ์ฝ๊ธฐ์ ๊ฒ์ ์๋๊ฐ ArrayList๋ณด๋ค ์ค๋๊ฑธ๋ฆฌ๋ ๊ฒ!
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
import java.util.LinkedList;
public class LinkedListExample {
public static void main(String[] args) {
// LinkedList ์ ์ธ
LinkedList<String> linkedList = new LinkedList<>();
// ์์ ์ถ๊ฐ
linkedList.add("Apple");
linkedList.add("Banana");
linkedList.add("Cherry");
System.out.println("LinkedList after additions: " + linkedList);
// ์ฒซ ๋ฒ์งธ์ ๋ง์ง๋ง์ ์์ ์ถ๊ฐ
linkedList.addFirst("Orange"); // ๋งจ ์์ "Orange" ์ถ๊ฐ
linkedList.addLast("Mango"); // ๋งจ ๋ค์ "Mango" ์ถ๊ฐ
System.out.println("LinkedList after addFirst and addLast: " + linkedList);
// ์์ ์ญ์
linkedList.remove("Banana"); // "Banana" ์ญ์
System.out.println("LinkedList after removing 'Banana': " + linkedList);
// ์ฒซ ๋ฒ์งธ์ ๋ง์ง๋ง ์์ ์ญ์
linkedList.removeFirst(); // ์ฒซ ๋ฒ์งธ ์์ ์ญ์
linkedList.removeLast(); // ๋ง์ง๋ง ์์ ์ญ์
System.out.println("LinkedList after removeFirst and removeLast: " + linkedList);
// ํน์ ์์น์ ์์ ๊ฐ์ ธ์ค๊ธฐ
String element = linkedList.get(1); // ์ธ๋ฑ์ค 1์ ์๋ ์์ ๊ฐ์ ธ์ค๊ธฐ
System.out.println("Element at index 1: " + element);
// ํน์ ์์น์ ์์ ์ถ๊ฐ
linkedList.add(1, "Strawberry"); // 1๋ฒ์งธ ์์น์ "Strawberry" ์ถ๊ฐ
System.out.println("LinkedList after inserting 'Strawberry' at index 1: " + linkedList);
// ๋ฆฌ์คํธ ํฌ๊ธฐ ํ์ธ
int size = linkedList.size();
System.out.println("LinkedList size: " + size);
// ๋ฆฌ์คํธ๊ฐ ๋น์ด ์๋์ง ํ์ธ
boolean isEmpty = linkedList.isEmpty();
System.out.println("Is LinkedList empty: " + isEmpty);
}
}