Stack / Queue / Deque / List / Set / Map / PriorityQueue

Stack /

• Stack<Integer> stack = new Stack<>();

Queue /

• Queue<Integer> queue = new LinkedList<>();

Deque /

• Deque<Integer> deque = new LinkedList<>();

List /

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

Set /

• Set<Integer> set = new HashSet<>();

Map /

• Map<Integer, String> map = new HashMap<>();

PriorityQueue(Heap-Min, Max)

• PriorityQueue<Integer> pq = new PriorityQueue<>();

import java.util.*;

public class Main
{
    public static void main(String[] args)
    {
        // Stack / Queue / Deque / List / Set / Map / PriorityQueue 
        // List
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        System.out.println(list);
        list.remove(2);
        System.out.println(list);
        list.add(2, 5);
        System.out.println(list);
        System.out.println(list.get(2));
        System.out.println(list.indexOf(4));
        System.out.println(list.size());
        System.out.println(list.contains(3));
        Collections.sort(list);
        System.out.println(list);
        Collections.reverse(list);
        System.out.println(list);
        list.clear();
        System.out.println(list);
        
        // Set
        Set<Integer> set = new HashSet<>();
        set.add(1);
        set.add(2);
        set.add(3);
        set.add(4);
        System.out.println(set);
        set.remove(2);
        System.out.println(set);
        System.out.println(set.contains(3)); 
        System.out.println(set.size());
        set.clear();
        System.out.println(set);
        
        // Map
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        map.put(4, "Four");
        System.out.println(map);
        map.remove(2);
        System.out.println(map);
        System.out.println(map.get(3));
        System.out.println(map.containsKey(4));
        System.out.println(map.containsValue("Two"));
        System.out.println(map.size());
        map.clear();
        System.out.println(map);
        
        // Stack
        Stack<Integer> stack = new Stack<>();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        System.out.println(stack);
        stack.pop();
        System.out.println(stack);
        System.out.println(stack.peek());
        System.out.println(stack.size());
        System.out.println(stack.isEmpty());
        stack.clear();
        System.out.println(stack);
        
        // Queue
        Queue<Integer> queue = new LinkedList<>();
        queue.add(1);
        queue.add(2);
        queue.add(3);
        queue.add(4);
        System.out.println(queue);
        queue.remove();
        System.out.println(queue);
        System.out.println(queue.peek());
        System.out.println(queue.size());
        System.out.println(queue.isEmpty());
        queue.clear();
        System.out.println(queue);
            
        // Deque
        Deque<Integer> deque = new LinkedList<>();
        deque.addFirst(1);
        deque.addFirst(2);
        deque.addLast(3);
        deque.addLast(4);
        System.out.println(deque);
        deque.removeFirst();
        System.out.println(deque);
        deque.removeLast();
        System.out.println(deque);
        System.out.println(deque.peekFirst());
        System.out.println(deque.peekLast());
        System.out.println(deque.size());
        System.out.println(deque.isEmpty());
        deque.clear();
        System.out.println(deque);
        
        // PriorityQueue
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        pq.add(4);
        pq.add(2);
        pq.add(3);
        pq.add(1);
        System.out.println(pq);
        pq.remove();
        System.out.println(pq);
        System.out.println(pq.peek());
        System.out.println(pq.size());
        System.out.println(pq.isEmpty());
        pq.clear();
        System.out.println(pq);
        
        // Iterator
        List<Integer> list2 = new ArrayList<>();
        
        list2.add(1);
        list2.add(2);
        list2.add(3);
        list2.add(4);
        
        Iterator<Integer> it = list2.iterator();
        
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
        
        
    }
}

Map

HashMap<String, Integer> h = new HashMap<>();
// k : 키
// v : 값

h.put(k,v);
h.get(k) 
h.remove(k) // 반환 후 삭제
h.size();
h.containsKey(k);
h.containsValue(v);
h.getOrDefault(k,default_val); 

// 순환
// 첫 번째 방법
for(Map.Entry<String, Integer> element : h.entrySet()){
      element.getKey();
      element.getValue();
}

// 두 번째 방법
for(String key: h.keySet()){…..}

for(Integer val: h.values()){……}

h.clear();

Heap : PriorityQueue를 통한 힙 구현

import java.util.PriorityQueue; 

//int형 priorityQueue 선언 (우선순위가 낮은 숫자 순)
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();

//int형 priorityQueue 선언 (우선순위가 높은 숫자 순)
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(Collections.reverseOrder());

//String형 priorityQueue 선언 (우선순위가 낮은 숫자 순)
PriorityQueue<String> priorityQueue = new PriorityQueue<>(); 

//String형 priorityQueue 선언 (우선순위가 높은 숫자 순)
PriorityQueue<String> priorityQueue = new PriorityQueue<>(Collections.reverseOrder());


priorityQueue.add(1);  
priorityQueue.add(2);    
priorityQueue.offer(3);   

priorityQueue.poll(); 
priorityQueue.remove(); 
priorityQueue.clear();   

PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();/
priorityQueue.offer(2);  
priorityQueue.offer(1);  
priorityQueue.offer(3); 
priorityQueue.peek();  

// Java program to iterate elements
// to a Queue

import java.util.*;
  
public class GFG {
  
    public static void main(String args[])
    {
        Queue<String> pq = new PriorityQueue<>();
  
        pq.add("Geeks");
        pq.add("For");
        pq.add("Geeks");
  
        Iterator iterator = pq.iterator();
  
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
    }
}

Stack/Queue

## Stack
Stack<Integer> s = new Stack<>();

s.push();
s.peek();
s.pop();
s.empty(); //returns bool
s.size();
s.celar();
s.contains(1) 

## Queue
// 선언
Queue<Integer> queue = new LinkedList<>(); 
Queue<String> queue = new LinkedList<>(); 

Queue<Integer> stack = new LinkedList<>(); 
queue.add(1);  
queue.add(2); 
queue.offer(3);  

Queue<Integer> queue = new LinkedList<>(); 
queue.offer(1);    
queue.offer(2);    
queue.offer(3);   
queue.poll();    
queue.remove();    
queue.clear();      

Queue<Integer> queue = new LinkedList<>(); 
queue.offer(1);   
queue.offer(2);  
queue.offer(3);    
queue.peek();