[Java] Collection Framework - List Interface
by rlaehddnd0422List Interface
- ์ค๋ณต์ ํ์ฉํ๋ฉด์, ์ ์ฅ์์๊ฐ ์ ์ง๋๋ ์ปฌ๋ ์ ์ ๊ตฌํํ๋๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
- ๋ฐฐ์ด๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก index๋ฅผ ํตํด ์์์ ์ ๊ทผํ ์ ์์ต๋๋ค.
- ๋ฐฐ์ด๊ณผ ๋ฌ๋ฆฌ ๋ฆฌ์คํธ๋ ์๋ฃํ ํฌ๊ธฐ๊ฐ ๊ณ ์ ๋์ง ์๊ณ ๋์ ์ผ๋ก ๋์ด๋ฌ๋ค ์ค์ด๋ค์๋ค ํ ์ ์๋ ๊ฐ๋ณ์ ์ธ ์์๊ฐ ์์ต๋๋ค.
- ์์ ์ฌ์ด์ ๋น ๊ณต๊ฐ์ ํ์ฉํ์ง ์๊ธฐ ๋๋ฌธ์ ์ฝ์ /์ญ์ ์ ๋ฐฐ์ด ์ด๋์ด ์ผ์ด๋ฉ๋๋ค.
Method of List Interface
๋ฉ์๋ | ๊ธฐ๋ฅ |
void add(int index, Object element) boolean addAll(int index, Collection c) |
์ง์ ๋ index์ ๊ฐ์ฒด, ์ปฌ๋ ์ ์ถ๊ฐ |
Object remove(int index) | ์ง์ ๋ index์ ๊ฐ์ฒด ์ญ์ ํ ํด๋น ๊ฐ์ฒด ๋ฆฌํด |
Object get(int index) | ์ง์ ๋ index์ ๊ฐ์ฒด ๋ฆฌํด |
Object set(int index, Object element) | ์ง์ ๋ index์ ๊ฐ์ฒด ์ ์ฅ |
int indexOf(Object o) | ์ง์ ๋ ๊ฐ์ฒด์ index ๋ฆฌํด (->) |
int lastIndexOf(Object o) | ์ง์ ๋ ๊ฐ์ฒด์ index ๋ฆฌํด (<-) |
List subList(int fromIndex, int toIndex) | fromIndex ~ toIndex์ ๊ฐ์ฒด๋ฅผ ๋ฆฌํด |
ListIterator listIterator() ListIterator listIterator(int index) |
List์ ๊ฐ์ฒด์ ์ ๊ทผํ ์ ์๋ ListIterator๋ฅผ ๋ฆฌํด |
void sort(Comparator c) | ์ง์ ๋ ๋น๊ต์๋ก List๋ฅผ ์ ๋ ฌ |
List ์ธํฐํ์ด์ค์ ๊ตฌํ์ฒด๋ก๋ ArrayList, LinkedList, Stack, Vector ํด๋์ค๊ฐ ์์ต๋๋ค.
์์ฐจ์ ์ผ๋ก ํ๋์ฉ ์์๋ด ์๋ค.
1. ArrayList class Implements List
- ArrayList ํด๋์ค๋ ๋ฐฐ์ด์ ์ด์ฉํด ๋ง๋ ๋ฆฌ์คํธ๋ก, ์์์ ์ค๋ณต์ ํ์ฉํ๊ณ , ์ ์ฅ ์์๊ฐ ์ ์ง๋๋ค๋ ํน์ง์ด ์์ต๋๋ค.
- ArrayList๋ ๊ธฐ์กด์ Vector๋ฅผ ๊ฐ์ ํ ๊ฒ์ผ๋ก Vector์ ๊ตฌํ ์๋ฆฌ์ ๊ธฐ๋ฅ์ ์ธ ์ธก๋ฉด์ด ๋์ผํ์ง๋ง, Vector๋ ๊ธฐ์กด ์์ค์์ ํธํ์ ์ํด ๋จ๊ฒจ๋๊ฒ์ด๋ผ, ๊ฐ๋ฅํ๋ฉด Vector๋ฅผ ์ฌ์ฉํ๊ธฐ๋ณด๋ค ArrayList๋ฅผ ์ฌ์ฉํฉ์๋ค.
- ๊ฐ์ฒด๊ฐ ์ถ๊ฐ๋๋ฉด size๊ฐ ๋์ด๋๊ณ , ์ญ์ ๋๋ฉด size๊ฐ ์ค์ด๋๋ ๊ฐ๋ณ์ฑ์ ์ง๋๋๋ค.
- ์ฅ์ : ๋จ๋ฐฉํฅ ํฌ์ธํฐ ๊ตฌ์กฐ์ด๊ธฐ ๋๋ฌธ์ ์๋ฃ์ ๋ํ ์กฐํ(get())๋ ๋น ๋ฅธ ํธ(O(1))์ด๋ผ ๋ณผ ์ ์์ต๋๋ค.
- ๋จ์ : ์ฝ์
/์ญ์ ์ ๋ฐฐ์ด์ ์ด๋์ด ์ผ์ด๋๋ฏ๋ก ๋๋ฆฝ๋๋ค. (์์ฐจ์ ์ธ ์ฝ์
/์ญ์ ์ ๊ฒฝ์ฐ์๋ O(1))
- ์ฝ์ /์ญ์ ์์น๋ก ์ด๋ํ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ O(N) + ์ญ์ O(1) + ๋ฐฐ์ด ์ด๋์ด ํ์ํ ๊ฒฝ์ฐ ์ถ๊ฐ์๊ฐ ๋ฐ์ = O(N) + a
public class ArrayListTest {
public static void main(String[] args) {
List<Integer> l = new ArrayList<>(); // ์ ์ธ
l.add(1); // ์ถ๊ฐ
l.add(2); // ์ถ๊ฐ
l.add(3); // ์ถ๊ฐ
l.add(9); // ์ถ๊ฐ
l.add(9); // ์ถ๊ฐ
l.set(0, 3); // 0๋ฒ์งธ ์ธ๋ฑ์ค์ ๊ฐ 3์ผ๋ก ๋ณ๊ฒฝ
l.remove(4); // ์ธ๋ฑ์ค๋ก ์ ๊ฑฐ
l.remove(Integer.valueOf(3)); // ์ปฌ๋ ์
๋ด๋ถ๋ฅผ ์์ฐจ์ ์ผ๋ก ์กฐํํ์ฌ ๋๋ฑ(๊ฐ์ด ๋์ผ)ํ ๊ฐ์ฒด๊ฐ ์กด์ฌํ๋ฉด ํ๋ ์ ๊ฑฐ
int size = l.size(); // ํฌ๊ธฐ
Integer getFirst = l.get(0);// 0๋ฒ์งธ ์ธ๋ฑ์ค์ ๊ฐ์ฒด ๋ฆฌํด
boolean contains = l.contains(9); // ์์์ ์กด์ฌ ์ฌ๋ถ
int i = l.indexOf(9); // ์์์ ์ธ๋ฑ์ค ๋ฆฌํด (์์ผ๋ฉด -1๋ฆฌํด)
Iterator<Integer> iterator = l.iterator(); // ์ดํฐ๋ ์ดํฐ
while (iterator.hasNext()) { // ์ดํฐ๋ ์ดํฐ ์ํ
System.out.println(iterator.next()); // ์ดํฐ๋ ์ดํฐ ์ถ๋ ฅ
}
}
}
2. LinkedList class Implements List
- LinkedList๋ ๊ฐ์ฒด๋ฅผ ์ฐ๊ฒฐํ์ฌ ๋ฆฌ์คํธ์ฒ๋ผ ๋ง๋ค ์ปฌ๋ ์ ์ ๋๋ค. (๋ฐฐ์ด์ด ์๋)
- ๋ฐ์ดํฐ์ ์ค๊ฐ ์ฝ์
, ์ญ์ ๊ฐ ๋น๋ฒํ ๊ฒฝ์ฐ ๋น ๋ฅธ ์ฑ๋ฅ์ ๋ณด์ฅํฉ๋๋ค.
- ์ฝ์ /์ญ์ ์์น์ ๋ฐ๋ผ ๊ทธ ์์น๊น์ง ์ด๋ํ๋ ์๊ฐ O(N) + ํฌ์ธํฐ์ ์ด๋ O(1) = O(N)
- ๋จ์ : ์์์ ์์์ ๋ํ ์ ๊ทผ ์ฑ๋ฅ์ ์ข์ง ์์ ํธ์ ๋๋ค. ( ์ธ๋ฑ์ค๋ฅผ ์ด์ฉํ get() search๊ฐ ๋ถ๊ฐ๋ฅํ๊ธฐ ๋๋ฌธ์ ์์ฐจ์ ์ผ๋ก ์ฐพ์์ผ ํ๋ฏ๋ก O(N) )
- ์๋ฐฉํฅ ํฌ์ธํฐ ๊ตฌ์กฐ๋ก ๋ณธ์ธ์ ๊ฐ๋ฆฌํค๋ ๊ฐ์ฒด์ ๋ณธ์ธ์ด ๊ฐ๋ฆฌํค๋ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๋ ํํ
- ์คํ, ํ, ํธ๋ฆฌ ๋ฑ์ ์๋ฃ๊ตฌ์กฐ์ ๊ทผ๊ฐ์ด ๋๋ ์๋ฃ๊ตฌ์กฐ
public class LinkedListTest {
public static void main(String[] args) {
List<String> ll = new LinkedList<>(Arrays.asList("1st", "second", "third")); // ์ ์ธ ๋ฐ ์ด๊ธฐํ
List<String> ll2 = new LinkedList<>(); // ์ ์ธ
// ์ถ๊ฐ
ll.add("fourth");
ll.add("fifth");
// ๋ณ๊ฒฝ
ll.set(0, "first");
// ์ญ์
((LinkedList<String>) ll).removeFirst(); // ์ฒซ๋ฒ์งธ ์์ ์ญ์ (์
์บ์คํ
to LinkedList)
((LinkedList<String>) ll).removeLast(); // ๋ง์ง๋ง ์์ ์ญ์ (์
์บ์คํ
to LinkedList)
// ll.remove(2); // ์ธ๋ฑ์ค๋ก ์ญ์
// ํฌ๊ธฐ
int size = ll.size(); // ์ปฌ๋ ์
ํฌ๊ธฐ
// ๊ฒ์
String s = ll.get(0);// ์ธ๋ฑ์ค๋ก ๊ฒ์
String first = ((LinkedList<String>) ll).getFirst(); // ์ฒซ๋ฒ์งธ ์์ ๋ฆฌํด (์
์บ์คํ
to LinkedList)
String last = ((LinkedList<String>) ll).getLast(); // ๋ง์ง๋ง ์์ ๋ฆฌํด (์
์บ์คํ
to LinkedList)
// ์ดํฐ๋ ์ดํฐ
Iterator<String> iterator = ll.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
3. Vector class Implements List
- ArrayList์ ๊ตฌํ ๋ฒ์ ์ผ๋ก ๋ด๋ถ ๊ตฌ์ฑ์ด ๊ฑฐ์ ๋์ผํฉ๋๋ค.
- ๋ฉ์๋๊ฐ ๋๊ธฐํ๋์ด ์์ด ๋ฉํฐ ์ค๋ ๋ ํ๋ก๊ทธ๋๋ฐ์์ ์์ ํ๋ค๋ ์ฅ์ ์ด ์์ต๋๋ค.
- ์ฐ์ผ ์ผ์ด ๊ฑฐ์ ์๋ ํธ
4. Stack class Implements List
- LIFO(Last-In First-Out) ๊ตฌ์กฐ์ ์๋ฃ๊ตฌ์กฐ์ ๋๋ค.
- ๋ง์ง๋ง์ ๋ค์ด์จ ์์๊ฐ ๋จผ์ ๋๊ฐ๋ค๋ ํน์ง์ด ์์ต๋๋ค.
- push(์ฝ์ ) pop(์ ๊ฑฐ)๋ก๋ง ์ฝ์ /์ญ์ ๊ฐ ๊ฐ๋ฅ
- Vector class๋ฅผ ์์ํ๋ฏ๋ก ์ ์ฐ์ง ์๊ณ , Queue interface์ ArrayDeque๋ฅผ ์ฌ์ฉํ๋ ํธ
public class StackTest {
public static void main(String[] args) {
Stack<String> s = new Stack<>();
// ์ฝ์
s.push("FIRST");
s.push("SECOND");
s.push("THIRD");
System.out.println(s.peek()); // THIRD
s.pop(); // ์ ๊ฑฐ
Iterator<String> iterator = s.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
<์ฐธ๊ณ ์๋ฃ>
Java List Interface
In Java, the List interface is an ordered collection that allows us to store and access elements sequentially. It extends the Collection interface. Classes that Implement List Since List is an interface, we cannot create objects from it. In order to use fu
www.programiz.com
[Java] ์๋ฐ LinkedList ์ฌ์ฉ๋ฒ & ์์ ์ด์ ๋ฆฌ
LinkedList๋? ์ฐ๊ฒฐ ๋ฆฌ์คํธ(LinkedList)๋ ๊ฐ ๋ ธ๋๊ฐ ๋ฐ์ดํฐ์ ํฌ์ธํฐ๋ฅผ ๊ฐ์ง๊ณ ํ ์ค๋ก ์ฐ๊ฒฐ๋์ด ์๋ ๋ฐฉ์์ ์๋ฃ๊ตฌ์กฐ์ ๋๋ค. ๋ฐ์ดํฐ๋ฅผ ๋ด๊ณ ์๋ ๋ ธ๋๋ค์ด ์ฐ๊ฒฐ๋์ด ์๊ณ , ๋ ธ๋์ ํฌ์ธํฐ๊ฐ ์ด์ ๋ ธ
coding-factory.tistory.com
๐งฑ Java Collections Framework ์ข ๋ฅ ๐ฏ ์ด์ ๋ฆฌ
Java Collection Framework ์๋ฐ ์๋ด๊ธฐ๋ถ๋ค์ ์ปฌ๋ ์ ํ๋ ์์ํฌ๋ผ๋ ๋จ์ด์ ๋ญ๊ฐ ๊ฑฐ์ฐฝํ๊ณ ์ด๋ ค์ด ๋๋์ด ๋ค์ ์๊ฒ ์ง๋ง, ๊ทธ๋ฅ ์๋ฃ ๊ตฌ์กฐ(Data Structure) ์ข ๋ฅ์ ํํ๋ค์ ์๋ฐ ํด๋์ค๋ก ๊ตฌํํ ๋ชจ์์ง
inpa.tistory.com
๐งฑ ArrayList vs LinkedList ํน์ง & ์ฑ๋ฅ ๋น๊ต
LinkedList vs ArrayList ํน์ง ๋น๊ต LinkedList๊ฐ ๊ฐ๊ธฐ ๋ ธ๋๋ฅผ ๋๊ณ ์ฃผ์ ํฌ์ธํฐ๋ฅผ ๋งํฌํ๋ ์์ผ๋ก ์๋ฃ๋ฅผ ๊ตฌ์ฑํ ์ด์ ๋ ArrayList๊ฐ ๋ฐฐ์ด์ ์ด์ฉํ์ฌ ์์๋ฅผ ์ ์ฅํจ์ผ๋ก์จ ๋ฐ์ํ๋ ๋จ์ ์ ๊ทน๋ณตํ๊ธฐ ์ํด
inpa.tistory.com
[JAVA] LinkedList์ ๊ฐ๋ ๋ฐ ์ฌ์ฉ๋ฒ
์๋ ํ์ธ์ ์ด๋ฒ ํฌ์คํ ์์๋ LinkedList์ ๋ํด์ ์์๋ณด๊ฒ ์ต๋๋ค ๋ชฉ์ฐจ LinkedList๋? LinkedList ์ ์ธํ๊ธฐ LinkedList ๊ฐ ์ถ๊ฐํ๊ธฐ LinkedList ๊ฐ ๋ณ๊ฒฝํ๊ธฐ LinkedList ๊ฐ ์ญ์ ํ๊ธฐ LinkedList ํฌ๊ธฐ ๊ตฌํ๊ธฐ LinkedList
crazykim2.tistory.com
'๐ Java&Spring > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] ๊ฐ์ฒด์งํฅ ์ํ์ฒด์กฐ ์์น 9๊ฐ์ง์ ๋ํด ์์๋ณด์ (3) | 2023.10.16 |
---|---|
[Java] Collection Framework - Queue Interface (0) | 2023.10.05 |
[Java] ์ปฌ๋ ์ ํ๋ ์์ํฌ์ Collection Interface์ ๋ํด (0) | 2023.10.04 |
[Java] ๋ด๋ถ ํด๋์ค์ static์ด ๊ถ์ฅ๋๋ ์ด์ ์ ๋ํด (0) | 2023.10.03 |
[Java] ๋ด๋ถ ํด๋์ค(Inner class)์ ๋ํด (0) | 2023.10.03 |
๋ธ๋ก๊ทธ์ ์ ๋ณด
Study Repository
rlaehddnd0422