๋ชฉ์ฐจ
1. ArrayList์ ๊ฐ๋ ๊ณผ ํน์ง
2. ArrayList์ ์ ์ธ๊ณผ ์ด๊ธฐํ ๋ฐฉ๋ฒ
3. ArrayList์ ์์ ์ถ๊ฐ, ์ญ์ , ์ ๊ทผํ๋ ๋ฐฉ๋ฒ
4. ArrayList์ ํฌ๊ธฐ ๋ฐ ๋ฐฐ์ด๊ณผ์ ์ฐจ์ด์
5. ArrayList์ ํ์ฉ ์์ ๋ฐ ์ฃผ์์ฌํญ
1. ArrayList์ ๊ฐ๋ ๊ณผ ํน์ง
ArrayList๋ Java์์ ์ ๊ณตํ๋ ๋์ ๋ฐฐ์ด ํด๋์ค์ ๋๋ค. ๋์ ๋ฐฐ์ด์ด๋, ํฌ๊ธฐ๊ฐ ์๋์ผ๋ก ์กฐ์ ๋๋ ๋ฐฐ์ด์ ๋งํฉ๋๋ค. ArrayList๋ ๋ฐฐ์ด๊ณผ ๋ฌ๋ฆฌ ํฌ๊ธฐ๋ฅผ ๋ฏธ๋ฆฌ ์ง์ ํ ํ์ ์์ด ์์๋ฅผ ์ถ๊ฐํ๊ฑฐ๋ ์ญ์ ํ ์ ์์ต๋๋ค.
ArrayList์ ํน์ง์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
- ํฌ๊ธฐ์ ์ ํ์ด ์์: ArrayList๋ ๋์ ๋ฐฐ์ด์ด๊ธฐ ๋๋ฌธ์ ์์์ ๊ฐ์์ ์๊ด์์ด ํ์ํ ๋๋ง๋ค ํฌ๊ธฐ๋ฅผ ์๋์ผ๋ก ์กฐ์ ํ ์ ์์ต๋๋ค.
- ์ธ๋ฑ์ค ๊ธฐ๋ฐ ์ ๊ทผ: ArrayList๋ ๊ฐ ์์์ ์ธ๋ฑ์ค๋ฅผ ํ ๋นํ์ฌ ์ ๊ทผํ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ํน์ ์์น์ ์๋ ์์์ ์ง์ ์ ๊ทผ์ด ๊ฐ๋ฅํฉ๋๋ค.
- ์ค๋ณต ์์ ํ์ฉ: ArrayList๋ ์ค๋ณต๋ ์์๋ฅผ ํ์ฉํฉ๋๋ค. ๋ฐ๋ผ์ ๋์ผํ ๊ฐ์ ์ฌ๋ฌ ๋ฒ ์ ์ฅํ ์ ์์ต๋๋ค.
- ์์ ๋ณด์ฅ: ArrayList๋ ์์๋ค์ ์ถ๊ฐํ ์์๋๋ก ์ ์ฅํ์ฌ ์์๊ฐ ๋ณด์ฅ๋ฉ๋๋ค.
ArrayList๋ ์๋ฐ์ java.util
ํจํค์ง์ ํฌํจ๋์ด ์์ผ๋ฉฐ, ์ ๋ค๋ฆญ์ ์ฌ์ฉํ์ฌ ๋ค์ํ ํ์
์ ์์๋ฅผ ๋ด์ ์ ์์ต๋๋ค.
2. ArrayList์ ์ ์ธ๊ณผ ์ด๊ธฐํ ๋ฐฉ๋ฒ
ArrayList๋ฅผ ์ ์ธํ๊ณ ์ด๊ธฐํํ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
1) ๊ธฐ๋ณธ ์ ์ธ ๋ฐฉ๋ฒ
ArrayList<์๋ฃํ> ๋ณ์๋ช
= new ArrayList<>();
์์ ๊ฐ์ด ArrayList<์๋ฃํ>
ํํ๋ก ์ ์ธํ ํ, new ArrayList<>()
๋ฌธ๋ฒ์ผ๋ก ์ด๊ธฐํํฉ๋๋ค. ์๋ฃํ์ ArrayList์ ์ ์ฅํ ์์์ ํ์
์ ์ง์ ํฉ๋๋ค.
์์:
ArrayList<Integer> numbers = new ArrayList<>();
ArrayList<String> names = new ArrayList<>();
2) ์ด๊ธฐ๊ฐ์ ๊ฐ์ง ์ ์ธ ๋ฐฉ๋ฒ
ArrayList<์๋ฃํ> ๋ณ์๋ช
= new ArrayList<>(์ด๊ธฐ๊ฐ);
ArrayList๋ฅผ ์ ์ธํ๋ฉด์ ์ด๊ธฐ๊ฐ์ ํจ๊ป ์ง์ ํ ์๋ ์์ต๋๋ค. ์ด๊ธฐ๊ฐ์ ArrayList์ ์ ์ฅํ ์์๋ค์ ์๋ฏธํฉ๋๋ค.
์์:
ArrayList<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
ArrayList<String> names = new ArrayList<>(Arrays.asList("Alice", "Bob", "Charlie"));
3) ๋ค๋ฅธ Collection์ ๊ธฐ๋ฐ์ผ๋ก ์ด๊ธฐํ ๋ฐฉ๋ฒ
ArrayList<์๋ฃํ> ๋ณ์๋ช
= new ArrayList<>(๋ค๋ฅธ Collection);
ArrayList๋ฅผ ๋ค๋ฅธ ์ปฌ๋ ์ (List, Set ๋ฑ)์ ๊ธฐ๋ฐ์ผ๋ก ์ด๊ธฐํํ ์๋ ์์ต๋๋ค.
์์:
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
ArrayList<Integer> numbers = new ArrayList<>(list);
ArrayList์ ์ ์ธ๊ณผ ์ด๊ธฐํ ๋ฐฉ๋ฒ์ ๋ค์ํ์ง๋ง, ๊ธฐ๋ณธ์ ์ผ๋ก๋ ์ ๋ค๋ฆญ์ ํ์ฉํ์ฌ ์์์ ํ์
์ ์ง์ ํ๊ณ , new ArrayList<>()
๋ฌธ๋ฒ์ผ๋ก ์ด๊ธฐํํ์ฌ ์ฌ์ฉํฉ๋๋ค.
3. ArrayList์ ์์ ์ถ๊ฐ, ์ญ์ , ์ ๊ทผํ๋ ๋ฐฉ๋ฒ
ArrayList์ ์์๋ฅผ ์ถ๊ฐ, ์ญ์ , ์ ๊ทผํ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
1) ์์ ์ถ๊ฐ
ArrayList.add(์์);
ArrayList์ ์์๋ฅผ ์ถ๊ฐํ๋ ค๋ฉด add()
๋ฉ์๋๋ฅผ ์ฌ์ฉํฉ๋๋ค. add()
๋ฉ์๋๋ ArrayList์ ๋งจ ๋ค์ ์์๋ฅผ ์ถ๊ฐํฉ๋๋ค.
์์:
ArrayList<Integer> numbers = new ArrayList<>();
numbers.add(10); // numbers = [10]
numbers.add(20); // numbers = [10, 20]
numbers.add(30); // numbers = [10, 20, 30]
2) ์์ ์ญ์
ArrayList.remove(์ธ๋ฑ์ค);
ArrayList์์ ์์๋ฅผ ์ญ์ ํ๋ ค๋ฉด remove()
๋ฉ์๋๋ฅผ ์ฌ์ฉํฉ๋๋ค. remove()
๋ฉ์๋๋ ์ง์ ๋ ์ธ๋ฑ์ค์ ํด๋นํ๋ ์์๋ฅผ ์ญ์ ํ๊ณ , ๊ทธ ๋ค์ ์๋ ์์๋ค์ ์ผ์ชฝ์ผ๋ก ์ด๋์ํต๋๋ค.
์์:
ArrayList<Integer> numbers = new ArrayList<>(Arrays.asList(10, 20, 30));
numbers.remove(1); // numbers = [10, 30]
3) ์์ ์ ๊ทผ
ArrayList.get(์ธ๋ฑ์ค);
ArrayList์์ ํน์ ์ธ๋ฑ์ค์ ์๋ ์์์ ์ ๊ทผํ๋ ค๋ฉด get()
๋ฉ์๋๋ฅผ ์ฌ์ฉํฉ๋๋ค. get()
๋ฉ์๋๋ ์ง์ ๋ ์ธ๋ฑ์ค์ ํด๋นํ๋ ์์๋ฅผ ๋ฐํํฉ๋๋ค.
์์:
ArrayList<Integer> numbers = new ArrayList<>(Arrays.asList(10, 20, 30));
int num = numbers.get(1); // num = 20
ArrayList์ ์์๋ฅผ ์ถ๊ฐํ๋ ค๋ฉด add()
๋ฉ์๋๋ฅผ ์ฌ์ฉํ๊ณ , ์ญ์ ํ๋ ค๋ฉด remove()
๋ฉ์๋๋ฅผ ์ฌ์ฉํฉ๋๋ค. ์ ๊ทผํ ์์์ ์ธ๋ฑ์ค๋ฅผ ์๊ณ ์๋ค๋ฉด get()
๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ํด๋น ์์์ ์ ๊ทผํ ์ ์์ต๋๋ค.
4. ArrayList์ ํฌ๊ธฐ ๋ฐ ๋ฐฐ์ด๊ณผ์ ์ฐจ์ด์
ArrayList๋ ๋์ ์ผ๋ก ํฌ๊ธฐ๊ฐ ์กฐ์ ๋๋ ๊ฐ๋ณ ํฌ๊ธฐ์ ๋ฐฐ์ด์ ์ ๊ณตํฉ๋๋ค. ๋ฐฐ์ด๊ณผ์ ์ฃผ์ ์ฐจ์ด์ ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
1) ํฌ๊ธฐ ์กฐ์
- ๋ฐฐ์ด์ ์ ์ ์ผ๋ก ํฌ๊ธฐ๊ฐ ๊ณ ์ ๋์ด ์๊ธฐ ๋๋ฌธ์ ํฌ๊ธฐ๋ฅผ ๋ณ๊ฒฝํ ์ ์์ต๋๋ค. ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ๋ณ๊ฒฝํ๋ ค๋ฉด ์๋ก์ด ๋ฐฐ์ด์ ์์ฑํ๊ณ ์ด์ ๋ฐฐ์ด์ ๊ฐ์ ๋ณต์ฌํด์ผ ํฉ๋๋ค.
- ArrayList๋ ๋์ ์ผ๋ก ํฌ๊ธฐ๊ฐ ์กฐ์ ๋๊ธฐ ๋๋ฌธ์ ์์๋ฅผ ์ถ๊ฐํ๊ฑฐ๋ ์ญ์ ํ ๋ ์๋์ผ๋ก ํฌ๊ธฐ๋ฅผ ์กฐ์ ํฉ๋๋ค. ๋ด๋ถ์ ์ผ๋ก ๋ฐฐ์ด์ ์ฌ์ฉํ์ง๋ง, ํฌ๊ธฐ๊ฐ ๋์ ์ผ๋ก ์กฐ์ ๋์ด ์ฌ์ฉ์๋ ํฌ๊ธฐ์ ๋ณํ๋ฅผ ์ ๊ฒฝ์ฐ์ง ์์๋ ๋ฉ๋๋ค.
2) ์๋ฃํ
- ๋ฐฐ์ด์ ๋์ผํ ์๋ฃํ์ ์์๋ง ์ ์ฅํ ์ ์์ต๋๋ค. ์ฆ, ๋ฐฐ์ด์ ์ ์ ์ธ ํ์ ์ ๊ฐ์ง๊ณ ์์ต๋๋ค.
- ArrayList๋ ์ ๋ค๋ฆญ์ ์ฌ์ฉํ์ฌ ๋ค์ํ ์๋ฃํ์ ์์๋ฅผ ์ ์ฅํ ์ ์์ต๋๋ค. ์ฆ, ArrayList๋ ๋์ ์ผ๋ก ํ์ ์ด ๊ฒฐ์ ๋ฉ๋๋ค.
3) ์๋ ๋ฐ์ฑ ๋ฐ ์ธ๋ฐ์ฑ
- ๋ฐฐ์ด์ ์์ ์๋ฃํ(primitive types)๊ณผ ๊ฐ์ฒด ์๋ฃํ(Object types)์ ๊ตฌ๋ถํ์ฌ ์ ์ฅํฉ๋๋ค. ๋ฐ๋ผ์ ์์ ์๋ฃํ์ ๊ฐ์ฒด๋ก ์ ์ฅํ๊ธฐ ์ํด์๋ ์๋์ผ๋ก ๋ฐ์ฑ(boxing)๊ณผ ์ธ๋ฐ์ฑ(unboxing)์ ํด์ผ ํฉ๋๋ค.
- ArrayList๋ ๋ชจ๋ ์์๋ฅผ ๊ฐ์ฒด๋ก ์ ์ฅํ๋ฏ๋ก, ์์ ์๋ฃํ์ ๊ฐ์ฒด๋ก ๋ณํํ๋ ๋ฐ์ฑ๊ณผ ๋ฐ๋๋ก, ๊ฐ์ฒด๋ฅผ ์์ ์๋ฃํ์ผ๋ก ๋ณํํ๋ ์ธ๋ฐ์ฑ ์์ ์ ์๋์ผ๋ก ์ฒ๋ฆฌํด์ค๋๋ค.
ArrayList๋ ๋ฐฐ์ด๊ณผ ๋น๊ตํ์ฌ ํฌ๊ธฐ๊ฐ ๋์ ์ผ๋ก ์กฐ์ ๋๊ณ ๋ค์ํ ์๋ฃํ์ ์์๋ฅผ ์ ์ฅํ ์ ์๋ ์ฅ์ ์ด ์์ต๋๋ค. ์ด๋ก ์ธํด ๋ฐฐ์ด๋ณด๋ค ๋ ํธ๋ฆฌํ๊ฒ ์ฌ์ฉํ ์ ์์ผ๋ฉฐ, ์ถ๊ฐ์ ์ธ ๋ฉ์๋๋ฅผ ์ ๊ณตํ์ฌ ์์๋ฅผ ์ฝ๊ฒ ์ถ๊ฐ, ์ญ์ , ์์ ํ ์ ์์ต๋๋ค.
5. ArrayList์ ํ์ฉ ์์ ๋ฐ ์ฃผ์์ฌํญ
ArrayList์ ํ์ฉ ์์
๋ค์์ ArrayList์ ํ์ฉ ์์ ์ ๋๋ค.
import java.util.ArrayList;
public class ArrayListExample {
public static void main(String[] args) {
// ArrayList ์์ฑ
ArrayList<String> students = new ArrayList<>();
// ์์ ์ถ๊ฐ
students.add("Tom");
students.add("Jerry");
students.add("Alice");
students.add("Bob");
students.add("Emma");
// ์์ ์ ๊ทผ
System.out.println(students.get(2)); // Alice
// ์์ ์์
students.set(1, "Mickey");
System.out.println(students.get(1)); // Mickey
// ์์ ์ญ์
students.remove(0);
System.out.println(students); // [Mickey, Alice, Bob, Emma]
// ArrayList ํฌ๊ธฐ
int size = students.size();
System.out.println(size); // 4
}
}
์ ์์ ์์๋ ArrayList๋ฅผ ํ์ฉํ์ฌ ํ์๋ค์ ์ด๋ฆ์ ์ ์ฅํ๊ณ ๊ด๋ฆฌํฉ๋๋ค. add()
๋ฉ์๋๋ก ํ์ ์ด๋ฆ์ ์ถ๊ฐํ๊ณ , get()
๋ฉ์๋๋ก ํน์ ์์น์ ์๋ ํ์ ์ด๋ฆ์ ์ ๊ทผํฉ๋๋ค. ๋ํ, set()
๋ฉ์๋๋ก ํ์ ์ด๋ฆ์ ์์ ํ๊ณ , remove()
๋ฉ์๋๋ก ํ์ ์ด๋ฆ์ ์ญ์ ํฉ๋๋ค. ๋ง์ง๋ง์ผ๋ก, size()
๋ฉ์๋๋ก ArrayList์ ํฌ๊ธฐ๋ฅผ ํ์ธํฉ๋๋ค.
ArrayList์ ์ฃผ์์ฌํญ
ArrayList๋ฅผ ์ฌ์ฉํ ๋ ์ฃผ์ํด์ผ ํ ๋ช ๊ฐ์ง ์ฌํญ์ด ์์ต๋๋ค.
1) ์์์ ์ธ๋ฑ์ค
ArrayList์ ์์์ ์ธ๋ฑ์ค๋ 0๋ถํฐ ์์ํฉ๋๋ค. ๋ฐ๋ผ์ ์ฒซ ๋ฒ์งธ ์์๋ฅผ ์ ๊ทผํ ๋๋ ์ธ๋ฑ์ค 0์ ์ฌ์ฉํด์ผ ํฉ๋๋ค.
2) ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋
ArrayList๋ ๋์ ์ผ๋ก ํฌ๊ธฐ๊ฐ ์กฐ์ ๋๊ธฐ ๋๋ฌธ์ ์ถ๊ฐ/์ญ์ ์์
์ด ๋น๋ฒํ๊ฒ ๋ฐ์ํ ๊ฒฝ์ฐ, ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ด ๋์ด๋ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ๋๋์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ ๋๋ ArrayList๊ฐ ์๋ ๋ค๋ฅธ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ณ ๋ คํด์ผ ํฉ๋๋ค.
3) ๋๊ธฐํ
ArrayList๋ ์ค๋ ๋์ ์์ ํ์ง ์์ต๋๋ค. ์ฌ๋ฌ ์ค๋ ๋์์ ๋์์ ArrayList๋ฅผ ์์ ํ๋ฉด ๋ถ์ผ์น(inconsistent)ํ ์ํ๊ฐ ๋ ์ ์์ต๋๋ค. ์ค๋ ๋์ ์์ ํ ๋๊ธฐํ๋ ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํด์ผ ํ ๊ฒฝ์ฐ, ArrayList ๋์ Vector
๋ CopyOnWriteArrayList
๋ฅผ ์ฌ์ฉํด์ผ ํฉ๋๋ค.
ArrayList๋ฅผ ์ฌ์ฉํ ๋์๋ ์ธ๋ฑ์ค์ ์์ ๊ฐ, ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋, ๋๊ธฐํ ๋ฑ์ ์ฃผ์ํด์ผ ํฉ๋๋ค. ์ด๋ฅผ ๊ณ ๋ คํ์ฌ ArrayList๋ฅผ ์ ์ ํ ํ์ฉํ๋ฉด ํธ๋ฆฌํ๊ฒ ์์๋ฅผ ์ถ๊ฐ, ์ญ์ , ์ ๊ทผํ ์ ์์ต๋๋ค.
๋๊ธ