Java 자료 구조(Collection, Map)

Java Playground

https://www.compilejava.net/

Online Java IDE

 

Collection interface

-  동적 크기: List, Set, Queue와 같은 Collection 구현체들은 동적으로 크기를 조정 가능
- 유연한 데이터 처리: Collection은 데이터에 접근하거나 변경할 때 다양한 메서드와 기능을 제공합니다. 예를 들어, 요소 추가, 삭제, 크기 변경 등이 가능
- 중복 허용 여부: Set은 중복을 허용하지 않으며, List는 중복을 허용 함
- 다양한 컬렉션 타입: Collection은 List, Set, Queue 등 

출처: wikipedia, Java collections framework

List

- LinkedList: 삽입 삭제 등이 빈번할 경우 사용(data 의 순차적 처리가 중요할 때)

- ArrayList: 읽기 성능이 중요(중간 data 삽입 삭제 시 성능 저하)

import java.util.*;

public class main {
    public static void main(String[] args) {
        linkedListTest();
    }

    public static void linkedListTest() {  
        // LinkedList 생성
        List<String> list = new LinkedList<>();

        // 값 추가
        list.add("Dog");
        list.add("Cat");
        list.add("Rabbit");

        // 출력: 리스트 내용
        System.out.println("List: " + list); // [Dog, Cat, Rabbit]

        // 특정 인덱스의 값 접근
        System.out.println("Element at index 0: " + list.get(0)); // Dog

        // 앞에 값 추가 (LinkedList 특성: 앞뒤 삽입/삭제가 빠름)
        list.add(0, "Fish");
        System.out.println("After adding at index 0: " + list); // [Fish, Dog, Cat, Rabbit]

        // 값 삭제
        list.remove("Cat");
        System.out.println("After removal: " + list); // [Fish, Dog, Rabbit]

        // 리스트 크기 확인
        System.out.println("Size of list: " + list.size()); // 3
        
        //Array List
        List<String> arrayList = new ArrayList<>();
        arrayList.add("Apple");
        arrayList.add("Banana");
        arrayList.add("Cherry");

        System.out.println(arrayList.get(1)); // Banana (빠른 조회)
    }
}

 

HashSet

: 중복을 허용하지 않고, 순서를 보장하지 않기 때문에 입력순서와 출력순서가 다를 수 있음

import java.util.*;

public class main {
    public static void main(String[] args) {
        hashSetTest();
    }

    public static void hashSetTest() {  
        HashSet<Integer> set = new HashSet<>();

        // 값 추가
        set.add(3);
        set.add(1);
        set.add(5);
        set.add(7);
        set.add(2);

        System.out.println(set);

        TreeSet<Integer> treeSet = new TreeSet<>(set);
        System.out.println("TreeSet 출력 (오름차순): " + treeSet);

        //foreach 문으로 내부 접근 가능능
        for (Integer one: set){
	        System.out.println(one);
        }
    }
}

 

Stack

import java.util.Stack;

public class main {
    public static void main(String[] args) {
        stackTest();
    }

    public static void stackTest(){
        Stack<Integer> stack = new Stack<>();
     
        stack.push(1);
        stack.push(9);
        stack.push(8);

        System.out.println(stack); //[1,9,8]
        System.out.println(stack.contains(9));  //포함여부 확인 true
        System.out.println(stack.size());  //size return

        stack.peek();  //stack 의 top value return
        int removedValue = stack.pop();  // top 값 제거하고 반환    

        System.out.println(removedValue); //[8]
        System.out.println(stack); //[1,9]
        System.out.println(stack.isEmpty());
    }
}

 

Queue

import java.util.Queue;       // Queue 인터페이스 
import java.util.LinkedList;  // LinkedList 클래스 

public class main {
    public static void main(String[] args) {
        queueTest();
    }

    public static void queueTest(){
        Queue<Integer> queue = new LinkedList<>();
     
        queue.add(1); //값 추가 (queue가 가득차면 예외발생)
        queue.offer(2); // 값 추가 (queue가 가득차면 false를 반환)
        queue.add(3); //값 추가
        System.out.println(queue); //[1,2,3]

        int intValue = queue.poll(); //return 첫번째 값(return 후 값 제거거), 비어있을 시 return null        
        System.out.println(intValue); //1

        int size = queue.size();
        System.out.println(size); //2

        System.out.println(queue.isEmpty()); //비어있는지 확인 false
        System.out.println(queue.peek()); //제거 없이 첫번째 값 출력 : 2
        System.out.println(queue.remove()); //첫번째 값 제거 : 2
        queue.clear(); //모든 값 제거
        System.out.println(queue.isEmpty()); //true
    }
}

 

Deque(Double Ended Queue)

: 양쪽 끝에서 값을 추가하거나 제거할 수 있는 자료구조(큐와 스텍을 합친 구조)

 

import java.util.*;      

public class main {
    public static void main(String[] args) {
        dequeTest();
    }

    public static void dequeTest(){
        List<Integer> list = Arrays.asList(1,2,3);        
        Deque<Integer> deque = new ArrayDeque<>(list); //객체 생성 + 초기화화

        deque.addLast(1);     
        System.out.println(deque); //뒤로 값 추가 [1,2,3,1]

        deque.addFirst(0);
        System.out.println(deque); //앞으로 값추가 [0,1,2,3,1]

        int removedValueFirst = deque.pollFirst(); 
        System.out.println(removedValueFirst); //0   
        System.out.println(deque); //앞으로 Data 제거 [1,2,3,1]

        int removedValueLast = deque.pollLast();
        System.out.println(removedValueLast); //1
        System.out.println(deque); //뒤에서 Data 제거 [1,2,3]

        System.out.println(deque.peekFirst()); //처음 요소 반환(없으면 null)
        System.out.println(deque.peekLast()); //처음 요소 반환(없으면 null)
        System.out.println(deque); //[1,2,3]
        System.out.println(deque.size()); // 3

        deque.clear();
        System.out.println(deque); //[]
    }
}

 

PriorityQueue

: poll 로 data 추출 시 최소값 or 우선순위가 가장 높은 값을 꺼내는 구조

import java.util.*;

public class main {
    public static void main(String[] args) {
        priorityQueueTest();
    }

    public static void priorityQueueTest() {
        // 우선순위 큐 생성 (기본적으로 오름차순)
        PriorityQueue<Integer> pq = new PriorityQueue<>();

        // 값 추가
        pq.add(5);
        pq.offer(1); 
        pq.add(3);
        pq.add(7);

        // 우선순위 큐에서 값을 꺼냄 (정렬된 순서대로 꺼내짐)
        System.out.println(pq);  // [1, 3, 5, 7]
        System.out.println("최소 값: " + pq.poll());  // 1
        System.out.println(pq);  // [3, 5, 7]
        System.out.println("최소 값: " + pq.poll());  // 3
    }
}

 

HashMap

: Key, Value  쌍을 이루는 자료구조(Key 는 중복안되며, Value 는 중복 가능)

import java.util.*;

public class main {
    public static void main(String[] args) {
        hashMapTest();
    }

    public static void hashMapTest() {  
        // HashMap 선언
        HashMap<Integer, String> map = new HashMap<>();
        
        // 값 추가
        map.put(1, "사과");
        map.put(2, "바나나");
        map.put(1, "포도");  // key 1이 이미 존재하면 value가 덮어씌워짐
        
        System.out.println(map);

        // 값 삭제
        map.remove(1);  // key 1을 삭제
        map.clear();    // 전체 삭제

        // 값 확인
        System.out.println(map.containsKey(1));  // key 1이 있으면 true, 없으면 false
        System.out.println(map.containsValue("사과"));  // value "사과"가 있으면 true, 없으면 false

        // 출력 방법 1: key와 value 출력
        for (Integer i : map.keySet()) {
            System.out.println(i + ": " + map.get(i));  // key와 value 출력
        }

        // 출력 방법 2: Entry 사용하여 key와 value 출력
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());  // key와 value 출력
        }
    }
}