[Java] 컬렉션 ( ArrayList, LinkedList, Stack, Queue, Set, Map )

컬렉션

컬렉션은 배열보다 다수의 참조형 데이터를 더 쉽고 효과적으로 처리할 수 있는 기능을 가지고 있음

• 기능 : 크기 자동 조정/ 추가/ 수정/ 삭제/ 반복/ 순회/ 필터/ 포함 확인 등
• 종류
  • List : 순서가 있는 데이터의 집합 ( 데이터 중복 허용 ) ( 배열과 비슷 )
  • Queue : 빨대처럼 한쪽에서 데이터를 넣고 반대쪽에서 데이터를 뺄 수 있는 집합
    • 먼저 들어간 순서대로 조회 가능
  • Set : 순서가 없는 데이터의 집합 ( 데이터 중복 허용 안 함 ) ( 집합과 비슷 )
  • Map : 순서가 없는 ( Key, Value ) 쌍으로 이루어진 데이터 집합 ( Key 는 중복 안 함 )

List

ArrayList

Array : 실제 값 저장 (기본형 변수로 저장 ) , 정적 배열

ArrayList : 참조형 변수들을 저장, 동적 배열

 

• 기능

// ArrayList 
// (사용하기 위해선 import java.util.ArrayList; 를 추가해야합니다.)
import java.util.ArrayList;

        public class Main {

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

                intList.add(1);
                intList.add(2);
                intList.add(3);

                System.out.println(intList.get(0)); // 1 출력
                System.out.println(intList.get(1)); // 2 출력
                System.out.println(intList.get(2)); // 3 출력
                System.out.println(intList.toString()); // [1,2,3] 출력

                intList.set(1, 10); // 1번순번의 값을 10으로 수정합니다.
                System.out.println(intList.get(1)); // 10 출력


                intList.remove(1); // 1번순번의 값을 삭제합니다.
                System.out.println(intList.toString()); // [1,3] 출력

                intList.clear(); // 전체 값을 삭제합니다.
                System.out.println(intList.toString()); // [] 출력
            }
        }

LinkedList

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

값을 나누어 담기 때문에 조회 속도 ↓ , 값을 중간에 추가/삭제 속도 ↑

 

import java.util.LinkedList;

 

사용하기 위해 LinkdedList 유틸 import 필요

Stack

상자처럼 나중에 들어간 것이 먼저 나온다고 생각하자.

 

• 기능 : 넣기(push()), 조회(peek()), 꺼내기(pop())

 

// Stack 
// (사용하기 위해선 import java.util.Stack; 를 추가해야합니다.)
import java.util.Stack;

        public class Main {

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

                intStack.push(1);
                intStack.push(2);
                intStack.push(3);

                while (!intStack.isEmpty()) { // 다 지워질때까지 출력
                    System.out.println(intStack.pop()); // 3,2,1 출력
                }

                // 다시 추가
                intStack.push(1);
                intStack.push(2);
                intStack.push(3);

                // peek()
                System.out.println(intStack.peek()); // 3 출력
                System.out.println(intStack.size()); // 3 출력 (peek() 할때 삭제 안됬음)

                // pop()
                System.out.println(intStack.pop()); // 3 출력
                System.out.println(intStack.size()); // 2 출력 (pop() 할때 삭제 됬음)      

                System.out.println(intStack.pop()); // 2 출력
                System.out.println(intStack.size()); // 1 출력 (pop() 할때 삭제 됬음)      

                while (!intStack.isEmpty()) { // 다 지워질때까지 출력
                    System.out.println(intStack.pop()); // 1 출력 (마지막 남은거 하나)
                }
            }
        }

 

while (!intStack.isEmpty()) { // 다 지워질때까지 출력
    System.out.println(intStack.pop()); // 3,2,1 출력
}

 

isEmpty() 는 비었나? 를 묻는 메서드.

 

그럼 위는 앞에 ! (NOT) 이 붙었기 때문에 비어져있지 않으면 반복문 실행 이라는 뜻.

 

Stack 의 pop() 은 맨 위에 요소를 꺼낸다.

---

Queue

한쪽에서 데이터를 넣고 반대쪽에서 데이터를 뺄 수 있는 집합 ( 빨대라고 생각 )

• 기능 : 넣는 기능(add()), 조회(peek()), 꺼내기(poll()) ( 꺼내고나면 삭제됨 )

Queue 는 생성자가 없는 껍데기(인터페이스)이기 때문에 바로 생성 불가 ( LinkedList 를 사용해서 생성 )

Queue<Integer> intQueue = new LinkedList<Integer>();

// Queue 
// (사용하기 위해선 java.util.LinkedList; 와 import java.util.Queue; 를 추가해야합니다.)
import java.util.LinkedList;
import java.util.Queue;

        public class Main {

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

                intQueue.add(1);
                intQueue.add(2);
                intQueue.add(3);

                while (!intQueue.isEmpty()) { // 다 지워질때까지 출력
                    System.out.println(intQueue.poll()); // 1,2,3 출력
                }

                // 다시 추가
                intQueue.add(1);
                intQueue.add(2);
                intQueue.add(3);

                // peek()
                System.out.println(intQueue.peek()); // 1 출력 (맨먼저 들어간값이 1 이라서)
                System.out.println(intQueue.size()); // 3 출력 (peek() 할때 삭제 안됬음)

                // poll()
                System.out.println(intQueue.poll()); // 1 출력
                System.out.println(intQueue.size()); // 2 출력 (poll() 할때 삭제 됬음)

                System.out.println(intQueue.poll()); // 2 출력
                System.out.println(intQueue.size()); // 1 출력 (poll() 할때 삭제 됬음)

                while (!intQueue.isEmpty()) { // 다 지워질때까지 출력
                    System.out.println(intQueue.poll()); // 3 출력 (마지막 남은거 하나)
                }
            }
        }

---

Set

순서가 없는 데이터의 집합 ( 데이터 중복 허용 x )

 

Set 은 생성자가 없는 껍데기(인터페이스)이기 때문에 바로 생성 불가 ( HashSet 을 사용해서 생성 )

// Set 
// (사용하기 위해선 import java.util.Set; 와 java.util.HashSet; 를 추가해야합니다.)
import java.util.HashSet;
import java.util.Set;

        public class Main {

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

                intSet.add(1);
                intSet.add(2);
                intSet.add(3);
                intSet.add(3); // 중복된 값은 덮어씁니다.
                intSet.add(3); // 중복된 값은 덮어씁니다.

                for (Integer value : intSet) {
                    System.out.println(value); // 1,2,3 출력
                }

                // contains()
                System.out.println(intSet.contains(2)); // true 출력
                System.out.println(intSet.contains(4)); // false 출력

                // remove()
                intSet.remove(3); // 3 삭제

                for (Integer value : intSet) {
                    System.out.println(value); // 1,2 출력
                }
            }
        }

 

여기서 중복되게  add 된 값들은 덮어써진다.

---

Map

• key-value 구조로 구성된 데이터를 저장
• key 값 단위로 중복을 허용하지 않음
• Map 으로 쓸 수도 있지만 HashSet, TreeSet 등으로 응용해서 사용 가능

        // Map 
// (사용하기 위해선 import java.util.Map; 를 추가해야합니다.)
import java.util.Map;

        public class Main {

            public static void main(String[] args) {
                Map<String, Integer> intMap = new HashMap<>(); // 선언 및 생성

                //          키 , 값
                intMap.put("일", 11);
                intMap.put("이", 12);
                intMap.put("삼", 13);
                intMap.put("삼", 14); // 중복 Key값은 덮어씁니다.
                intMap.put("삼", 15); // 중복 Key값은 덮어씁니다.

                // key 값 전체 출력
                for (String key : intMap.keySet()) {
                    System.out.println(key); // 일,이,삼 출력
                }

                // value 값 전체 출력
                for (Integer key : intMap.values()) {
                    System.out.println(key); // 11,12,15 출력
                }

                // get()
                System.out.println(intMap.get("삼")); // 15 출력
            }
        }