컬렉션 프레임워크 핵심 인터페이스와 특징
- List => 순서가 있는 데이터의 집합 / 데이터 중복 허용
- Set => 순서를 유지하지 않는 데이터의 집합 / 데이터 중복 허용X
- Map => 키와 값의 쌍으로 이루어진 데이터의 집합 / 순서 유지X 키 중복 허용X 값 중복 허용
- List Interface
- void add(int index, Object element) / boolean addAll(int index, Collection c)
- Object get(int index)
- int indexOf(Object o)
- int lastIndexOf(Object o)
- ListIterator listIterator() / ListIterator listIterator(int index)
- Object remove(int index)
- Object set(int index, Object element)
- void sort(Comparator c)
- List subList(int fromIndex, int toIndex)
- Map Interface
- void clear()
- boolean containsKey(Object key)
- boolean containsValue(Object value)
- Set entrySet()
- boolean equla(Object o)
- Object get(Object o)
- int hashCode()
- boolean isEmpty()
- Set keySet()
- Object put(Object key, Object value)
- void pullAll(Map t)
- Object remove(Object key)
- int size()
- Collection values()
- Map.Entry Interface
- boolean equals(Object o)
- Object getKey()
- Object getValue()
- int hashCode()
- Object setValue(Object value)
- ArrayList ---(추가, 삭제기능 향상)---> LinkedList(---->HashMap&TreeMap) ---->
Queue ----(검색, 범위검색, 정렬기능 향상)---> TreeMap ----> TreeSet ----(검색기능 향상) --->
HashMap ----> Properties ----(순서유지 기능향상)----> LinkedHashMap
----> HashSet ----(순서유지 기능향상)---> LinkedHashSet
public class MyCollection<T> {
private List<T> list;
(생성자)
// 해당 메소드에서만 유효한 제너릭 타입 U
public <U> MyCollection<U> map(Function<T, U> function) {
List<U> newList = new ArrayList<>();
foreach(d -> newList.add(function.apply(d)));
return new MyCollection(newList);
}
public MyCollection<T> filter(Predicate<T, U> predicate) {
List<U> newList = new ArrayList<>();
foreach(d -> {
if(predicate.test(d)) newList.add(d)
});
return new MyCollection(newList);
}
public int size() {
return list.size();
}
public void foreach(Consumer<T> consumer) {
for(int i = 0; i < list.size(); i++) {
T data = list.get(i);
consumer.accept(data);
}
}
}
public class Main {
(main) {
MyCollection<String> c1 = new MyCollection<>(Arrays.asList("A", "CA", "CCA", "CCCA", "CCA"));
MyCollection<String> c2 = c1.map(String::length);
c2.foreach(System.out::println);
// 위의 식을 아래처럼 요약 가능
// method chainning 방식
new MyCollection<>(Arrays.asList("A", "CA", "CCA", "CCCA", "CCA"));
.map(String::length)
.filter(i -> i % 2 == 1)
.foreach(System.out.println);
int s =new MyCollection<>(Arrays.asList("A", "CA", "CCA", "CCCA", "CCA"));
.map(String::length)
.filter(i -> i % 2 == 1)
.size();
}
}
LIST
- LinkedList
- 데이터가 가변적으로 늘었다 줄었다 하기만 하면 된다면 아무거나 사용가능
- List 인터페이스
- ArrayList (not synch)
- 멀티 쓰레드 환경이 아니다
- 내부적으로 Array를 가지고 있음
- Index를 통해 빠르게 값에 접근할 필요가 있으면 사용
- Vector (synch) 멀티쓰레드 환경에서 쓰레드 세이프하게 구현해야한다 하면 사용
- contains()
//contains가 찾을 수 있도록 equals를 만들어야 함
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
MyData myData = (MyData) o;
return value == myData.value;
}
@Override
public int hashCode() {
return Objects.hashCode(value);
}
Map
- Array 장점 + List 장점
- 유연하면서도 빠르게 값을 찾아낼 수 있는
- Map : Key -> hash function -> hash -> bucket index -> List -> Data
- Map<K, V>
- HashMap (sync X)
- HashTable (sync) -> thread-safe 병목현상 발생 -> ConcurrentHashMap 활용 (sync + high concurrency)
Set
- HashSet을 사용할땐 class에 Hashcode를 오버라이딩 해줘야 함
- TreeSet은 BinarySearch 사용
//Heap
//작은 값부터 꺼내옴 -> min heap 동작
PriorityQueue<Integer> pq = new PriorityQueue<>();
//이건 큰값부터
PriorityQueue<Integer> pq = new PriorityQueue<>(Comparator.reverseOrder());
// search는 indexOf, contains, remove 같은 곳에서 이미 구현되어 있음
// equals가 제공될 필요가 있다.
// 이진탐색 : Collections.binarySearch
// Comparable 가 구현되어 있어야 한다.
// 순서대로 정렬되어 있어야 한다.
Stack
- Stack<E>
- push(E item)
- pop()
Queue
- Queue<E>
- offer(E e)
- poll()
동기화된 컬렉션
return type | 메소드 | 설명 |
List<T> | synchronizedList(List<T> list) | List를 동기화된 List로 리턴 |
Map<K,V> | synchronizedMap(Map<K,V> m) | Map을 동기화된 Map으로 리턴 |
Set<T> | synchronizedSet(Set<T> s) | Set을 동기화된 Set으로 리턴 |
- Arraylist / HashSet / HashMap 은 동기화 처리가 되어있지 않기 때문에 동기화 수단이 필요
- Map<Integer, String> map = Collections.synchronizedMap(new HashMap<>()) 형식으로 동기화 가능
불변객체 생성 방법
// 정적 메소드 of() 사용
List<String> immutableList = List.of("A","B","C");
Set<String> immutableSet = set.of("A","B","C");
Map<Integer, String> immutableMap = map.of(
1, "A",
2, "B",
3, "C"
);
'프로그래밍 > JAVA' 카테고리의 다른 글
[Java] Generics (0) | 2024.03.30 |
---|---|
[Java] Enum (0) | 2024.03.30 |
[Java] Conception (0) | 2024.03.30 |
[Java] about java (0) | 2024.03.30 |
[Java] Operator / Scope (0) | 2024.03.30 |