1. ์ ๋ค๋ฆญ์ค(Generics)
์ ๋ค๋ฆญ์ค๋?
์ ๋ค๋ฆญ์ค(generics)๋ ์๋ฐ J2SE 5.0 ๋ฒ์ ์ดํ์ ๋์
๋ ๊ฐ๋
์ผ๋ก, ์๋ฃํ์ ์์ ํ๊ฒ ์ฌ์ฉํ ์ ์๋๋ก ๋ง๋ค์ด ์ฃผ๋ ๊ธฐ๋ฅ์ด๋ค. ์ ๋ค๋ฆญ์ค๋ฅผ ์ฌ์ฉํ๋ฉด ์๋ฃํ์ ๊ฐ์ ๋ก ๋ฐ๊ฟ ๋ ์๊ธธ ์ ์๋ ์บ์คํ
(Casting) ์ค๋ฅ๋ฅผ ์ค์ผ ์ ์๋ค.
ArrayList๋ ์๋ฐ์ **์ ๋ค๋ฆญ์ค(Generics)**๋ฅผ ํ์ฉํ๋ ๋ํ์ ์ธ ์ปฌ๋ ์
ํด๋์ค์ด๋ค. ์ ๋ค๋ฆญ์ค<>๋ฅผ ์ฌ์ฉํ๋ฉด ArrayList์ ์ ์ฅํ ์์์ ํ์
์ ์ง์ ํ ์ ์๊ณ , ๋๋ถ์ ํ ๋ณํ ์์ด ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋ค. (ํ์
์์ ์ฑ ๋ณด์ฅ)
ArrayList๋ ArrayList<E> ํํ๋ก ์ ์ํ๋๋ฐ, ์ฌ๊ธฐ์ E๋ ์ ์ฅํ ์์์ ํ์
์ ๋ํ๋ด๋ ํ์
๋งค๊ฐ๋ณ์์ด๋ค. ArrayList<String>,ArrayList<Integer>์ฒ๋ผ ์ ๋ค๋ฆญ์ค๋ฅผ ์ฌ์ฉํ์ฌ ํน์ ํ์
๋ง ์ ์ฅํ๋๋ก ์ ํํ ์ ์๋ค.
์ผ๋ฐ์ ์ธ ๋ฐฉ์ : ArrayList<String> pitches = new ArrayList<String>();
์ ํธ๋๋ ๋ฐฉ์ : ArrayList<String> pitches = new ArrayList<>();
(๋ท ๋ถ๋ถ์ ์๋ฃํ์ ๋ช
ํํ๋ฏ๋ก ๊ตณ์ด ์ ์ง ์๋ ๊ฒ.)
(์คํ๋ ค ์๋ค์ ์๋ฃํ์ ๋ชจ๋ ์ ์ผ๋ฉด ์ธํ
๋ฆฌ์ ์ด์์๋ ๊ฒฝ๊ณ ๋ฉ์์ง๋ฅผ ์ถ๋ ฅํ๋ค. ใ
ใ
)
์ฌ์ค ์ ๋ค๋ฆญ์ค ๋์
์ (~J2SE 1.4)๊น์ง๋ ๋ค์๊ณผ ๊ฐ์ด ์ฌ์ฉํ๋ค.
ArrayList pitches = new ArrayList();
์ ๋ค๋ฆญ์ค ๋์
์ ํ์ ์ฐจ์ด๋ ArrayList ์๋ฃํ ๋ค์์ <String>์ด ์๋๊ฐ์ ์๋ค. ์ ๋ค๋ฆญ์ค๋ฅผ ํํํ <String>์ โArrayList์ ๋ด์ ์ ์๋ ์๋ฃํ์ String๋ฟ์ด๋คโ๋ผ๋ ๋ป์ด๋ค. ์ฆ, ์ ๋ค๋ฆญ์ค๋ฅผ ์ด์ฉํ๋ฉด ์๋ฃํ์ ์ข ๋ ๋ช
ํํ๊ฒ ์ฒดํฌํ ์ ์๋ค๋ ์ฅ์ ์ด ์๋ค.
J2SE 5.0 ์ดํ ๋ฒ์ ์์๋ ์ ๋ค๋ฆญ์ค๋ฅผ ์ฌ์ฉํ์ง ์๊ณ ์ฝ๋๋ฅผ ์์ฑํด๋ ์ค๋ฅ๋ ๋์ง ์๋๋ค. ๋ค๋ง, ์ ๋ค๋ฆญ์ค ์๋ฃํ์ ๋ช ํํ๊ฒ ์ง์ ํ๋ผ๋ ๊ฒฝ๊ณ ๋ฉ์์ง๊ฐ ์ถ๋ ฅ๋๋ค.
์ ๋ค๋ฆญ์ค๋ฅผ ์ ์ฐ๋ฉด?
ArrayList pitches = new ArrayList();
pitches.add("138");
pitches.add("129");
String one = (String) pitches.get(0);
String two = (String) pitches.get(1);
์ ๋ค๋ฆญ์ค๋ฅผ ์ฌ์ฉํ์ง ์์ผ๋ฉด ArrayList์ ์ถ๊ฐํ๋ ๊ฐ์ฒด๋ Object ์๋ฃํ์ผ๋ก ์ธ์๋๋ค. Object ์๋ฃํ์ ๋ชจ๋ ๊ฐ์ฒด๊ฐ ์์ํ๊ณ ์๋ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ์๋ฃํ์ด๋ค. ๋ฐ๋ผ์ ArrayList ๊ฐ์ฒด์ ๊ฐ์ ๋ฃ์ ๋๋ ๋ฌธ์ ๊ฐ ์์ง๋ง ๊ฐ์ ๊ฐ์ ธ์ฌ ๋๋ ๋งค๋ฒ Object ์๋ฃํ์์ String ์๋ฃํ์ผ๋ก ํ ๋ณํ(casting) ์ ํด์ผ ํ๋ค.
String one = (String) pitches.get(0); // Object ์๋ฃํ์ String ์๋ฃํ์ผ๋ก ํ ๋ณํ
์ฌ๊ธฐ์ ๋ฌธ์ ๋๋ ์ ์ pitches์๋ String ์ธ์ ๋ค๋ฅธ ๊ฐ์ฒด๋ ๋ฃ์ ์ ์์ด์ ํ ๋ณํ ์ค๋ฅ๊ฐ ๋ฐ์ํ ์ ์๋ค๋ ๊ฒ์ด๋ค. ์ด๋ฌํ ์ค๋ฅ๋ฅผ ๋ฐฉ์งํ๊ณ ํ์
์์ ์ฑ์ ๋ณด์ฅํด์ฃผ๋ ๊ฒ์ด ์ ๋ค๋ฆญ์ค์ด๋ค.
ArrayList<String> pitches = new ArrayList<>();
pitches.add("138");
pitches.add("129");
String one = pitches.get(0); // ํ ๋ณํ์ด ํ์์๋ค.
String two = pitches.get(1); // ํ ๋ณํ์ด ํ์์๋ค.
์ ๋ค๋ฆญ์ค๋ก ์๋ฃํ์ ์ ์ธ๋ง ํ๋ฉด ๊ทธ ์ดํ๋ก๋ ์๋ฃํ์ ํ ๋ณํํ๋ ๊ณผ์ ์ด ํ์ ์๋ค. pitches์๋ ๋ฐ๋์ String ์๋ฃํ๋ง ์ถ๊ฐ๋์ด์ผ ํ๋ค๋ ๊ฒ์ ์ปดํ์ผ๋ฌ๊ฐ ์ด๋ฏธ ์๊ธฐ ๋๋ฌธ์ด๋ค. ์ด์ฒ๋ผ ์ ๋ค๋ฆญ์ค๋ฅผ ์ด์ฉํ๋ฉด ํ ๋ณํ๊ณผ ๊ด๋ จ๋ ๋ถํ์ํ ์ฝ๋ฉ์ ์ค์ผ ์ ์๊ณ , ์๋ชป๋ ํ ๋ณํ ๋๋ฌธ์ ๋ฐ์ํ๋ ๋ฐํ์ ์ค๋ฅ๋ฅผ ๋ฐฉ์งํ ์ ์๋ค.
2. ArrayList ์ ์ธ
ArrayList๋ ์๋ฐ์์ ๋์ ์ผ๋ก ํฌ๊ธฐ๋ฅผ ์กฐ์ ํ ์ ์๋ ๋ฐฐ์ด๋ก, java.util ํจํค์ง์ ํฌํจ๋ ๋ฆฌ์คํธ(List) ์ธํฐํ์ด์ค์ ๊ตฌํ์ฒด์
๋๋ค. ์ผ๋ฐ์ ์ธ ๋ฐฐ์ด๊ณผ ๋ฌ๋ฆฌ, ์์๋ฅผ ์ถ๊ฐํ๊ฑฐ๋ ์ ๊ฑฐํ ๋๋ง๋ค ํฌ๊ธฐ๊ฐ ์๋์ผ๋ก ๋ณ๊ฒฝ๋๊ธฐ ๋๋ฌธ์ ๋ฐ์ดํฐ ์ ์ฅ์ด ์ ์ฐํ๋ค.
๋ค์์ ์ฌ๋ฌ ๊ฐ์ง ๋ฐฉ๋ฒ์ผ๋ก ArrayList ์ ์ธํ๋ ๋ฒ์ด๋ค.
1. add ๋ฉ์๋๋ก ArrayList ๊ฐ์ฒด์ ์์ ์ถ๊ฐ
2. asList ๋ฉ์๋๋ก ์ด๋ฏธ ์กด์ฌํ๋ String ๋ฐฐ์ด์ ๊ฐ์ง๊ณ ArrayList ๋ง๋ค๊ธฐ
3. String ๋ฐฐ์ด ๋์ String ์๋ฃํ์ ์ฌ๋ฌ ๊ฐ ์ ๋ฌํ์ฌ ์์ฑ
2-1. add() ๋ฉ์๋
add() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด ArrayList ๊ฐ์ฒด์ ์์๋ฅผ ์ถ๊ฐํ ์ ์๋ค.
import java.util.ArrayList;
public class Sample {
public static void main(String[] args) {
ArrayList<String> pitches = new ArrayList<>(); // ์ ๋ค๋ฆญ์ค๋ฅผ ์ฌ์ฉํ ํํ
pitches.add("138");
pitches.add("129");
pitches.add("142");
System.out.println(pitches); // [138, 129, 142] ์ถ๋ ฅ
}
}
2-2. Arrays.asList() ๋ฉ์๋
java.util.Arrays ํด๋์ค์์ ์ ๊ณตํ๋ Arrays.asList()๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด ์ด๋ฏธ ์กด์ฌํ๋ String ๋ฐฐ์ด์ ์ด๋ ์ด๋ฆฌ์คํธ๋ก ๋ง๋ค ์ ์๋ค.
import java.util.ArrayList;
import java.util.Arrays;
public class Sample {
public static void main(String[] args) {
String[] data = {"138", "129", "142"}; // ์ด๋ฏธ ํฌ๊ตฌ์ ๋ฐ์ดํฐ ๋ฐฐ์ด์ด ์๋ค.
ArrayList<String> pitches = new ArrayList<>(Arrays.asList(data));
System.out.println(pitches); // [138, 129, 142] ์ถ๋ ฅ
}
}
2-3. String ๋ฐฐ์ด ๋์ String ์๋ฃํ์ ์ฌ๋ฌ ๊ฐ ์ ๋ฌ
import java.util.ArrayList;
import java.util.Arrays;
public class Sample {
public static void main(String[] args) {
ArrayList<String> pitches =
new ArrayList<>(Arrays.asList("138", "129", "142"));
System.out.println(pitches);
}
}
3. ์ฃผ์ ArrayList ๋ฉ์๋
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class ArrayListMethodsExample {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
// ์์ ์ถ๊ฐ
list.add("Apple");
list.add("Banana");
list.add(1, "Orange"); // ์ธ๋ฑ์ค 1์ Orange ์ฝ์
System.out.println("์ด๊ธฐ ๋ฆฌ์คํธ: " + list);
// ํน์ ์์ ์ ๊ทผ
String fruit = list.get(1);
System.out.println("์ธ๋ฑ์ค 1์ ์์: " + fruit);
// ์์ ์์
list.set(1, "Grape");
System.out.println("์์ ํ ๋ฆฌ์คํธ: " + list);
// ํน์ ์์ ์ ๊ฑฐ
list.remove("Grape");
System.out.println("์์ ์ ๊ฑฐ ํ ๋ฆฌ์คํธ: " + list);
// ๋ฆฌ์คํธ๊ฐ ๋น์ด ์๋์ง ํ์ธ
System.out.println("๋ฆฌ์คํธ๊ฐ ๋น์ด ์๋๊ฐ? " + list.isEmpty());
// ํน์ ์์ ํฌํจ ์ฌ๋ถ ํ์ธ
System.out.println("Banana๊ฐ ํฌํจ๋์ด ์๋๊ฐ? " + list.contains("Banana"));
// ๋ฆฌ์คํธ ํฌ๊ธฐ ํ์ธ
System.out.println("๋ฆฌ์คํธ ํฌ๊ธฐ: " + list.size());
// ๋ฐฐ์ด๋ก ๋ณํ
String[] array = list.toArray(new String[0]);
System.out.println("๋ฐฐ์ด๋ก ๋ณํ: " + Arrays.toString(array));
// ๋ชจ๋ ์์ ์ ๊ฑฐ
list.clear();
System.out.println("๋ชจ๋ ์์ ์ ๊ฑฐ ํ ๋ฆฌ์คํธ: " + list);
}
}
add(E element)
๋ฆฌ์คํธ์ ๋์ ์์ ์ถ๊ฐ
ArrayList<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
System.out.println(list); // ์ถ๋ ฅ: [Apple, Banana]
add(int index, E element)
์ง์ ํ ์ธ๋ฑ์ค์ ์์๋ฅผ ์ฝ์ ํ๊ณ , ๊ทธ ๋ค์ ์์๋ค์ ํ ์นธ์ฉ ๋ค๋ก ์ด๋
list.add(1, "Orange");
System.out.println(list); // ์ถ๋ ฅ: [Apple, Orange, Banana]
get(int index)
์ง์ ํ ์ธ๋ฑ์ค์ ์์๋ฅผ ์ฃผ์ด์ง ๊ฐ์ผ๋ก ๋ณ๊ฒฝ
list.set(1, "Grape");
System.out.println(list); // ์ถ๋ ฅ: [Apple, Grape, Banana]
remove(int index)
์ง์ ํ ์ธ๋ฑ์ค์ ์์๋ฅผ ์ ๊ฑฐํ๊ณ , ๊ทธ ๋ค์ ์์๋ค์ ํ ์นธ์ฉ ์์ผ๋ก ์ด๋
list.remove(1);
System.out.println(list); // ์ถ๋ ฅ: [Apple, Banana]
remove(Object o)
๋ฆฌ์คํธ์์ ์ฒ์์ผ๋ก ๋ฐ๊ฒฌ๋ ์ง์ ๋ ๊ฐ์ฒด๋ฅผ ์ ๊ฑฐํฉ๋๋ค. ๊ฐ์ฒด๊ฐ ์กด์ฌํ์ง ์์ผ๋ฉด ๋ณํ ์์.
list.remove("Banana");
System.out.println(list); // ์ถ๋ ฅ: [Apple]
size()
๋ฆฌ์คํธ์ ํ์ฌ ์์ ๊ฐ์๋ฅผ ๋ฐํ(ํฌ๊ธฐ ๋ฐํ)
int size = list.size();
System.out.println(size); // ์ถ๋ ฅ: 1
clear()
๋ฆฌ์คํธ์ ๋ชจ๋ ์์๋ฅผ ์ ๊ฑฐ
list.clear();
System.out.println(list); // ์ถ๋ ฅ: []
isEmpty()
๋ฆฌ์คํธ๊ฐ ๋น์ด ์์ผ๋ฉด true๋ฅผ, ๊ทธ๋ ์ง ์์ผ๋ฉด false๋ฅผ ๋ฐํํฉ๋๋ค.
boolean empty = list.isEmpty();
System.out.println(empty); // ์ถ๋ ฅ: true
contains(Object o)
๋ฆฌ์คํธ์ ์ง์ ๋ ์์๊ฐ ํฌํจ๋์ด ์๋์ง ํ์ธํ์ฌ true ๋๋ false๋ฅผ ๋ฐํ
list.add("Apple");
boolean containsApple = list.contains("Apple");
System.out.println(containsApple); // ์ถ๋ ฅ: true
indexOf(Object o)
๋ฆฌ์คํธ์์ ํน์ ์์๊ฐ ์ฒ์ ๋ํ๋๋ ์ธ๋ฑ์ค๋ฅผ ๋ฐํํฉ๋๋ค. ์์๊ฐ ์์ผ๋ฉด -1์ ๋ฐํ
list.add("Banana");
int index = list.indexOf("Banana");
System.out.println(index); // ์ถ๋ ฅ: 1
lastIndexOf(Object o)
๋ฆฌ์คํธ์์ ํน์ ์์๊ฐ ๋ง์ง๋ง์ผ๋ก ๋ํ๋๋ ์ธ๋ฑ์ค๋ฅผ ๋ฐํํฉ๋๋ค. ์์๊ฐ ์์ผ๋ฉด -1์ ๋ฐํ
list.add("Banana");
list.add("Apple");
list.add("Banana");
int lastIndex = list.lastIndexOf("Banana");
System.out.println(lastIndex); // ์ถ๋ ฅ: 3
toArray()
ArrayList์ ๋ชจ๋ ์์๋ฅผ ํฌํจํ๋ Object ๋ฐฐ์ด์ ๋ฐํ
Object[] array = list.toArray();
System.out.println(Arrays.toString(array)); // ์ถ๋ ฅ: [Apple, Banana]
toArray(T[] a)
ArrayList์ ๋ชจ๋ ์์๋ฅผ ํฌํจํ๋ ํน์ ํ์ ์ ๋ฐฐ์ด์ ๋ฐํ
String[] array = list.toArray(new String[0]);
System.out.println(Arrays.toString(array)); // ์ถ๋ ฅ: [Apple, Banana]
subList(int fromIndex, int toIndex)
์ง์ ๋ ๋ฒ์์ ์๋ ์์์ **๋ทฐ(view)**๋ฅผ ๋ฐํ, ์์ ์ธ๋ฑ์ค๋ ํฌํจ๋๊ณ , ๋ ์ธ๋ฑ์ค๋ ๋ถํฌํจ
List<String> subList = list.subList(0, 2);
System.out.println(subList); // ์ถ๋ ฅ: [Apple, Banana]
4. String.join
ArrayList์ ์์๋ค์ ๊ตฌ๋ถ์๋ฅผ ๋ฃ์ด์ 1๊ฐ์ ๋ฌธ์์ด๋ก ๋ฐํํ ๋ ์ฐ๋ ๋ฉ์๋์ด๋ค.
์๋ฅผ ๋ค๋ฉด, ํ์ฌ ๋ฆฌ์คํธ์ ๋ค์ด ์๋ ๋ด์ฉ์ด ["๋ฐ๋๋", "์ฌ๊ณผ", "ํฌ๋"]์ธ๋ฐ ์ฝค๋ง๋ฅผ ๊ฐ ์์ ์ค๊ฐ์ ๋ฃ์ด์ ํ๋์ ๋ฌธ์์ด๋ก ๋ฐํํด ์ฃผ๋ ค๊ณ ํ๋ค.
String.join ๋ฉ์๋๋ฅผ ์ฐ์ง ์์ผ๋ฉด for ๋ฃจํ๋ฅผ ์ฌ์ฉํด pitches ๋ฆฌ์คํธ์ ๋ชจ๋ ์์๋ฅผ StringBuilder ๊ฐ์ฒด์ ์ถ๊ฐํ๋ค. ๊ฐ ์์ ๋ค์ ,๋ฅผ ์ถ๊ฐํ๋๋ฐ ์ด ๋ result.substring(0, result.length() - 1)์ ์ฌ์ฉํ์ฌ ๋ง์ง๋ง์ ์ถ๊ฐ๋ ์ฝค๋ง๋ฅผ ์ ๊ฑฐํด์ผ๋ง ์ฐ๋ฆฌ๊ฐ ์ํ๋ ๊ฐ์ด ์ถ๋ ฅ๋๋ค.
import java.util.ArrayList;
import java.util.Arrays;
public class Sample {
public static void main(String[] args) {
ArrayList<String> pitches = new ArrayList<>(Arrays.asList("๋ฐ๋๋", "์ฌ๊ณผ", "ํฌ๋"));
StringBuilder result = new StringBuilder();
for (int i = 0; i < pitches.size(); i++) {
result.append(pitches.get(i));
result.append(",");
}
result.setLength(result.length() - 1); // ๋ง์ง๋ง ์ฝค๋ง ์ ๊ฑฐ
System.out.println(result.toString()); // ๋ฐ๋๋,์ฌ๊ณผ,ํฌ๋
}
}
์ ๊ณผ์ ์ ๋ ๊ฐ๋จํ๊ฒ ํด ์ฃผ๋ ๊ฒ์ด String.join("๊ตฌ๋ถ์",๋ฆฌ์คํธ๋ช
) ๋ฉ์๋์ด๋ค.
import java.util.ArrayList;
import java.util.Arrays;
public class Sample {
public static void main(String[] args) {
ArrayList<String> pitches = new ArrayList<>(Arrays.asList("๋ฐ๋๋", "์ฌ๊ณผ", "ํฌ๋"));
String result = String.join(",", pitches);
System.out.println(result); // ๋ฐ๋๋,์ฌ๊ณผ,ํฌ๋
}
}
5. ArrayList ์ ๋ ฌํ๊ธฐ
๋ฆฌ์คํธ๋ฅผ ์์๋๋ก ์ ๋ ฌํ๊ธฐ ์ํด์๋ sort()๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
public class Sample {
public static void main(String[] args) {
ArrayList<String> pitches = new ArrayList<>(Arrays.asList("138", "129", "142"));
pitches.sort(Comparator.naturalOrder()); // ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ
System.out.println(pitches); // [129, 138, 142] ์ถ๋ ฅ
}
}
sort ๋ฉ์๋์ ํ๋ผ๋ฏธํฐ๋ ์ ๋ ฌ๊ธฐ์ค์ด๋ค. ์ฆ, ์ค๋ฆ์ฐจ์๊ณผ ๋ด๋ฆผ์ฐจ์์ธ์ง ๋งค๊ฐ๋ณ์๋ฅผ ํตํด ํ์ ํด์ค๋ค.
- ์ค๋ฆ์ฐจ์(์๋ฐฉํฅ) ์ ๋ ฌ - Comparator.naturalOrder()
- ๋ด๋ฆผ์ฐจ์(์ญ๋ฐฉํฅ) ์ ๋ ฌ - Comparator.reverseOrder()
ํฌ์คํ
์์ฑ์ ์ฐธ์กฐํ ์๋ฃ
๋ฐ์์ฉ - ์ ํ ํฌ ์๋ฐ
chatGPT์ ์ง๋ฌธํด๊ฐ๋ฉฐ ์ฝ๋๋ฅผ ์์ฑํ์์.