기본 자료구조 및 사용법 정리

≣ 목차

 Array (배열)

Java에서 배열은 고정된 크기를 가지며, 인덱스를 통해 빠르게 접근할 수 있는 자료구조입니다.

public class ArrayExample {
    public static void main(String[] args) {
        // 배열 선언과 초기화
        int[] arr = new int[5];  // 크기가 5인 정수형 배열
        int[] initializedArr = {1, 2, 3, 4, 5};  // 초기화된 배열
        
        // 배열 값 변경
        arr[0] = 10;
        
        // 배열 순회
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

 

ArrayList (동적 배열)

ArrayList는 동적 크기의 배열로, 크기가 가변적입니다.

import java.util.ArrayList;

public class ArrayListExample {
    public static void main(String[] args) {
        // ArrayList 선언
        ArrayList<Integer> list = new ArrayList<>();

        // 요소 추가
        list.add(1);
        list.add(2);
        list.add(3);

        // 요소 접근
        int firstElement = list.get(0);

        // 요소 삭제
        list.remove(1);  // 인덱스 1의 요소 삭제

        // 리스트 크기
        System.out.println("Size: " + list.size());

        // 리스트 순회
        for (int num : list) {
            System.out.println(num);
        }
    }
}

LinkedList (연결 리스트)

LinkedList는 이중 연결 리스트로 구현되며, 삽입과 삭제에 유리한 자료구조입니다.

import java.util.LinkedList;

public class LinkedListExample {
    public static void main(String[] args) {
        // LinkedList 선언
        LinkedList<String> linkedList = new LinkedList<>();

        // 요소 추가 (앞, 뒤)
        linkedList.addFirst("First");
        linkedList.addLast("Last");

        // 요소 제거 (앞, 뒤)
        linkedList.removeFirst();
        linkedList.removeLast();

        // 요소 접근
        linkedList.add("Middle");
        String element = linkedList.get(0);

        // 리스트 순회
        for (String str : linkedList) {
            System.out.println(str);
        }
    }
}

Stack (스택)

Stack은 후입선출(LIFO) 자료구조로, Java에서 Stack 클래스를 사용하거나 Deque를 스택처럼 사용할 수 있습니다.

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        // Stack 선언
        Stack<Integer> stack = new Stack<>();

        // 스택에 값 추가 (push)
        stack.push(1);
        stack.push(2);
        stack.push(3);

        // 스택에서 값 제거 (pop)
        int top = stack.pop();

        // 스택의 가장 위 값 확인 (peek)
        int peek = stack.peek();

        // 스택이 비어있는지 확인
        boolean isEmpty = stack.isEmpty();
    }
}

Queue (큐)

Queue는 선입선출(FIFO) 자료구조입니다. Java에서 LinkedList나 ArrayDeque로 큐를 구현할 수 있습니다.

import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {
    public static void main(String[] args) {
        // Queue 선언
        Queue<Integer> queue = new LinkedList<>();

        // 큐에 값 추가 (offer)
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);

        // 큐에서 값 제거 (poll)
        int first = queue.poll();

        // 큐의 가장 앞 요소 확인 (peek)
        int peek = queue.peek();

        // 큐가 비어있는지 확인
        boolean isEmpty = queue.isEmpty();
    }
}

Priority Queue (우선순위 큐)

PriorityQueue는 기본적으로 최소 힙(min-heap)으로 구현되며, 요소들이 우선순위에 따라 정렬됩니다.

import java.util.PriorityQueue;

public class PriorityQueueExample {
    public static void main(String[] args) {
        // PriorityQueue 선언 (기본적으로 최소 힙)
        PriorityQueue<Integer> pq = new PriorityQueue<>();

        // 요소 추가 (offer)
        pq.offer(3);
        pq.offer(1);
        pq.offer(2);

        // 우선순위가 가장 높은 요소 제거 (poll)
        int min = pq.poll();  // 가장 작은 값이 나옴

        // 우선순위가 가장 높은 요소 확인 (peek)
        int peek = pq.peek();

        // 큐가 비어있는지 확인
        boolean isEmpty = pq.isEmpty();
    }
}

HashMap (해시맵)

HashMap은 키-값 쌍으로 데이터를 저장하며, 빠른 검색과 삽입이 가능한 자료구조입니다.

import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        // HashMap 선언
        HashMap<String, Integer> map = new HashMap<>();

        // 키-값 쌍 추가 (put)
        map.put("one", 1);
        map.put("two", 2);

        // 값 접근 (get)
        int value = map.get("one");

        // 키-값 쌍 삭제 (remove)
        map.remove("two");

        // 맵에 키가 있는지 확인 (containsKey)
        boolean hasKey = map.containsKey("one");

        // 맵 순회
        for (String key : map.keySet()) {
            System.out.println("Key: " + key + ", Value: " + map.get(key));
        }
    }
}

HashSet (해시셋)

HashSet은 중복되지 않는 요소를 저장하는 자료구조입니다.

import java.util.HashSet;

public class HashSetExample {
    public static void main(String[] args) {
        // HashSet 선언
        HashSet<Integer> set = new HashSet<>();

        // 요소 추가 (add)
        set.add(1);
        set.add(2);
        set.add(3);

        // 요소 제거 (remove)
        set.remove(2);

        // 요소가 존재하는지 확인 (contains)
        boolean contains = set.contains(1);

        // Set 순회
        for (int num : set) {
            System.out.println(num);
        }
    }
}

TreeMap (정렬된 맵)

TreeMap은 키를 기준으로 자동 정렬된 상태로 데이터를 유지합니다.

import java.util.TreeMap;

public class TreeMapExample {
    public static void main(String[] args) {
        // TreeMap 선언
        TreeMap<String, Integer> treeMap = new TreeMap<>();

        // 키-값 추가
        treeMap.put("b", 2);
        treeMap.put("a", 1);
        treeMap.put("c", 3);

        // 자동으로 키에 따라 정렬된 순서로 출력
        for (String key : treeMap.keySet()) {
            System.out.println(key + " -> " + treeMap.get(key));
        }
    }
}

Deque (덱)

Deque는 양방향 큐로, 앞과 뒤에서 모두 삽입과 삭제가 가능한 자료구조입니다.

import java.util.ArrayDeque;
import java.util.Deque;

public class DequeExample {
    public static void main(String[] args) {
        // Deque 선언
        Deque<Integer> deque = new ArrayDeque<>();

        // 앞에서 추가 (addFirst), 뒤에서 추가 (addLast)
        deque.addFirst(1);
        deque.addLast(2);

        // 앞에서 제거 (removeFirst), 뒤에서 제거 (removeLast)
        int first = deque.removeFirst();
        int last = deque.removeLast();

        // 앞에서 접근 (peekFirst), 뒤에서 접근 (peekLast)
        int peekFirst = deque.peekFirst();
        int peekLast = deque.peekLast();
    }
}