지삐띠니야 메서드 알려줘

리스트 메서드 알려줘

List<Integer> list = new ArrayList<>();

// 리스트 끝에 요소 추가
list.add(10);                              // [10]
list.add(20);                              // [10, 20]
// 특정 인덱스에 요소 삽입
list.add(1, 15);                           // [10, 15, 20]

// 인덱스 위치 요소 제거
list.remove(0);                            // [15, 20]
// 해당 값과 같은 첫 번째 요소 제거
list.remove(Integer.valueOf(20));          // [15]

list.add(30);                              // [15, 30]
list.add(15);                              // [15, 30, 15]

// 특정 위치의 요소 반환
System.out.println(list.get(1));           // 30
// 특정 위치의 요소 변경
System.out.println(list.set(1, 20));       // [15, 20, 15]
// 리스트에 특정 값이 있는지 확인
System.out.println(list.contains(15));     // true
// 처음 나타나는 위치 반환 (없으면 -1)
System.out.println(list.indexOf(15));      // 0
// 마지막 나타나는 위치 반환
System.out.println(list.lastIndexOf(15));  // 2

// 리스트 길이 반환
System.out.println(list.size());           // 3
// 비어있는지 확인
System.out.println(list.isEmpty());        // false

// 여러 개 한꺼번에 추가
list.addAll(Arrays.asList(100, 200));      // [15, 20, 15, 100, 200]
// 특정 값 전체 제거
list.removeAll(Arrays.asList(15));         // [20, 100, 200]
// 특정 값 남기고 나머지 제거
list.retainAll(Arrays.asList(100, 200));   // [100, 200]
// 전체 요소 삭제
list.clear();                              // []

list.addAll(Arrays.asList(5, 2, 8, 1));

// 오름차순 정렬
Collections.sort(list);                    // [1, 2, 5, 8]
// 내림차순 정렬
Collections.sort(list, Collections.reverseOrder());  // [8, 5, 2, 1]

 

덱 메서드 알려줘

역할	주요 메서드
스택	push, pop, peek
큐	offer, poll, peek
덱	addFirst, addLast, removeFirst, removeLast, peekFirst, peekLast

// 스택처럼
Deque<String> stack = new ArrayDeque<>();

stack.push("Sweet");   // [Sweet]
stack.push("Potato");  // [Potato, Sweet]
stack.push("Chips");   // [Chips, Potato, Sweet]
System.out.println(stack.pop());   // Chips ... [Potato, Sweet]
System.out.println(stack.peek());  // Potato <- [Potato, Sweet]

// 큐처럼
Deque<String> queue = new ArrayDeque<>();

queue.offer("Sweet");   // [Sweet]
queue.offer("Potato");  // [Sweet, Potato]
queue.offer("Chips");   // [Sweet, Potato, Chips]
System.out.println(queue.poll());  // Sweet ... [Potato, Chips]
System.out.println(queue.peek());  // Potato <- [Potato, Chips]

// 덱처럼
Deque<String> deque = new ArrayDeque<>();

deque.add("Sweet");       // [Sweet]
deque.add("Potato");      // [Sweet, Potato]
deque.addFirst("Chips");  // [Chips, Sweet, Potato]
deque.addLast("Sweet");   // [Chips, Sweet, Potato, Sweet]
System.out.println(deque.removeFirst());  // Chips ... [Sweet, Potato, Sweet]
System.out.println(deque.removeLast());   // Sweet ... [Sweet, Potato]
System.out.println(deque.peekFirst());    // Sweet <- [Sweet, Potato]
System.out.println(deque.peekLast());     // Potato <- [Sweet, Potato]

// 기타 메서드
System.out.println(deque.contains("Sweet"));  // true
System.out.println(deque.size());             // 2
System.out.println(deque.isEmpty());          // false

예외	반환 값 있음
add 계열 + push는 공간 부족 시 예외 발생	offer 계열은 공간 부족 시 false 반환
remove 계열 + pop은 비어 있을 때 예외 발생	poll 계열은 비어 있을 때 null 반환
get 계열은 비어있을 때 예외 발생	peek 계열은 비어 있을 때 null 반환

 

우선순위 큐 메서드 알려줘

• 숫자는 작은 수가 먼저(오름차순)
• 문자열은 알파벳 빠른 게 문저(사전 순)

// 정수 최소 힙
PriorityQueue<Integer> pq = new PriorityQueue<>();

pq.offer(5);  // [5]
pq.offer(3);  // [3, 5]
pq.offer(7);  // [3, 5, 7]
System.out.println(pq.poll());  // 3 ... [5, 7]
System.out.println(pq.peek()); // 5 <- [5, 7]

// 정수 최대 힙
PriorityQueue<Integer> maxPq = new PriorityQueue<>(Collections.reverseOrder());

// 문자열 최소 힙
PriorityQueue<String> strPq = new PriorityQueue<>();

pq.offer("banana");  // [banana]
pq.offer("apple");   // [apple, banana]
pq.offer("cherry");  // [apple, banana, cherry]
System.out.println(pq.poll());  // apple ... [banana, cherry]
System.out.println(pq.peek());  // banana <- [banana, cherry]

// 문자열 최대 힙
PriorityQueue<String> maxStrPq = new PriorityQueue<>(Collections.reverseOrder());

// 기타 메서드
System.out.println(maxStrPq.contains("cherry"));  // true
System.out.println(maxStrPq.size());              // 2
System.out.println(maxStrPq.isEmpty());           // false