[Java] ์ปฌ๋ ์ ํ๋ ์์ํฌ์ Collection Interface์ ๋ํด
by rlaehddnd0422Java Collection Framework
์ปฌ๋ ์ ํ๋ ์์ํฌ๋ '๋ฐ์ดํฐ ๊ตฐ(๊ฐ์ฒด)์ ์ ์ฅํ๋ ํด๋์ค๋ค์ ํ์คํํ ์ค๊ณ'๋ฅผ ๋งํฉ๋๋ค.
์ปฌ๋ ์ ํ๋ ์์ํฌ๋ ๋ค์์ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ๋ ๋ฐ ํ์ํ ๋ค์ํ๊ณ ํ๋ถํ ํด๋์ค๋ค์ ์ ๊ณตํ๊ธฐ ๋๋ฌธ์, ์ผ์ผํ ๊ฐ๋ฐ์๊ฐ LinkedList์ ๊ฐ์ ์๋ฃ๊ตฌ์กฐ๋ฅผ C์ธ์ด์ฒ๋ผ ๊ตฌํํ ํ์์์ด ํ๋ ์์ํฌ๋ฅผ ๊ฐ์ ธ์์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
์ปฌ๋ ์ ํ๋ ์์ํฌ์๋ ์ค์ง ๊ฐ์ฒด๋ง ์ ์ฅํ ์ ์๊ธฐ ๋๋ฌธ์, int, double ๊ณผ ๊ฐ์ primitive ํ์ ์ ์ ์ฅํ ์ ์์ต๋๋ค.
๋ฐ๋ผ์ primitive ํ์ ์ ์ ์ฅํ๊ณ ์ ํ๋ค๋ฉด, wrapper ํ์ ์ผ๋ก ๋ณํํ์ฌ Integer, Double ๊ฐ์ฒด๋ก ๋ฐ์ฑํ์ฌ ์ ์ฅํด์ผ ํฉ๋๋ค.
+ '๊ฐ์ฒด๋ฅผ ๋ด๋๋ค'๋ ์๋ฏธ๋ ์ฃผ์๊ฐ์ ๋ด๋๋ค๋ ์๋ฏธ์ด๋ฏ๋ก, null ๋ํ ์ ์ฅ์ด ๊ฐ๋ฅ
์ฅ์
- ์ธํฐํ์ด์ค์ ๋คํ์ฑ์ ์ด์ฉํ ๊ฐ์ฒด์งํฅ์ ์ธ ์ค๊ณ๋ฅผ ํตํด ํ์คํ ๋์ด, ์ฌ์ฉ๋ฒ์ ์ตํ๊ธฐ ํธ๋ฆฌํ๊ณ ์ฌ์ฌ์ฉ์ฑ์ด ๋์ ์ฝ๋๋ฅผ ์์ฑํ ์ ์๋ค.
- ์ด๋ฏธ ๊ตฌํ๋ API๋ฅผ ์ฌ์ฉํ๋ฏ๋ก, ์๋ก์ด API๋ฅผ ์ตํ๊ณ ์ค๊ณํ๋ ์๊ฐ์ด ์ค์ด๋ ๋ค.
Collection Framework ์ข ๋ฅ
์ปฌ๋ ์ ํ๋ ์์ํฌ์๋ ํฌ๊ฒ ๋ณด๋ฉด Collection๊ณผ Map์ด ์์ต๋๋ค. Collection ์ธํฐํ์ด์ค ์์์๋ Iterable ์ธํฐํ์ด์ค๊ฐ ์กด์ฌ.
Iterable Interface
public interface Iterable<T> {
Iterator<T> iterator(); // ์ปฌ๋ ์
์์ ์ดํฐ๋ ์ดํฐ๋ฅผ ๊ตฌํ
default void forEach(Consumer<? super T> action) { // ํจ์ํ ํ๋ก๊ทธ๋๋ฐ ์ ์ฉ ๋ฃจํ ๋ฉ์๋
Objects.requireNonNull(action);
for (T t : this) {
action.accept(t);
}
}
default Spliterator<T> spliterator() { // ํ์ดํ๋ผ์ด๋ ๊ด๋ จ ๋ฉ์๋
return Spliterators.spliteratorUnknownSize(iterator(), 0);
}
}
* Collection ์ธํฐํ์ด์ค๊ฐ Iterable ์ธํฐํ์ด์ค๋ฅผ ์์๋ฐ๊ณ ์๋๋ฐ, ์ด๋ ๋จ์ง ๊ณตํต ๋ฉ์๋(* ์ปฌ๋ ์ ์ ์ํํ ๋ ์ฌ์ฉํ๋ Iterator ๊ฐ์ฒด๋ฅผ ๊ด๋ฆฌํ๋)๋ฅผ ๋ฝ์ ์ค๋ณต์ ์ ๊ฑฐํ๊ธฐ ์ํด Iterable ์ธํฐํ์ด์ค๋ฅผ ๋์ ํ ๊ฒ์ด๋ฏ๋ก, ์์ ๊ณ์ธต๋์์ ๋ณ ์๋ฏธ๋ ์์ต๋๋ค.
Collection Interface
Collection์ ๋ค์ List, Queue, Set์ผ๋ก ๋๋ ์ ์์ต๋๋ค. ๋ง์ฐฌ๊ฐ์ง๋ก List, Queue, Set์์ ์ฌ์ฉํ๋ ๊ณตํต ๋ฉ์๋๋ฅผ ํ๋๋ก ๋ฝ์ ๋ง๋ ์ธํฐํ์ด์ค๋ผ๊ณ ์๊ฐํ์๋ฉด ๋ฉ๋๋ค.
- List, Queue, Set์ ์์ํ๋ ์ค์ง์ ์ต์์ ์ปฌ๋ ์ ํ์ ์ผ๋ก, ์ด ์ธ ๊ฐ์ง ์ธํฐํ์ด์ค๋ค์ ์ ์บ์คํ (๋คํ์ฑ)์ผ๋ก ๋ค์ํ ์ข ๋ฅ์ ์ปฌ๋ ์ ์๋ฃํ์ ๋ฐ์ ์๋ฃ๋ฅผ ์ฝ์ ,์ญ์ ,ํ์์ด ๊ฐ๋ฅํฉ๋๋ค.
Collection Interface method
Collection ์ธํฐํ์ด์ค๋ List, Set, Queue์์ ๊ณตํต์ผ๋ก ์ฌ์ฉํ๋ ๋ฉ์๋๋ฅผ ๋ชจ์ ์ ์ธํด๋์ ์ธํฐํ์ด์ค์ ๋๋ค.
IDE์์ ๊ณต์ ๋ฌธ์๋ฅผ ํ์ธํ ์ ์์ต๋๋ค.
public interface Collection<E> extends Iterable<E> {
int size() // Collection์ ์ ์ฅ๋ ๊ฐ์ฒด์ ๊ฐ์ ๋ฆฌํด
boolean isEmpty(); // Collection์ด ๋น์ด์๋์ง ํ์ธ
boolean contains(Object o);
boolean containsAll(Collection<?> c); // ์ง์ ๋ ๊ฐ์ฒด๋ Collection์ ๊ฐ์ฒด๋ค์ด ํฌํจ๋์ด ์๋์ง ํ์ธ
Object[] toArray(); // Collection์ ์ ์ฅ๋ ๊ฐ์ฒด๋ฅผ ๊ฐ์ฒด ๋ฐฐ์ด(Object[])๋ก ๋ฆฌํด
<T> T[] toArray(T[] a); // ์ง์ ๋ ๋ฐฐ์ด์ Collection์ ๊ฐ์ฒด๋ฅผ ์ ์ฅํด์ ๋ฆฌํด
default <T> T[] toArray(IntFunction<T[]> generator) {
return toArray(generator.apply(0));
}
boolean add(E e);
boolean addAll(Collection<? extends E> c); // ์ง์ ๋ ๊ฐ์ฒด๋ Collection์ ๊ฐ์ฒด๋ค์ ์ถ๊ฐ
boolean remove(Object o);
boolean removeAll(Collection<?> c); // ์ง์ ๋ ๊ฐ์ฒด๋ Collection์ ๊ฐ์ฒด๋ค์ ์ญ์
boolean retainAll(Collection<?> c); // ์ง์ ๋ Collection์ ํฌํจ๋ ๊ฐ์ฒด๋ง์ ๋จ๊ธฐ๊ณ ๋ค๋ฅธ ๊ฐ์ฒด๋ค์ ์ญ์ ํ๋๋ฐ, ์ด ์์
์ผ๋ก ์ธํด Collection์ ๋ณํ๊ฐ ์๊ธฐ๋ฉด true, else false return
void clear(); // ์ปฌ๋ ์
์ด๊ธฐํ
boolean equals(Object o); // ๋์ผํ Collection์ธ์ง ๋น๊ต
int hashCode(); // Collection์ hash code ๋ฆฌํด
Iterator<E> iterator(); // Collection์ Iterator๋ฅผ ์ป์ด์ ๋ฆฌํด (์์ Iterable ์ธํฐํ์ด์ค๋ฅผ ์์)
@Override
default Spliterator<E> spliterator() { // ํ์ดํ๋ผ์ด๋ ๊ด๋ จ ๋ฉ์๋๋ก (์์ Iterable ์ธํฐํ์ด์ค๋ฅผ ์์๋ฐ์ ๊ตฌํ)
return Spliterators.spliterator(this, 0);
}
default Stream<E> stream() { // JDK 1.8 ver.
return StreamSupport.stream(spliterator(), false);
}
default Stream<E> parallelStream() { // JDK 1.8 ver.
return StreamSupport.stream(spliterator(), true);
}
default boolean removeIf(Predicate<? super E> filter) { // JDK 1.8 ver.
Objects.requireNonNull(filter);
boolean removed = false;
final Iterator<E> each = iterator();
while (each.hasNext()) {
if (filter.test(each.next())) {
each.remove();
removed = true;
}
}
return removed;
}
}
์ ๋ฉ์๋๋ฅผ ์ธ์์ ์ฌ์ฉํ๊ธฐ๋ณด๋ค, ํ์ ์ปฌ๋ ์ ์์ ๊ณตํต์ผ๋ก ์ฌ์ฉํ๋ ๋ฉ์๋๋ค์ ์ด๋ฐ ๊ฒ๋ค์ด ์๊ตฌ๋ ์ ๋๋ก ์์๋์๋ฉด ๋ฉ๋๋ค.
์ฝ๋๋ฅผ ๋ณด๋ฉด Iterable ์ธํฐํ์ด์ค์์ ์ ์ธํ Iterator<E> iterator() ๋ฉ์๋๋ฅผ ๊ตณ์ด Collection ์ธํฐํ์ด์ค์์ ๋์ผํ ๋ฉ์๋๋ฅผ ํ ๋ฒ ๋ ์ ์ธํ ๊ฒ์ ํ์ธํ ์ ์์ต๋๋ค. ์ถ์ธก์ปจ๋ฐ, ์ปฌ๋ ์ ์ ๋ฐ๋ณต ๊ฐ๋ฅํ ๊ฐ์ฒด๋ก ๊ฐ์กฐํ๊ธฐ ์ํด ํ ๋ฒ๋ ๋ช ์ํด์ค ๊ฒ์ด๋ผ๊ณ ์๊ฐ๋ฉ๋๋ค.
+ JDK 1.8๋ถํฐ๋ ํจ์ํ ํ๋ก๊ทธ๋๋ฐ์ ์ํด parallelStream, removeIf, stream, forEach ๋ํดํธ ๋ฉ์๋ ์ถ๊ฐ๋จ.
๋ค์ ํฌ์คํ ์์ ์ด์ด Collection ํ๋ ์์ํฌ์ List, Queue, Set์ ๋ํด ์์ฐจ์ ์ผ๋ก ์์๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
<์ฐธ๊ณ ์๋ฃ>
'๐ Backend > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] Collection Framework - Queue Interface (0) | 2023.10.05 |
---|---|
[Java] Collection Framework - List Interface (1) | 2023.10.04 |
[Java] ๋ด๋ถ ํด๋์ค์ static์ด ๊ถ์ฅ๋๋ ์ด์ ์ ๋ํด (0) | 2023.10.03 |
[Java] ๋ด๋ถ ํด๋์ค(Inner class)์ ๋ํด (0) | 2023.10.03 |
[Java] ์ธํฐํ์ด์ค๋ฅผ ์ด์ฉํ ๋คํ์ฑ๊ณผ ํ์ฉ (1) | 2023.10.02 |
๋ธ๋ก๊ทธ์ ์ ๋ณด
Study Repository
rlaehddnd0422