[자바(JAVA)] 컬렉션 ArrayList, LinkedList, Stack, Queue, Set , Map

 

🔷 Java 컬렉션
- Java 프로그래밍 언어에서 데이터를 저장하고 조작하기 위한 자료 구조의 집합이다.
- 배열을 더 고도화 시킨 것으로 다수의 참조형 데이터를 더 쉽고 효과적으로 추가, 검색, 수정 및 삭제등을 할 수 있도록 도와준다.

 

 

<종류>

• List: 순서가 있는 데이터의 집합 (데이터 중복 허용)
• Queue : 빨대🥤처럼 한쪽에서 데이터를 넣고 반대쪽에서 데이터를 뺄 수 있는 집합(FIFO: First in First Out) (데이터 중복 허용)
• Set : 순서가 없는 데이터의 집합 (데이터 중복 허용 안함) - 순서없고 중복없는 배열
• Map : 순서가 없는 (Key,Value) 쌍으로 이루어진 데이터의 집합 (Key값 중복 허용 안함)

 

Queue vs Set vs Map ❓


1. Queue: 데이터를 FIFO(First-In-First-Out) 순서로 저장하고 처리하는 자료 구조를 나타내며, 주로 대기열이나 작업 큐에 사용됩니다.
LinkedList가 Queue 인터페이스를 구현한 클래스입니다.

2. Set: 중복을 허용하지 않는 데이터의 집합을 나타냅니다.
HashSet과 TreeSet이 Set 인터페이스를 구현한 대표적인 클래스입니다.

3. Map: 키-값 쌍으로 데이터를 저장하는 자료 구조를 나타내며, 키는 중복될 수 없습니다.
HashMap과 TreeMap이 Map 인터페이스를 구현한 대표적인 클래스입니다.

 

 

 

---

📗 List

: 순서가 있는 데이터의 집합을 나타내며, 데이터를 중복으로 저장할 수 있다(배열과 성질이 비슷함)

 

 

---

 

🔸 ArrayList

: Array처럼 데이터 요소를 순차적으로 저장하는 데 사용되는 자료 구조이며, 

생성시점에 작은 연속된 공간을 요청해서 참조형 변수들을 담아놓고, 값이 추가될때 더 큰 공간이 필요하면 더 큰 공간을 받아서 저장하는 동적배열이다.

 

💬 기능
  º 선언 : ArrayList<Integer> intList 형태로 선언 
  º 생성 : new ArrayList<Integer>(); 형태로 생성
  º 초기화 : 사이즈를 지정하는것이 없기 때문에 초기화가 필요 없다.
  º 값 추가 : intList.add({추가할 값}) 형태로 값을 추가
  º 값 수정 : intList.set({수정할 순번}, {수정할 값}) 형태로 값을 수정
  º 값 삭제 : intList.remove({삭제할 순번}) 형태로 값을 삭제
  º 전체 출력 : intList.toString() 형태로 전체 값을 대괄호[]로 묶어서 출력
  º 전체 제거 : intList.clear() 형태로 전체 값을 삭제

 

 

---

 

🤔 ArrayList가 Array의 성질이 유사하지만 Array는 정적배열이고 ArrayList는 동적배열이다.

두가지가 각각 어떤 상황에서 장단점을 가지는지 궁금해졌다!

🔽🔽🔽

 

1. 공통점:

ArrayList와 Array는 둘 다 데이터를 저장하는 데 사용되는 자료 구조로 아래와 같은 공통점을 가진다.

1. 데이터 저장: ArrayList와 Array는 모두 데이터를 저장할 수 있다.
2. 인덱스 기반 접근: 둘 다 인덱스를 사용하여 요소에 접근할 수 있다.

 

2. 차이점:

   1. 크기: Array는 고정 크기를 갖고 있으며 선언할 때 크기를 지정해야 합니다.

       ArrayList는 크기가 가변적이며 필요에 따라 동적으로 크기가 조정됩니다.

   2. 타입: Array는 특정 데이터 타입의 요소만 포함할 수 있습니다. 

       ArrayList는 제네릭을 사용하여 다양한 타입의 요소를 포함할 수 있습니다.

   3. 메모리 할당: Array는 요소를 메모리에 연속적으로 할당합니다.

       ArrayList는 내부적으로 Array를 사용하지만, 크기가 조정될 때마다 새로운 Array를 할당하고 기존 요소를 복사합니다.

   4. 추가/삭제: Array의 크기는 고정되어 있으므로 요소를 추가하거나 삭제할 수 없습니다.

       ArrayList는 동적으로 크기가 조정되므로 요소를 추가하거나 삭제할 수 있습니다.

 

 

3. 사용 예시:

• Array:
  • int[] numbers = new int[5]; // 크기가 5인 정수형 Array 생성
  • String[] names = {"John", "Jane", "Tom"}; // 초기값을 가지는 문자열 Array 생성
  • Array는 크기가 고정되어 있고, 데이터를 추가하거나 삭제할 필요가 없는 경우에 주로 사용된다.
  • 또한 성능이 중요한 상황에서 Array가 더 효율적일 수 있습니다.
• ArrayList:
  • ArrayList<Integer> numbers = new ArrayList<>(); // 정수형 요소를 가지는 ArrayList 생성
  • ArrayList<String> names = new ArrayList<>(Arrays.asList("John", "Jane", "Tom")); // 초기값을 가지는 문자열 ArrayList 생성
  • ArrayList는 크기가 동적으로 조정되어야 하거나 데이터를 추가하거나 삭제해야 하는 경우에 주로 사용됩니다.
  • 또한 다양한 타입의 요소를 포함해야 하는 상황에서 유연성을 제공합니다.

 

 

Array는 선언할 때 크기가 고정되고 메모리가 연속적으로 할당되기 때문에, 크기를 동적으로 조정하거나 요소를 추가하거나 삭제할 수 없다.

 

만약 Array에 요소를 추가하거나 삭제해야 한다면, 새로운 Array를 생성하고 기존의 요소를 복사하는 방법밖에 없다.

추가 또는 삭제할 위치에 요소를 삽입하거나 삭제한 뒤, 기존의 요소들을 새로운 Array에 복사하여 크기를 조정하는 과정을 거쳐야 하며, 이는 상대적으로 번거롭고 비효율적일 수 있다.

크기를 동적으로 조절해야 하는 상황에서는 ArrayList를 사용하는 것이 더 적합하다. ArrayList는 내부적으로 Array를 사용하지만, 크기 조정이 필요할 때마다 새로운 Array를 할당하고 기존 요소를 복사하는 작업을 내부에서 처리한다.

이를 통해 요소의 추가 또는 삭제가 간편하고 효율적으로 이루어진다.

따라서 요소의 추가 또는 삭제가 빈번하게 발생하는 상황에서는 ArrayList를 사용하는 것이 더 적합하다.

 

 

 

 

❗ 위의 설명대로라면 ArrayList의 크기가 변경될 경우 기존 요소를 복사해서 새로운 Array를 할당하는건데 그럼 내부적으로 차지하는 메모리가 늘어나서 결론적으론 비용이 증가하는게 아닐까? 

 

👉 결론: 가비지 컬렉터가 처리한다.

ArrayList의 크기가 변경되어야 하는 경우에는 다음과 같은 과정을 거치게 됩니다.

1. 새로운 ArrayList를 생성한다.
2. 기존의 ArrayList에 있는 요소들을 새로운 ArrayList로 복사한다.
3. 새로운 ArrayList를 기존의 ArrayList로 참조한다.

이 과정에서 기존의 ArrayList는 더 이상 참조되지 않는 객체가 되며, Java의 가비지 컬렉터가 메모리를 해제할 수 있도록 됩니다.
기존의 ArrayList는 삭제되고, 메모리를 계속 차지하는 것은 아니기때문에 ArrayList의 크기가 변경되어야 하는 경우에는 기존의 ArrayList를 복사하여 새로운 ArrayList를 생성하고 기존의 ArrayList는 삭제되므로 메모리 누수는 발생하지 않습니다.

 

---

 

🤔 ArrayList에 대한 설명은 이해되나, 성능이 중요한 경우 Array를 사용하는게 더 효율적이라는 부분이 이해되지 않아서 다시 찾아보았다.

 

 

4. Array를 사용했을 때 성능면에서 더 효율적인 이유

 

1. 메모리 사용: Array는 고정 크기를 갖고 있으며, 요소들이 연속적으로 메모리에 할당된다.

이로 인해 메모리 사용이 더 효율적입니다. ArrayList는 내부적으로 Array를 사용하지만, 크기가 동적으로 조정될 때마다 새로운 Array를 할당하고 기존 요소를 복사해야 하므로 메모리 사용이 더 많아질 수 있다.
2. 접근 속도: Array는 인덱스를 사용하여 요소에 직접 접근하기 때문에, ArrayList보다 접근 속도가 빠릅니다. ArrayList는 인덱스를 사용하여 요소에 접근하는 경우 내부적으로 인덱스 계산 등의 추가 작업이 필요하다.
3. 크기 변경 빈도: Array는 고정 크기를 갖기 때문에 크기를 동적으로 변경할 필요가 없는 상황에서는 Array가 더 효율적입니다. 크기 변경 작업은 ArrayList에서 새로운 Array를 할당하고 요소를 복사해야 하는 비용이 발생하기 때문이다.

 

따라서, 크기가 고정되어 있고 요소의 추가 또는 삭제가 빈번하지 않으며, 메모리 사용과 접근 속도가 중요한 경우에는 Array가 성능적으로 더 효율적일 수 있다. 하지만 요소의 추가 또는 삭제가 빈번하거나 크기가 동적으로 변경되어야 하는 상황에서는 ArrayList가 더 적합하다. 

성능에 대한 상대적인 효율성은 상황에 따라 다를 수 있으므로, 실제 사용 시에는 상황에 맞는 자료 구조를 선택하는 것이 중요하다.

 

 

---

 

 

 

 

✅ ArrayList 선언

// ArrayList를 사용할 경우 import java.util.ArrayList;를 먼저 추가해야됨

// ArrayList<래퍼타입> 리스트명 = new ArrayList<래퍼타입>();  
 ArrayList<Integer> intList = new ArrayList<Integer>(); // 선언 + 생성

 

 

✅ ArrayList 추가

   public static void main(String[] args) {
        // ArrayList<래퍼타입> 배열명 = new ArrayList<래퍼타입>();
        ArrayList<Integer> intList = new ArrayList<Integer>(); 
        intList.add(1);  // 래퍼 타입이 Intger라서 1,2을 추가할 수 있음
        intList.add(2);
        intList.add("숫자");  // 타입 불일치로 오류
    }

 

✅ ArrayList 수정

intList.set(1, 10);  // 리스트 값(15)을 10으로 바꾸기
System.out.println(intList.get(1));

 

 

---

 

 

🔸 LinkedList

: 메모리에 남는 공간을 요청해서 여기저기 나누어서 실제값을 담아놓고, 실제값이 있는 주소값으로 목록을 구성하고 저장한다.

=> 실제 값이 있는 주소값으로 목록을 구성하고 저장하는 자료구조

 

기본적인 기능은 ArrayList 와 동일하지만 LinkedList 는 값을 나누어 담기 때문에 모든값을 조회하는 속도가 느리다.

대신, 값을 중간에 추가하거나 삭제할때는 속도가 빠르다.

* ArrayList 의 경우 추가, 삭제시 그 순서를 전부 보정해줘야 하기때문에 상대적으로 느리다.

 

 

 

 

 

✅LinkedList 예시

public static void main(String[] args) {
        // Linked List
        // 메모리에 남는 공간을 요청해서 여기 저기 나누어서 실제 값을 담는다
        // 실제 값이 있는 주소값으로 목록을 구성하고 저장하는 자료구조
        LinkedList<Integer> linkedList = new LinkedList<Integer>();
        linkedList.add(5);
        linkedList.add(10);
        linkedList.add(15);

        System.out.println(linkedList.get(0));
        System.out.println(linkedList.get(1));
        System.out.println(linkedList.get(2));
        System.out.println(linkedList.toString());   // 전체조회
    }

-> 전체조회시 속도가 어레이 리스트에 비해 현저히 느리다

( 분산된 데이터를 조합해서 가져와야하기 때문)

 

 

 

✅LinkedList 값 추가

  linkedList.add(2, 4);  // 2번 인덱스에 4 추가(빠름)
  System.out.println(linkedList.toString());  // [5, 10, 4, 15]

 

 

---

📗 Stack (스택)

: Stack은 박스처럼 데이터를 수직으로 쌓아놓고 넣었다가 빼는 후입선출(LIFO, Last-In-First-Out) 방식을 따르는 자료구조이다.

 

• 가장 최근에 추가된 항목이 맨 위에 위치하며, 이 항목이 가장 먼저 제거된다.
• 스택에 요소를 추가하는 작업(push()) / 조회(peek()), 제거(pop()) 세가지 기능을 주로 사용한다.
• 주로 최근 저장된 데이터를 나열하거나 함수의 호출 스택, 브라우저의 이전 페이지 기록 등에 사용된다.

 

 

// 스택 (Stack):

    ┌───────┐
    │       │
    │   3   │
    │   2   │
    │   1   │
    └───────┘

 

 

 

 

✅ Stack의 사용예시

  public static void main(String[] args) {
        // Stack (Basket)
        // 수직으로 값을 쌓아놓고, 넣었다가 뺀다 (FILO) first in last out
        // 주요기능: 값 추가, 조회, 꺼냄
        // push, peek, pop
        // 최근 저정된 데이터를 나열하거나 데이터의 중복처리를 막고싶을 때 사용함
        Stack<Integer> intStack = new Stack<Integer>();   // 선언

        intStack.push(10);
        intStack.push(20);
        intStack.push(30);

        while (!intStack.isEmpty()) { // intStack이 empty가 아닐때까지 반복한다
            System.out.println(intStack.pop()); // 제일 최신데이터부터 꺼내준다 (pop은 꺼내면 삭제됨)
        }
    }

 

   intStack.push(10);
        intStack.push(20);
        intStack.push(30);

        System.out.println(intStack.peek()); // 출력값: 30

 

 

---

 

📗 Queue (큐)

Queue는 빨대처럼 한쪽에서 데이터를 넣고 반대쪽에서 데이터를 뺄 수 있는 집합으로 FIFO(First in First Out)방식을 따르는 자료구조이다.

• 가장 먼저 추가된 항목이 맨 앞에 위치하며, 이 항목이 가장 먼저 제거된다.
• 큐에 요소를 추가하는 작업을 "enqueue"라고 하고, 요소를 제거하는 작업을 "dequeue"라고 한다.
• Queue는 생성자가 없는 인터페이스이기 때문에 바로 사용이 불가능하며, 생성자가 존재하는 LinkedList등과 함께 사용하여 생성할 수 있다.
• 추가(add()), 조회(peek()), 꺼내기_삭제됨(poll())
• 주요 활용 예시: 작업 대기열, 메시지 큐 등

 

 

 

 

✅ Queue 사용예시

public static void main(String[] args) {
        Queue<Integer> intQueue = new LinkedList<>();  // Queue를 선언, 생성

        intQueue.add(1);
        intQueue.add(5);
        intQueue.add(9);

        while (!intQueue.isEmpty()){
          System.out.println(intQueue.poll()); // 출력: 1 -> 5 -> 9
        }

        intQueue.add(1);
        intQueue.add(5);
        intQueue.add(9);

        System.out.println(intQueue.peek()); // 출력: 1
    }

 

 

---

📗 Set(집합)

Set은 순서가 없는 데이터의 집합으로 데이터 중복을 허용하지 않은다.

/// Set
	{ 1, 2, 3, 4, 5 }

 

• Set은 단독사용이 가능하나 HashSet, TreeSet 등으로 응용해서 함께 사용할 수 있다.
• 주요 활용 예시: 중복 제거, 멤버십 테스트 등
• 추가(add()), 조회(.get(순번)), 삭제(.remove()), 포함여부 확인_논리값출력(.contains(확인할 값))

 

 

 

 

 

✅ Set 사용예시

 public static void main(String[] args) {
        Set<Integer> intSet = new HashSet<>(); // 선언 및 생성

        intSet.add(1);
        intSet.add(12);
        intSet.add(5);
        intSet.add(9);
        intSet.add(12);		// 중복불가로 덮어쓰기됨

        for(Integer value:intSet) {
            System.out.println(value);
        }
    }

 

        intSet.add(1);
        intSet.add(12);     중복으로 마지막값에 덮어쓰기 되었음
        intSet.add(5);
        intSet.add(9);
        intSet.add(12);

 

-> 결과값 (중복 제거됨)

 

 

✅ contains 사용 

: 어떤 값이 존재하는지 여부를 확인할 때 사용한다.

true or fales

System.out.println(intSet.contains(2)); //intSet이 2를 포함하고 있는지 여부 확인
System.out.println(intSet.contains(5));

 

 

📌TIP)  HashSet vs TreeSet vs LinkedHashSet 

HashSet : 가장 빠르며 순서를 전혀 예측할 수 없음
TreeSet : 정렬된 순서대로 보관하며 정렬 방법을 지정할 수 있음
LinkedHashSet : 추가된 순서, 또는 가장 최근에 접근한 순서대로 접근 가능

보통 HashSet 을 주로 쓰는데 순서보장이 필요한 경우에는 LinkedHashSet 을 주로 사용한다.

---

 

📗 Map

: Map은 키-값(key-value) 쌍으로 이루어진 자료구조로, key값은 unique하게 보장된다.

• 순번으로 조회하던 기존방식에서 특정 key값에 매칭되는 vlaue값으로 조회할 수 있다.
• 맵에 새로운 키-값 쌍을 추가하거나 기존의 쌍을 제거하는 작업이 가능하다.
• Map 은 그냥 Map으로 쓸수도있지만 HashMap, TreeMap등으로 응용하여 사용할 수 있습니다.
• 추가(.put({추가할 Key값}, {추가할 Value값})), 조회(.get(조회할 Key값)), 삭제(.remove(삭제할 Key값)), 전체 key조회(.keySet()), 전체 value 조회(.values())
• 주요 활용 예시: 데이터베이스, 사전, 설정 정보 등

 

 

 

✅ Map 예시 

 

public static void main(String[] args) {
        // Map : key-value pair
        // key라는 값으로 unique하게 보장되어야 함.

        // key는 String, value는 Integer로 선언
        Map<String, Integer> intMap = new HashMap<>();

        intMap.put("일", 1);
        intMap.put("이", 2);
        intMap.put("삼", 3);
        intMap.put("삼", 33);     // 중복 key
        intMap.put("삼", 3333);   // 중복 key

        for(String key:intMap.keySet()){  // keySet: key값만 빼서 배열로 만드는 기능
            System.out.println(key);
        }

 

중복된 key는 생략해버림.

중복 key는 덮어쓰기가 진행되기 때문에

출력시 가장 마지막 값이 나오게 된다.

 

 

 

 

 

번외) HashMap 키, 벨류 출력방법

https://imcodiiing.tistory.com/manage/posts/

Tistory

 

 

 

 

 

각 종류별 명령어 정리

 

종류	ArrayList	LinkedList	Stack	Queue	Set	Map
선언 및 생성	ArrayList <integer> IntList = new ArrayList<Integer>();	LinkedList<Integer> linkedList = new LinkedList<>();	Stack<Integer> intStack = new Stack<Integer>();	Queue<Integer> intQueue = new LinkedList<>();	Set<Integer> intSet = new HashSet<Integer>();
값 추가	intList.add({추가할 값})	linkedList.add({추가할 값})	intStack.push({추가할 값})	intQueue.add({추가할 값})	intSet.add({추가할 값})	intMap.put({추가할 Key값},{추가할 Value값})
값 중간추가		linkedList.add({추가할 순번}, {추가할 값})
값 수정	intList.set({수정할 순번},{수정할 값})	linkedList.set({수정할 순번}, {수정할 값})
값 삭제	intList.remove({삭제할 순번})	linkedList.remove({삭제할 순번})			intSet.remove({삭제할 값})
전체 출력	intList.toString()	linkedList.toString()				Key조회 :intMap.keySet() vallue 조회 intMap.values()
전체 제거	intList.clear()	linkedList.clear()
특정값 제거						intMap.remove({삭제할 Key값})
조회			intStack.peek()	intQueue.peek()	intSet.get({초회할 순번})	intMap.get({조회할 Key값})
꺼내기			intStack.pop()	intQueue.poll()
값 포함 확인					intSet.contains({포함확인 할 값})

 

 

---

 

자료구조들은 각각의 특성과 활용 목적에 따라 사용됩니다.

Stack(스택)과 Queue(큐)는 데이터의 삽입과 삭제에 집중되어 있는데,
✔Stack(스택)은 가장 최근에 추가된 항목에 접근하는 경우 주로 사용됩니다.
✔Queue(큐)는 먼저 추가된 항목에 접근하는 경우 주로 사용됩니다.
✔Set(집합)은 중복된 요소를 제거하고 고유한 값들을 관리하는 데 사용되며,
✔Map(맵)은 키-값 쌍을 사용하여 데이터를 구조화하고 접근하는 데 사용됩니다.