๐ ์ค๋์ ํ์ต ํค์๋
- LinkedList
- ArrayList
๐ฅ List ๋?
๋ฐฐ์ด๊ณผ ๊ฐ์ด ๊ฐ์ฒด๋ฅผ 1์ด๋ก ๋์ด๋์ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๊ณ ์๋ค. ๊ฐ์ฒด๋ฅผ ์ธ๋ฑ์ค๋ก ๊ด๋ฆฌํ๊ธฐ ๋๋ฌธ์
๊ฐ์ฒด๋ฅผ ์ ์ฅํ๋ฉด ์๋์ผ๋ก ์ธ๋ฑ์ค๊ฐ ๋ถ์ฌ๋๊ณ , ์ธ๋ฑ์ค๋ก ๊ฐ์ฒด๋ฅผ ์ถ๊ฐ, ๊ฒ์, ์ญ์ ํ ์ ์๋ ๋ฑ์ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ค.
List ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ํด๋์ค๋ ArrayList, Vector, LinkedList, Stack ๋ฑ์ด ์์ง๋ง,
๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋๋ ๊ฒ์ ArrayList, LinkedList๊ฐ ์๋ค.
- ๋ฆฌ์คํธ์ ํน์ง
- ์์๊ฐ ์๊ณ ์ค๋ณต์ ํ์ฉ
- ์ธ๋ฑ์ค๋ก ๊ด๋ฆฌํ๊ธฐ ๋๋ฌธ์ ์ธ๋ฑ์ค๋ก ์ ๊ทผ ๊ฐ๋ฅ
- ํฌ๊ธฐ๊ฐ ๊ฐ๋ณ์
๐ฅ List ์ธํฐํ์ด์ค
List ์์ ๊ณตํต์ ์ผ๋ก ์ฌ์ฉ ๊ฐ๋ฅํ ๋ฉ์๋
add(int index, Object element)
- ์ฃผ์ด์ง ์ธ๋ฑ์ค์ ๊ฐ์ฒด๋ฅผ ์ถ๊ฐ
set(int index, Object element)
- ์ฃผ์ด์ง ์ธ๋ฑ์ค์ ๊ฐ์ฒด๋ฅผ ์ ์ฅ. Object ํ์ ์ ๋ฆฌํด
indexOf(Object o) / lastIndex(Object o)
- ์๋ฐฉํฅ / ์ญ๋ฐฉํฅ์ผ๋ก ํ์ํ์ฌ ์ฃผ์ด์ง ๊ฐ์ฒด์ ์์น๋ฅผ ๋ฐํ. int ํ์ ์ ๋ฆฌํด
remove(int index)
- ์ฃผ์ด์ง ์ธ๋ฑ์ค์ ์ ์ฅ๋ ๊ฐ์ฒด๋ฅผ ์ญ์ . ๊ฐ์ฒด๋ฅผ ๋ฐํ. Object ํ์ ์ ๋ฆฌํด
๐ฅ ArrayList
List ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ํด๋์ค๋ก ์ปฌ๋ ์ ํ๋ ์์ํฌ์์ ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋๋ค.
๊ฐ์ฒด๊ฐ ์ธ๋ฑ์ค๋ก ๊ด๋ฆฌ๋๋ค๋ ์ ์์ ๋ฐฐ์ด๊ณผ ์ ์ฌํ๋ค. ๊ทธ๋ฌ๋ ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ ๊ณ ์ ์ ์ด๊ณ , ๋ณ๊ฒฝํ ์ ์์ง๋ง
ArrayList๋ ์ ์ฅ ์ฉ๋์ ์ด๊ณผํ์ฌ ๊ฐ์ฒด๋ค์ด ์ถ๊ฐ๋ผ๋, ์๋์ผ๋ก ์ ์ฅ์ฉ๋์ด ๋์ด๋๋ฉฐ, ๋ฐ์ดํฐ๋ ์ฐ์์ ์ผ๋ก
์กด์ฌํ์ฌ ๋ฐ์ดํฐ์ ์์๊ฐ ์ ์ง๋๋ค.
ArrayList์ ๊ฐ์ฒด๋ฅผ ์ถ๊ฐํ๊ฒ ๋๋ฉด ์ธ๋ฑ์ค๋ 0๋ถํฐ ์ฐจ๋ก๋๋ก ์ ์ฅ๋๋ค.
ํน์ ์ธ๋ฑ์ค์ ๊ฐ์ฒด๋ฅผ ์ ๊ฑฐํ๋ฉด, ๋ฐ๋ก ๋ค ์ธ๋ฑ์ค๋ถํฐ ๋ง์ง๋ง ์ธ๋ฑ์ค๊น์ง ๋ชจ๋ ์์ผ๋ก 1์ฉ ๋น๊ฒจ์ง๋ค.
์ ์ฅํ ๋๋ ๋ฐ์ดํฐ๋ฅผ ์ด๋ํ์ง ์์๋ ๋๋ฏ๋ก, ์์ ์๋๊ฐ ๋น ๋ฅด์ง๋ง,
์ค๊ฐ์ ์์นํ ๊ฐ์ฒด๋ฅผ ์ถ๊ฐ, ์ญ์ ํ ๋๋ ๋ฐ์ดํฐ ์ด๋์ด ๋ง์ผ๋ฏ๋ก ์๋๊ฐ ์ ํ๋๋ค.
๋ฐ๋ฉด, ์ธ๋ฑ์ค๋ก ๋ฐ์ดํฐ์ ๋น ๋ฅด๊ฒ ์ ๊ทผ์ด ๊ฐ๋ฅํ๊ธฐ ๋๋ฌธ์ ๊ฒ์์ธก๋ฉด์์๋ ์ ๋ฆฌํ๋ค.
ArrayList<๋งค๊ฐ๋ณ์> ๊ฐ์ฒด๋ช
= new ArrayList<๋งค๊ฐ๋ณ์>(์ด๊ธฐ ์ ์ฅ ์ฉ๋);
// ArrayList๋ ์ด๊ธฐ ์ฉ๋์ ์ ํ์ง ์์ผ๋ฉด ๊ธฐ๋ณธ๊ฐ์ผ๋ก 10์ผ๋ก ์ง์ ๋จ
// ArrayList
// (์ฌ์ฉํ๊ธฐ ์ํด์ import java.util.ArrayList; ๋ฅผ ์ถ๊ฐํด์ผํฉ๋๋ค.)
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
ArrayList<Integer> intList = new ArrayList<Integer>(); // ์ ์ธ ๋ฐ ์์ฑ
intList.add(1);
intList.add(2);
intList.add(3);
System.out.println(intList.get(0)); // 1 ์ถ๋ ฅ
System.out.println(intList.get(1)); // 2 ์ถ๋ ฅ
System.out.println(intList.get(2)); // 3 ์ถ๋ ฅ
System.out.println(intList.toString()); // [1,2,3] ์ถ๋ ฅ
intList.set(1, 10); // 1๋ฒ์๋ฒ์ ๊ฐ์ 10์ผ๋ก ์์ ํฉ๋๋ค.
System.out.println(intList.get(1)); // 10 ์ถ๋ ฅ
intList.remove(1); // 1๋ฒ์๋ฒ์ ๊ฐ์ ์ญ์ ํฉ๋๋ค.
System.out.println(intList.toString()); // [1,3] ์ถ๋ ฅ
intList.clear(); // ์ ์ฒด ๊ฐ์ ์ญ์ ํฉ๋๋ค.
System.out.println(intList.toString()); // [] ์ถ๋ ฅ
}
}
โ๏ธ ArrayList ์ฅ์
๋ฐ์ดํฐ๋ฅผ ์์ฐจ์ ์ผ๋ก ์ถ๊ฐํ๊ฑฐ๋ ์ญ์ ํ๋ ๊ฒฝ์ฐ
- ์์ฐจ์ ์ผ๋ก ์ถ๊ฐํ๋ค๋ ๊ฒ์ ์ธ๋ฑ์ค 0๋ฒ๋ถํฐ ์ถ๊ฐํ๋ ๊ฒ
- ์์ฐจ์ ์ผ๋ก ์ญ์ ํ๋ค๋ ๊ฒ์ ๋ง์ง๋ง ์ธ๋ฑ์ค์์๋ถํฐ ์ญ์ ํ๋ ๊ฒ
๋ฐ์ดํฐ๋ฅผ ์ฝ์ด ๋ค์ด๋ ๊ฒฝ์ฐ
- ์ธ๋ฑ์ค๋ฅผ ํตํด ๋ฐ๋ก ๋ฐ์ดํฐ์ ์ ๊ทผ๊ฐ๋ฅํ๋ฏ๋ก ๊ฒ์์ด ๋น ๋ฅด๋ค.
โ๏ธ ArrayList ๋จ์
์ค๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐ, ์ญ์ ํ๋ ๊ฒฝ์ฐ
- ์ถ๊ฐ, ์ญ์ ์, ํด๋น ๋ฐ์ดํฐ์ ๋ค์ ์์นํ ๊ฐ๋ค์ ๋ค๋ก ๋ฐ๊ฑฐ๋ ์์ผ๋ก ๋น๊ฒจ์ผ ํ๋ค.
๐ฅ LinkedList
ArrayList์ ๋ฐฐ์ด์ ๋ชจ๋ ๋ฐ์ดํฐ๊ฐ ์ฐ์์ ์ผ๋ก ์กด์ฌํ์ง๋ง, LinkedList์๋ ๋ถ์ฐ์์ ์ผ๋ก ์ ์ฌํ๋ฉฐ,
์๋ก ์ฐ๊ฒฐ๋์ด ์๋ค. LinkedList ์ปฌ๋ ์ ์ ๋ฐ์ดํฐ๋ฅผ ํจ์จ์ ์ผ๋ก ์ถ๊ฐ, ์ญ์ , ๋ณ๊ฒฝํ๊ธฐ ์ํด ์ฌ์ฉ๋๋ค.
LinkedList์ ๊ฐ ์์๋ค์ ์์ ๊ณผ ์ฐ๊ฒฐ๋ ์ด์ , ๋ค์ ์์์ ์ฃผ์๊ฐ๊ณผ ๋ฐ์ดํฐ๋ก ๊ตฌ์ฑ๋์ด ์๋ค.
LinkedList์์ ๋ฐ์ดํฐ๋ฅผ ์ญ์ ํ๋ฉด, ์ญ์ ํ๊ณ ์ ํ๋ ์ด์ ์์๊ฐ ์ญ์ ํ๊ณ ์ ํ๋ ๋ค์ ์์๋ฅผ ์ฐธ์กฐํ๋๋ก ๋ณ๊ฒฝ๋๋ค.
๋ฐฐ์ด์ฒ๋ผ ๋ฐ์ดํฐ๋ฅผ ์ด๋ํ๊ธฐ ์ํด ๋ณต์ฌํ ํ์๊ฐ ์๊ธฐ ๋๋ฌธ์ ์ฒ๋ฆฌ ์๋๊ฐ ํจ์ฌ ๋น ๋ฅด๋ค.
// LinkedList
// (์ฌ์ฉํ๊ธฐ ์ํด์ import java.util.LinkedList; ๋ฅผ ์ถ๊ฐํด์ผํฉ๋๋ค.)
import java.util.LinkedList;
public class Main {
public static void main(String[] args) {
LinkedList<Integer> linkedList = new LinkedList<>(); // ์ ์ธ ๋ฐ ์์ฑ
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
System.out.println(linkedList.get(0)); // 1 ์ถ๋ ฅ
System.out.println(linkedList.get(1)); // 2 ์ถ๋ ฅ
System.out.println(linkedList.get(2)); // 3 ์ถ๋ ฅ
System.out.println(linkedList.toString()); // [1,2,3] ์ถ๋ ฅ (์๋ ๋๋ฆผ)
linkedList.add(2, 4); // 2๋ฒ ์๋ฒ์ 4 ๊ฐ์ ์ถ๊ฐํฉ๋๋ค.
System.out.println(linkedList); // [1,2,4,3] ์ถ๋ ฅ
linkedList.set(1, 10); // 1๋ฒ์๋ฒ์ ๊ฐ์ 10์ผ๋ก ์์ ํฉ๋๋ค.
System.out.println(linkedList.get(1)); // 10 ์ถ๋ ฅ
linkedList.remove(1); // 1๋ฒ์๋ฒ์ ๊ฐ์ ์ญ์ ํฉ๋๋ค.
System.out.println(linkedList); // [1,4,3] ์ถ๋ ฅ
linkedList.clear(); // ์ ์ฒด ๊ฐ์ ์ญ์ ํฉ๋๋ค.
System.out.println(linkedList); // [] ์ถ๋ ฅ
}
}
โ๏ธLinkedList ์ฅ์
์ค๊ฐ์ ์์นํ๋ ๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐ, ์ญ์ ํ๋ ๊ฒฝ์ฐ
- ๋ฐ์ดํฐ๋ฅผ ์ค๊ฐ์ ์ถ๊ฐ, ์ญ์ ํ๋ ๊ฒฝ์ฐ ์ด์ ๊ณผ ๋ค์์ ์ฃผ์๊ฐ๋ง ๋ณ๊ฒฝํ๋ฉด ๋๋ฏ๋ก,
๋ค๋ฅธ ์์๋ค์ ์ด๋์ํฌ ํ์๊ฐ ์๋ค.
๋ฐ๋ผ์, ๋ฐ์ดํฐ๋ฅผ ์ค๊ฐ์ ์ถ๊ฐ, ์ญ์ ํ๋ ๊ฒฝ์ฐ LinkedList๋ ArrayList๋ณด๋ค ๋น ๋ฅธ ์๋๋ฅผ ๋ณด์ฌ์ค
๋ฐ์ดํฐ์ ์ฆ์ ๋ณ๊ฒฝ์ด ์์๋ ๋ LinkedList, ๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐํ ๋ ArrayList
๐ ์ค๋์ ํ๊ณ
๊ธฐ๋ณธ๋ถํฐ ์ฐจ๊ทผ์ฐจ๊ทผ
'TIL' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
01/25(๋ชฉ) ๋ด์ผ๋ฐฐ์์บ ํ Java 24์ผ์ฐจ TIL - REST API (0) | 2024.01.25 |
---|---|
01/24(์) ๋ด์ผ๋ฐฐ์์บ ํ Java 23์ผ์ฐจ TIL - 3 Layer Architecture (2) | 2024.01.24 |
01/22(์) ๋ด์ผ๋ฐฐ์์บ ํ Java 21์ผ์ฐจ TIL - Path Variable, Request Param (0) | 2024.01.22 |
01/19(๊ธ) ๋ด์ผ๋ฐฐ์์บ ํ Java 20์ผ์ฐจ TIL - this (0) | 2024.01.19 |
01/18(๋ชฉ) ๋ด์ผ๋ฐฐ์์บ ํ Java 19์ผ์ฐจ TIL - MVC (0) | 2024.01.18 |