[JAVA] 컬렉션 정리

💡 컬렉션?

자바에서 자료구조를 표현하는 인터페이스이다.

컬렉션을 구현한 자료구조에는 List, Stack, Queue, Set, Map이 있다.

자바의 자료형은 크게 기본 타입(primitive type)과 참조 타입(reference type)으로 나누어진다. 대표적으로 기본 타입에는 char, int, float, double, boolean 등이 있고 참조 타입은 class, interface 등이 있다. Collection의 자료형에는 primitive 타입은 올 수 없다. primitive 타입에 해당하는 wrapper class 가 존재하니 그것을 대신 사용하자.

List<Integer> ingeterList = new ArrayList<>();
List<String> stringList = new ArrayList<>();

 

💡 List

: 순서가 있는 데이터의 집합이며 데이터의 중복을 허용한다.
→ ArrayList, LinkedList, Stack 등

public class Main {
    public static void main(String[] args) {
        List list = new ArrayList(10);
        list.add(1);
        list.add(5);
        list.add(4);
        list.add(11);
        list.add(10); // ArrayList에 값 한개씩 입력
        System.out.println(list); // [1,5,4,11,10]

        Collections.sort(list); // list 정렬
        System.out.println(list); // [1,4,5,10,11]

        System.out.println(list.size()); // arrayList의 크기 출력

        arrayList.remove(4); // 인덱스를 활용하여 해당하는 값 제거
        System.out.println(list);

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i)); // get을 이용하여 값 1개씩 출력
        }
        
        // for each문
        for (int current : list) {
             System.out.println(current);
        }

    }
}

 

💡 Set

: 순서를 유지하지 않는 데이터의 집합이며 데이터의 중복을 허용하지 않는다.
→ HashSet, TreeSet 등

public class Main {
    public static void main(String[] args) {

        Set<String> stringSet = new HashSet<>();
        stringSet.add("LA");
        stringSet.add("LA"); // 두개를 넣어도 하나만 저장함
        stringSet.add("New York");
        stringSet.add("LasVegas");
        stringSet.add("San Francisco");
        stringSet.add("Seoul");
        System.out.println(stringSet); // 순서가 지켜지지 않음

        stringSet.remove("Seoul"); // 인덱스가 존재하지 않음. Seoul을 HashSet에서 제거함
        System.out.println(stringSet);

        ArrayList<String> target = new ArrayList<String>();
        target.add("New York");
        target.add("LasVegas"); //제거할 항목을 ArrayList에 삽입
        stringSet.removeAll(target); //제거항목에 삽입된 도시들을 삭제
        System.out.println(stringSet);

        System.out.println("LA가 포함되어있는가? " + stringSet.contains("LA"));
        System.out.println("LA가 포함되어있는가? " + stringSet.contains("LasVegas"));
        // LA가 HashSet에 포함되어있으면 true를, 그렇지 않으면 false를 반환합니다.

        System.out.println("현재 HashSet의 크기는 : " + stringSet.size() + "입니다.");

        stringSet.clear();//HashSet의 모든 아이템들을 삭제합니다.
        System.out.println(stringSet);
    }
}

 

💡 Map

: 키(key)와 값(value)의 쌍으로 이루어진 데이터의 집합이다.

: 키와 값을 통하여 해싱(hashing)을 가능하게 하여 데이터를 검색하는데 뛰어난 성능을 보여준다.
: 순서는 유지되지 않으며 키는 중복을 허용되지 않고 값은 중복을 허용한다.
→ HashMap, TreeMap 등

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "apple");
        map.put(2, "berry");
        map.put(3, "cherry");

        System.out.println(map);
        System.out.println("1 in map: " + map.get(1)); // 1은 인덱스 아니고 key!!

        map.remove(2); // 인덱스 아니고 key!
        System.out.println(map);
        System.out.println(map.containsKey(2));
        System.out.println(map.containsValue("cherry"));
        
        map.clear();
        System.out.println(map);
    }
}

 

 

💡 Stack

: 마지막에 넣은 데이터를 먼저 꺼내는 자료구조이다. LIFO(Last In First Out)
→ Stack, ArrayDeque 등

public class Main {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.push(1);
        stack.push(3);
        stack.push(5);
        stack.push(7);
        System.out.println(stack); // Stack을 출력

        System.out.println(stack.peek()); // Stack의 가장 상단 값을 출력한다.(삭제는 하지 않음)
        stack.pop(); // Stack의 가장 상단 값을 제거
        System.out.println(stack);
        System.out.println(stack.size()); // Stack의 크기를 반환
        System.out.println(stack.contains(1)); // Stack에 1이라는 값이 있으면 true를, 그렇지 않으면 false를 반환
        System.out.println(stack.empty()); // STack이 비어있으면 true를, 그렇지 않으면 false를 반환
        System.out.println(stack);
    }
}

 

 

💡 Queue

: 먼저 넣은 데이터를 먼저 꺼내는 자료구조이다. FIFO(First In First Out)
→ Queue, ArrayDeque 등

public class Main {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        queue.add(1);
        queue.add(3);
        queue.add(5); //Queue에 값 삽입
        
        System.out.println(queue); // Queue 출력
        System.out.println(queue.poll()); // Queue에서 객체를 꺼내서 반환
        
        queue.add(7);
        queue.add(11);
        queue.add(9);
        System.out.println(queue);
        System.out.println(queue.peek()); // Queue에서 삭제 없이 요소를 반환
        System.out.println(queue);
    }
}

 

💡 ArrayDeque

: 양 끝에서 삽입과 삭제가 이루어지는 자료구조이다.

: 실무에서는 단순히 Stack, Queue 클래스 대신에 ArrayDeque 많이 사용한다고 한다. 기본 Stack, Queue의 기능을 모두 포함하면서도 성능이 더 좋기 때문이다.

public class Main {
    public static void main(String[] args) {
        ArrayDeque<Integer> arrayDeque = new ArrayDeque<>();
        arrayDeque.addFirst(1);
        arrayDeque.addFirst(2);
        arrayDeque.addFirst(3);
        arrayDeque.addFirst(4); // arrayDeque의 앞에 값을 삽입
        System.out.println(arrayDeque);

        arrayDeque.addLast(0); // arrayDeque의 끝에 값을 삽입
        System.out.println(arrayDeque);

        arrayDeque.offerFirst(10); 
        // addFirst와 비슷하지만 큐의 크기 문제가 생길 때, 
        // offerFirst는 false를, addFrist는 exception을 반환함
        arrayDeque.offerLast(-1); // arrayDeque의 끝에 값을 삽입
        System.out.println(arrayDeque);
        System.out.println(arrayDeque.size()); // 7


        System.out.println(arrayDeque.removeFirst()); // 첫번째 값을 제거하면서 그 값을 리턴
        System.out.println(arrayDeque.removeLast()); // 마지막 값을 제거하면서 그 값을 리턴
        System.out.println(arrayDeque.pollFirst()); // 첫번째 값을 반환 및 제거하면서 그 값을 리턴
        System.out.println(arrayDeque.size()); // 4


        System.out.println(arrayDeque.pollLast()); // 마지막 값을 반환 및 제거하면서 그 값을 리턴
        System.out.println(arrayDeque.peekFirst()); // 첫번째 값을 반환, 제거하지 않음
        System.out.println(arrayDeque.peekLast()); // 마지막 값을 반환, 제거하지 않음
        System.out.println(arrayDeque.size()); // 3
        
    }
}