우선, 글을 작성하기 전 이 글의 모든 내용은 김영한님의 JAVA 강의를 바탕으로 함을 알립니다.

💡Stack, Queue, Deque

이번 포스팅에서는 대표적인 선형 자료구조인 Stack, Queue 그리고 Deque에 대해서 알아보자

Stack

• 후입 선출(LIFO, Last In First Out)의 자료구조
• 즉, 나중에 넣은 것이 가장 먼저 나오는 것을 후입선출 자료구조라고 한다

◻️ 주의!

JAVA에서 제공하는 Stack은 사용하지 않는 것을 지향한다. Stack 클래스 내부에서 Vector라는 자료 구조를 사용하는데, 이 자료구조는 지금은 사용되지 않고 하위 호환을 위해 존재한다. 대신에 Deque를 사용하는 것을 권장한다

◻️ Stack 활용 예제

public class StackMain {

    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();

        stack.push(1);
        stack.push(2);
        stack.push(3);
        System.out.println(stack);

        // 다음 꺼낼 요소 확인(꺼내지 않고 단순 조회)
        System.out.println("stack.peek() = " + stack.peek());

        // 스택 요소 뽑기
        // LIFO 후입 선출
        System.out.println("stack.pop() = " + stack.pop());
        System.out.println("stack.pop() = " + stack.pop());
        System.out.println("stack.pop() = " + stack.pop());
        System.out.println(stack);
    }
}

Queue

• 선입 선출(FIFO, Fist In Fist Out)의 자료구조

• Queue에 값을 넣는 것을 offer, 값을 꺼내는 것을 poll이라고 한다

◻️ 컬렉션의 Queue

• java의 Collection은 Queue인터페이스를 구현체로 제공한다.

◻️ Queue 활용 예제

public class QueueMain {

    public static void main(String[] args) {
        Queue<Object> queue = new ArrayDeque<>();
//        Queue<Object> linkedlist = new LinkedList<>();

        //데이터 추가
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);
        System.out.println(queue);

        //다음 꺼낼 데이터 확인(꺼내지 않고 단순 조회만)
        System.out.println("queue.peek() = " + queue.peek());

        // 데이터 꺼내기
        System.out.println("queue.poll() = " + queue.poll());
        System.out.println("queue.poll() = " + queue.poll());
        System.out.println("queue.poll() = " + queue.poll());
        System.out.println(queue);
    }
}

Deque

Deque는 Double Ended Queue의 약자로, 자료구조의 끝 양쪽에서 데이터를 추가하거나 삭제할 수 있는 자료구조이다. 컬렉션에서는 Queue인터페이스의 구현체로 제공된다

• offerFirst() : 앞에 추가한다.
• offerLast() : 뒤에 추가한다.
• pollFirst() : 앞에서 꺼낸다.
• pollLast() : 뒤에서 꺼낸다.

◻️ Deque 활용 예제

public class DequeMain {

    public static void main(String[] args) {
        Deque<Integer> deque = new ArrayDeque<>();
//        Deque<Integer> deque = new LinkedList<>(); 더 느림

        // 데이터 추가
        deque.offerFirst(1);
        System.out.println(deque);
        deque.offerFirst(2);
        System.out.println(deque);
        deque.offerFirst(3);
        System.out.println(deque);
        deque.offerFirst(4);
        System.out.println(deque);

        // 다음 꺼낼 데이터 확인(단순 조회)
        System.out.println("deque.peekFirst() = " + deque.peekFirst());
        System.out.println("deque.peekLast() = " + deque.peekLast());

        // 데이터 꺼내기
        System.out.println("deque.pollFirst() = " + deque.pollFirst());
        System.out.println("deque.pollFirst() = " + deque.pollFirst());
        System.out.println("deque.pollLast() = " + deque.pollLast());
        System.out.println("deque.pollLast() = " + deque.pollLast());
        System.out.println(deque);
    }
}

◻️ Deque와 Stack, Queue

Deque는 요소를 저장하는 처음과 끝 즉, 양쪽에서의 데이터 추가와 삭제가 가능하다. 이러한 Deque의 성질로 인해 Deque를 통해 Queue와 Stack을 모두 구현할 수 있다. java의 Deque 인터페이스는 이러한 Deque의 성질을 반영해 Stack의 데이터 입력(push()), 데이터 삭제(pop()) 그리고 Queue의 데이터 입력(offer()), 데이터 삭제(poll())을 제공한다.

// Deque-Stack
import java.util.ArrayDeque;
import java.util.Deque;

/**
 *  Deque 자료구조를 stack으로 사용할 수 있음 이때 단순히 Deque의 offer와 poll이 아닌
 *  stack의 push pop을 그대로 사용할 수 있음
 */
public class DequeStackMain {

    public static void main(String[] args) {
        Deque<Object> deque = new ArrayDeque<>();

        // 데이터 추가
        deque.push(1);
        deque.push(2);
        deque.push(3);
        System.out.println(deque);

        // 다음 꺼낼 데이터 확인(꺼내지 않고 단순 조회만)
        System.out.println("deque.peek() = " + deque.peek());

        // 데이터 꺼내기
        System.out.println("deque.pop() = " + deque.pop());
        System.out.println("deque.pop() = " + deque.pop());
        System.out.println("deque.pop() = " + deque.pop());
        System.out.println(deque);
    }
}

우선, 글을 작성하기 전 이 글의 모든 내용은 김영한님의 JAVA 강의를 바탕으로 함을 알립니다.

💡Map 인터페이스

Map은 키-값쌍을 저장하는 자료구조이다.

• Key는 중복이 불가능하다. Key를 통해 Value를 빠르게 검색이 가능하다
• Value는 중복이 가능하다.
• Map은 순서를 허용하지 않는다

Map 인터페이스

◻️ HashMap

• 가장 많이 사용
• 해시 인덱스를 통해 요소를 저장
  • key값은 해시함수를 통해 해시 인덱스로 변환되고 데이터 저장, 삭제에 사용됨
• 일반적으로 O(1) 성능을 가짐 (해시 충돌이 많으면 최악의 경우 O(n))

• 주의점!
  • HashSet과 동일하게 해시코드로 변형이 되어야 하는 참조형은 반드시 hashCode()와 equals()를 오버라이딩하여 재정의 해주어야 한다. 따라서, HashMap의 Key로 사용되는 객체는 반드시 hashCode() , equals()를 반드시 구현해야 한다

◻️ LinkedHashMap

• Node를 도입하여 LinkedList를 통해 입력된 요소의 순서를 유지
• 상대적으로 HashMap보다 무거움

◻️ TreeMap

• 레드-블랙 트리 기반으로 정렬된 순서를 가짐
• 모든 key는 Comparator(비교자)에 의해 정렬됨
• get, move, remove는 O(logN)의 성능을 가짐

Set과 Map의 관계

Map의 특징은 중복을 허용하지 않고, 순서를 보장하지 않는다는 것이다. 이 특성은 Set의 특성과 동일하다. 즉, Map의 Key가 결국 Set과 동일하게 작동다는 것을 의미하고, 이는 결국 Set은 Map에서 value부분만 제거된 것이라고 봐도 무방하다. 따라서 다음과 같은 유의미한 상관관계를 갖는다

• HashSet -> HashMap
• LinkedHashSet -> LinkedHashMap
• TreeSet -> TreeMap

우선, 글을 작성하기 전 이 글의 모든 내용은 김영한님의 JAVA 강의를 바탕으로 함을 알립니다.

💡Set 인터페이스

이전 포스팅에서 Set 자료구조의 특징과 Hash 알고리즘에 대해서 학습하였다. JAVA는 컬렉션을 통해 Set 인터페이스를 제공하고 대표적으로 HashSet,LinkedHashSet,TreeSet이 구현체로 다양한 Set 자료 구조 기능을 제공한다.

• HashSet : Hash 알고리즘에 기반한 Set 자료구조
• LinkedHashSet : HashSet의 데이터 저장 공간을 LinkedList로 구성하여 데이터 입력 순서를 보장하는 Set 자료구조
• TreeSet : 이진 탐색을 기반으로 데이터를 정렬한 Set

HashSet

• 구현 : Hash 자료구조를 사용하여 요소 저장
• 순서 : 데이터 입력 순서를 보장 x
• 시간복잡도 : 주요 연산(추가, 삭제, 검색)은 평균적으로 O(1)
• 용도 : 데이터 순서 상관없이 데이터의 유일성이 중요한 경우

LinkedHashSet

• 구현 : HashSet에 LinkedList를 추가하여 입력된 요소들의 순서를 보장
• 순서 : 데이터 입력에 따른 순서 보장
• 시간복잡도 : 주요 연산(추가, 삭제, 검색)은 평균적으로 O(1)
• 용도 : 데이터의 유일성과 데이터 입력 순서 모두를 보장해야 하는 경우

TreeSet

• 구현 : TreeSet은 이진 탐색 트리를 개선한 레드-블랙 트리를 내부에서 사용
• 순서 : 요소들은 정렬된 순서로 저장됨. 순서의 기준은 비교자(Comparator)로 변경 가능
• 시간 복잡도 : 주요 연산은 O(log n)의 시간 복잡도를 가짐
• 용도 : 데이터를 정렬된 순서로 유지하면서 Set의 특성을 활용해야 하는 경우

◻️ Tree 구조

• 트리구조는 부모 노드와 자식 노드로 구성
• 이진 트리 : 자식이 2개까지 올 수 있는 트리
• 이진 탐색 트리 : 특정 노드의 왼쪽 자손은 더 작은 값, 오른쪽 자손은 더 큰 값을 가져 정렬이 된 것을 이진 탐색 트리라고 한다

class Node {
     Object item;
     Node left;
     Node right;
}

◻️ 이진 탐색 트리의 Big-O

위의 Tree 구조에서 사용한 데이터를 보면, 15개의 데이터로 구성되어 있는 것을 확인할 수 있다. 여기서 숫자 35를 검색한다고 가정하면 다음과 같은 과정이 진행된다.

• 1번 : root인 20과 검색 대상인 35를 비교 -> 35가 크기에 오른쪽으로 찾아감
• 2번 : 40 vs 35 -> 40이 크기에 왼쪽으로 찾아감
• 3번 : 30 vs 35 -> 35가 크기에 오른쪽으로 찾아감
• 4번 : 35 vs 35 -> 35를 찾음

15개의 데이터에서 4번의 연산만으로 결과를 얻음. 이는 List의 검색(O(n)) 보단 성능이 좋고 Hash의 검색(O(1))보다는 느리다.

이진 탐색의 핵심원리는 한번의 연산으로 데이터의 절반을 날릴 수 있다는 점이다. 비교 대상 기준 크다 와 작다의 이분법적 개념으로만 접근하기 때문이다. 예를들어, 검색 대상이 35인 경우 root(20) vs 35 에서 35가 root 보다 크기 때문에 root 보다 작은, 왼쪽에 있는 데이터들은 고려할 필요가 없어진다.

즉, 16개의 데이터 기준 이진 탐색은 16->8->4->2->1 ,4번의 연산만으로 목표에 도달할 수 있다는 의미이고 이를 일반화 하면 n개의 데이터 기준 logN (밑은 2이다)의 연산이 필요 함을 알 수 있다.

따라서, 이진 탐색 트리의 Big-O 는 O(logN) 이다.

우선, 글을 작성하기 전 이 글의 모든 내용은 김영한님의 JAVA 강의를 바탕으로 함을 알립니다.

💡Hash 알고리즘

List와 Set

• List : 순서 유지, 중복 허용, 인덱스 접근 가능의 특징을 갖는 선형 자료구조 (앞에서 많이 언급)
• Set : 유일한 요소의 컬렉션
  • 특징
    • 유일성 : Set의 요소는 중복이 불가능
    • 순서 미보장 : Set의 요소는 순서가 정해져 있지 않음
  • 용도 : 중복을 허용하지 않고, 요소의 유무만 중요한 경우 사용

◻️ 직접 구현해보는 Set

public class MyHashSetV0 {

    private int[] elementData = new int[10];
    private int size = 0;

    // O(n)
    public boolean add(int value) {
        if (contains(value)) {
            return false;
        }
        elementData[size] = value;
        size++;
        return true;
    }

    // O(n)
    public boolean contains(int value) {
        for (int data : elementData) {
            if (data == value) {
                return true;
            }
        }
        return false;
    }

    public int size() {
        return size;
    }

    @Override
    public String toString() {
        return "MyHashSetV0{" +
                "elementData=" + Arrays.toString(Arrays.copyOf(elementData,size)) +
                ", size=" + size +
                '}';
    }
}

• 배열을 활용한 Set을 구현한 결과 Set의 특성상 중복이 허용되면 안되기 때문에 add() 메서드에서 중복되지 않은 대상만 요소로 추가가 가능하도록 contains()를 통해 배열의 모든 요소를 검사하는 과정을 진행한다.
• 즉, 성능이 O(n)으로 좋지않다.

Hash 알고리즘 도입

배열을 데이터의 저장소로 사용한 Set의 경우를 다시 생각해보자. 배열의 경우 인덱스를 통한 조회하는 기능은 O(1)으로 높은 성능을 갖는다. 그렇다면 데이터를 배열의 인덱스로 사용한다면 인덱스 조회와 데이터 검색이 함께 가능하지 않을까??

즉, 입력되는 데이터를 동일한 인덱스 공간에 저장하면 조회와 검색이 빨라지지 않을까?

◻️ 데이터 값을 배열 인덱스로 사용하는 경우

• 인덱스 1에는 데이터 1이 들어있고, 인덱스 8에는 데이터 8이 들어있다. 즉, 저장하는 데이터와 인덱스를 완전히 맞추어 인덱스 번호가 데이터가 되고, 데이터가 인덱스 번호가 되었다.
• 하지만 낭비되는 메모리가 너무 많다. 만약에 int의 모든 범위에서 특정 숫자를 Set 자료구조에 추가한다고 가정하면 빈공간으로만 메모리를 거의 다 사용하는 상황이 발생한다.

◻️ 나머지 연산

메모리를 절약하면서, 넓은 범위의 값을 사용할 수 없을까? 나머지 연산을 사용하면 가능하다. 예를들어, 배열의 크기를 10으로 고정했다고 가정하자.

• 1 % 10 = 1
• 2 % 10 = 2
• 3 % 10 = 3
• 4 % 10 = 4
• 5 % 10 = 5
• 24 % 10 = 4
• 99 % 10 = 9 나머지 연산을 활용하면, 나머지 연산의 결과는 절대로 배열의 크기를 넘지 않고 결국 배열의 크기만큼 배열에 저장할 수 있게 된다.

◻️ 해시 인덱스

해시 인덱스(hashIndex) 란 배열의 인덱스로 사용할 수 있도록 원래의 값을 계산한 인덱스를 의미한다.

◻️ 해시 충돌

99와 9를 모두 10으로 나누면 동일한 나머지인 9를 해시 인덱스로 갖게 된다. 이렇게 해시 충돌이란 다른 값을 입력했지만 같은 해시 코드가 나오는 것을 의미한다. 어떻게 해야할까?

• 99와 9를 같이 저장하면 된다
• 배열의 원소를 또다른 배열로 만든다면 동시 저장이 가능하다

◻️ 해시 충돌 조회 및 성능

해시충돌이 발생한 경우 내부의 데이터를 하나씩 비교해보면 결과를 찾을 수 있다. 위의 예에서 99를 조회한다고 가정하자.

• 9번 인덱스까지 배열의 특성을 통해 조회
• 9번 인덱스의 내부 배열에서 반복문과 equals()를 통해 배열내의 모든 값을 비교하여 99를 검색

해시 충돌 상황에서의 값 조회 과정을 살펴보니 추가되는 데이터에의해 특정 인덱스에 데이터가 많이 몰리는 경우가 발생할 수 있다.

• 이 경우 모든 입력 데이터에 대한 해시 인덱스는 9가 된다
• 따라서 9번 인덱스에 모든 데이터가 저장되고, 특정 데이터를 조회할 때 결국 반복문에 의해 저장된 데이터 수 만큼 비교가 이루어져야 한다
• 즉, 최악의 경우 O(n)의 성능을 갖게 된다.

정리

• 해시 알고리즘에 의한 해시 인덱스를 사용하는 경우
  • 데이터 저장
    • 평균 : O(1)
    • 최악 : O(n)
  • 데이터 조회
    • 평균 : O(1)
    • 최악 : O(n)
• 해시 인덱스를 사용하는 방식에서 최악의 경우(해시 충돌에서의 최악 경우)는 거의 발생하지 않고 배열의 크기만 적절하게 잡아주면 대부분 O(1)의 성능을 갖는다

우선, 글을 작성하기 전 이 글의 모든 내용은 김영한님의 JAVA 강의를 바탕으로 함을 알립니다.

💡List

앞 포스트에서 ArrayList와 LinkedList를 살펴보았다. java에서 제공하는 두 클래스는 List인터페이스의 구현체로 List인터페이스의 핵심 메서드만 살펴보면 다음과 같다

public interface MyList<E> {

    int size();

    void add(E e);

    void add(int index, E e);

    E get(int index);

    E set(int index, E element);

    E remove(int index);

    int indexOf(E o);
}

List 추상화

• List는 순서가 있고 중복을 허용하는 자료구조

• 리스트 추상화

  • List를 인터페이스로 추상화하여 ArrayList, LinkedList를 구현체로 구현하면 다형성을 통해 유지보수 측면에서 많은 성능 향상을 구현할 수 있다.

  

의존 관계 주입(Dependency Injection)

ArrayList 자료구조를 통해 많은 데이터 유입을 처리하는 BatchProcessor라는 프로그램이 있다고 가정하자.

public class BatchProcessor {
    private final MyArrayList<Integer> list = new MyArrayList<>();

   /**
   * 처리 로직
   **/
}

• 이때 앞부분에서의 데이터 유입측면에서는 LinkedList가 ArrayList보다 성능이 높아 데이터 저장공간을 LinkedList로 변환하려고 한다. 즉, BatchProcessor의 직접적인 코드 수정이 필요하다. 이런 경우를 클라이언트 코드인 BatchProcessor가 구체적인 클래스에 의존한다고 표현한다.

• BatchProcessor가 추상적인 List에 의존하면 어떻게 될까?

public class BatchProcessor {

//    private final MyArrayList<Integer> list = new MyArrayList<>();
    private final MyList<Integer> list;

    public BatchProcessor(MyList<Integer> list) {
        this.list = list;
    }

    /**
    * 처리 로직
    **/
}

• 수정된 BatchProcessor를 보면 생성자를 통해 List타입의 참조형 객체를 직접 외부에서 받아오는 것을 확인 할 수 있다. 다형성에 의해 생성자로 유입되는 list로 List의 구현체는 모두 가능하다.
• 즉, BatchProcessor내부에서 상황에 따라 코드의 수정 없이 ArrayList 또는 LinkedList를 외부의 유입을 통해 사용이 가능한 것이다.
• 위와 같이 추상적인 List와 생성자를 통해 클래스(BatchProcessor)외부에서 의존할 대상이 결정되어서 다형성에 의해 내부로 유입되는 것을 DI(Dependency Injection), 의존성 주입이라고 한다

다시 정리 해보자.

◻️ 컴파일 타임 의존관계

• 런타임 이전 컴파일 시점에는 클라이언트인 BatchProcessor가 List 인터페이스에만 의존 한다

◻️ 런타임 의존관계

• 코드가 실행되어 런타임 시점에는 생성자를 통해 ArrayList 또는 LinkedList 참조값이 클라이언트인 BatchProcessor에 전달됨
• 즉, 클라이언트는 의존 관계를 클래스내에서 결정하지 않고 런타임의 객체 생성 시점에 결정한다. OCP 원칙에 의해 클라이언트 코드 변경없이 다형적 참조에 의해 구현체를 성능에 맞게 사용하여 필요한 기능을 사용할 수 있게 된다

정리

1. 의존관계를 클래스 내부에서 직접 의존하면 상황에 따라 클라이언트 코드를 매번 변경하는 일이 발생한다
2. 의존성 주입을 통해 객체간의 의존을 클래스 외부에서 구현하여 클라이언트 코드의 변경없이 구현이 가능하다

우선, 글을 작성하기 전 이 글의 모든 내용은 김영한님의 JAVA 강의를 바탕으로 함을 알립니다.

💡LinkedList

이전 시간에는 ArrayList에 대해 살펴보았다. ArrayList의 단점에 대해 다시 살펴보자.

ArrayList의 단점

• 고정된 크기

  • ArrayList는 배열을 통해 데이터를 보관
  • 배열은 생성과 동시에 크기가 고정된 연속적인 자료구조 → 데이터의 추가/삭제 여부 예측이 어려워 메모리 낭비 발생

  

• 데이터의 추가/삭제 성능이 안좋다
  • add(추가) : 기준 index 이후의 데이터를 전부 오른쪽으로 한 칸씩 이동 후 해당 index 위치의 데이터를 새로운 것으로 대체, O(n)
  • remove(제거) : 해당 index 위치 이후의 데이터를 전부 왼쪽으로 한 칸씩 이동, O(n)

LinkedList

LinkedList는 Node를 활용하여 낭비되는 메모리 없이 필요한 만큼만 메모리를 확보해서 사용하고, 앞 중간에 데이터를 추가하거나 삭제할 때도 효율적인 자료 구조이다.

◻️ Node

public class Node {
    Object item;
    Node next;
}

• Node는 내부에 저장할 데이터인 item과, 다음으로 연결할 노드의 참조값인 next를 가진다
• 여러 노드가 연결되면 다음과 같다

◻️ 직접 구현해보는 LinkedList

제너릭과 중첩 클래스는 따로 정리 할 예정이다

public class MyLinkedListV3<E> {

    private Node<E> first;  // 첫번째 노드 
    private int size = 0; // 현재 저장되어 있는 데이터의 양

    // add : 마지막에 데이터 추가
    public void add(E e) {
        Node<E> newNode = new Node(e);
        if (first == null) {
            first = newNode;
        } else {
            Node<E> lastNode = getLastNode(); // O(n)
            lastNode.next = newNode;
        }
        size++;

    }

    private Node<E> getLastNode() {
        Node<E> x = first;
        while (x.next != null) { //
            x = x.next;
        }
        return x;
    }

    // 특정 index 위치에 노드 add
    public void add(int index, E e) {
        Node<E> newNode = new Node<>(e);
        if (index == 0) {
            newNode.next = first;
            first = newNode;
        } else {
            Node<E> prev = getNode(index - 1);
            newNode.next = prev.next;
            prev.next = newNode;
        }
        size ++;
    }

    // 특정 index의 값 변경
    public E set(int index, E element) {
        Node<E> x = getNode(index);
        E oldValue = x.item;
        x.item = element;
        return oldValue;
    }

    // 삭제
    public E remove(int index) {
        Node<E> removeNode = getNode(index);
        E removedItem = removeNode.item;
        if (index == 0) {
            first = removeNode.next;
        } else {
            Node<E> prev = getNode(index - 1);
            prev.next = removeNode.next;
        }
        /**
         *  GC는 메모리 참조값을 기준으로 작동한다.
         *  GC는 더 이상 참조되지 않는 객체를 찾아 제거하기 때문에
         *  제거 대상이 참조되고 있거나 다른 객체를 참조하고 있다면 GC는 이를 삭제하지 않음
         *  따라서, 명시적으로 null을 통해 참조값을 제거해야한다.
         */
        removeNode.item = null;
        removeNode.next = null;
        size--;
        return removedItem;
    }

    // 특정 index의 value값 조회
    public E get(int index) {
        Node<E> node = getNode(index);
        return node.item;
    }

    // 특정 index의 노드 조회 메서드
    private Node<E> getNode(int index) {
        Node<E> x = first;
        for (int i = 0; i < index; i++) {
            x = x.next;
        }
        return x;
    }

    public int indexOf(E o) {
        int index = 0;
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                return index;
            }
            index++;
        }
        return -1;
    }

    public int size() {
        return size;
    }

    @Override
    public String toString() {
        return "MyLinkedListV1{" +
                "first=" + first +
                ", size=" + size +
                '}';
    }

    // 중첩 클래스를 활용하여 Node를 LinkedList 내부에 설정
    private static class Node<E> {

        E item;
        Node<E> next;

        public Node(E item) {
            this.item = item;
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            Node<E> x = this;
            sb.append("[");
            while (x != null) {
                sb.append(x.item);
                if (x.next != null) {
                    sb.append("->");
                }
                x = x.next;
            }
            sb.append("]");

            return sb.toString();
        }
    }
}

• add(Object o) : o를 item으로 갖는 node를 '순차적으로' 추가
• add(int index, Object o) : index 위치에 o를 item으로 갖는 node 추가
• set(int index, Object o) : index 위치의 노드의 item을 o로 변경
• get(int index) : index 위치의 노드의 item 반환
• getNode(int index) : index 위치의 노드 반환
• indexOf(Object o) : item을 o로 갖는 노드의 인덱스 반환

ArrayList vs LinkedList

• 공통점 : 중복을 허용하고 순서가 있는 자료구조

• 차이점 : 성능 차이

  기능	ArrayList	LinkedList
  인덱스 조회	O(1)	O(n)
  데이터 검색	O(n)	O(n)
  앞에 데이터 추가	O(n)	O(1)
  뒤에 데이터 추가	O(1)	O(n)
  중간에 데이터 추가	O(n)	O(n)

정리

• 데이터를 조회할 일이 많고, 뒷 부분에 데이터를 빈도있게 추가한다 → ArrayList
• 앞 부분에 데이터를 빈도있게 추가하거나 삭제할 일이 많다 → LinkedList
• java가 제공하는 collection의 LinkedList는 이중연결리스트이기에 앞/뒤 데이터 추가 삭제 모두 성능이 좋다

우선, 글을 작성하기 전 이 글의 모든 내용은 김영한님의 JAVA 강의를 바탕으로 함을 알립니다.

💡ArrayList

배열

고정된 크기의 연속된 메모리의 공간을 갖는 자료구조

◻️ 배열의 특징

1. 인덱스(index)를 이용하여 빠르게 자료에 접근 가능 (O(1))
2. 인덱스를 통한 입력(add), 변경(set), 조회(contains)의 경우 한번의 계산으로 자료의 위치에 도달 가능

◻️ 배열의 index 활용 예시

• arr[0]: x100 + (4byte * 0) : x100
• arr[1]: x100 + (4byte * 1) : x104
• arr[2]: x100 + (4byte * 2) : x108

◻️ 배열의 검색

배열의 경우 index를 통해 특정 인덱스의 위치까지 빠르게 접근이 가능하지만 배열에 저장되어 있는 데이터를 확인하기 위해서는 데이터를 처음부터 하나하나 비교해야한다(O(n))

◻️ 배열의 데이터 추가

• 첫번째 위치에 추가
  • 기존의 데이터 오른쪽으로 이동 O(n)
  • 추가 데이터 첫번재 인덱스 위치에 접근 후 저장 O(1)

• 중간(특정 index)에 추가
  • 특정 index 이후의 데이터 오른쪽으로 이동 O(n)
  • 특정 index에 접근 후 데이터 저장 O(1)

• 마지막 위치에 추가
  • 마지막 index에 접근 후 데이터 저장 O(1)\

◻️ 배열의 한계

• 배열은 생성과 동시에 크기가 고정된다
  • 배열의 크기가 1000으로 가정하면 배열에 저장되는 데이터가 현저히 작으면 메모리 낭비가 된다. 반대로 배열에 저장되는 데이터가 1000개가 넘어가면 더이상 데이터 추가가 불가능하다

ArrayList

◻️ List 자료구조

• 순서가 있고 중복을 허용하는 자료구조

◻️ 직접 구현하는 ArrayList

public class ArrayListReview {

    private Object[] elementArray;
    private int size = 0; // 현재 value가 채워져있는 정도 ex. 5크기의 배열에 idx = 3까지 채워져있음 size = 3

    public ArrayListReview(int initialCapacity) {
        this.elementArray = new Object[initialCapacity];
    }

    // size 반환
    public int Size() {
        return size;
    }

    // 데이터 추가
    // 동적 배열을 구현
    public void add(Object o) {
        if (size == elementArray.length) {
            grow();
        }
        elementArray[size] = o;
        size ++;
    }

    // 특정 인덱스 위치에 데이터 추가
    public void add(int index, Object o) {
        if (size == elementArray.length) {
            grow(); // 크기 동적 변환
        }
        shiftRightFrom(index);
        elementArray[index] = o;
        size ++;
    }

    private void shiftRightFrom(int index) {
        for (int i = size; i > index; i--) {
            elementArray[i] = elementArray[i-1];
        }
    }

    private void grow() {
        int oldCapacity = elementArray.length;
        int newCapacity = oldCapacity * 2;

        Object[] newArray = Arrays.copyOf(elementArray, newCapacity);
        elementArray = newArray;
    }

    // 특정 인덱스의 value 반환
    public Object get(int index) {
        return elementArray[index];
    }

    // 특정 인덱스의 value 변경
    public Object set(int index, Object element) {
        Object oldValue = get(index);
        elementArray[index] = element;
        return oldValue;
    }

    // 특정 value의 인덱스 반환
    public int indexOf(Object o) {
        for (int i = 0; i < elementArray.length; i++) {
            if (elementArray[i] == o) {
                return i;
            }
        }
        return -1;
    }

    // 특정 인덱스 value 삭제
    public Object remove(int index) {
        Object oldValue = get(index);
        shiftLeftFrom(index);

        size --;
        elementArray[size] = null; // 자동 안되나?
        return oldValue;
    }

    private void shiftLeftFrom(int index) {
        for (int i = index; i < size - 1; i++) {
            elementArray[i] = elementArray[i + 1];
        }
    }

    // size 크기만큼의 elementData를 복사 후 반환
    public String toString() {
        return Arrays.toString(Arrays.copyOf(elementArray,size)) +
                " size=" + size + ", capacity=" + elementArray.length;
    }
}

◻️ ArrayList의 단점

• 데이터 저장공간을 배열을 사용하였기에 고정된 크기에 의한 단점은 여전히 존재
• 데이터 추가와 삭제의 부분도 마지막 인덱스 위치를 제외하고는 기존의 데이터를 오른쪽 및 왼쪽으로 이동시켜야 하기 때문에 성능이 좋지 못함 O(n)

우선, 글을 작성하기 전 이 글의 모든 내용은 김영한님의 JAVA 강의를 바탕으로 함을 알립니다.

💡열거형 ENUM 2

직전 포스팅에서 고정된 상수 값들의 집합을 정의할 때 String을 사용했을 때의 문제점과 타입 안전 열거형 패턴의 개념을 알아보고 구현을 해보았다. 이번 포스팅에서는 JAVA에서 제공하는 ENUM 열거형 패턴과 열거형 리팩토링 및 열거형이 제공하는 메서드에 대해 알아보자.

열거형 ENUM Type

JAVA는 타입 안전 열거형 패턴을 쉽게 사용할 수 있도록 ENUM 열거형 타입을 제공한다. 이전 포스팅의 회원 등급과 가격을 입력하면 할인 금액을 계산해주는 예제의 classGrade를 ENUM타입으로 하면 다음과 같다

public enum Grade {
    BASIC, GOLD, DIAMOND  
}

/* Enum은 아래와 같다

public class Grade extends Enum {
    public static final Grade BASIC = new Grade();
    public static final Grade GOLD = new Grade();
    public static final Grade DIAMOND = new Grade();

    //private 생성자 추가
    private Grade() {}
}
 */

◻️ ENUM 특징

• 열거형도 클래스이다.
• 열거형 ENUM은 자동으로 java.lang.Enum을 상속 받는다
• 외부에서 임의로 생성할 수 없다 (private 생성자)
• 열거형은 인터페이스 구현 가능
• 열거형에 추상 메서드를 선언하고 구현 가능

ENUM은 결국 이전 포스팅의 ClassGrade와 기능이 거의 동일하다고 보면 된다. 다만 개발자가 사용하기 편하게 JAVA에서 직접 제공한다는 점이 차이점이다.

◻️ ENUM 장점

• 타입 안전성 향상 : 사전에 정의된 상수들로만 구성되기에 유효하지 않은 값이 입력되는 경우는 존재하지 않는다. 이런 경우 컴파일 에러가 발생한다
• 간결성 및 일관성 : ENUM을 사용하면 코드의 가독성이 높아지고, 타입 안전성 향상에 의해 데이터의 일관성이 보장된다.
• 확장성 : 새로운 등급을 추가하고 싶을 때, ENUM에 새로운 상수를 추가하면 끝난다.

열거형 주요 메서드

public class EnumMethod1 {

    public static void main(String[] args) {

        // values() : 모든 ENUM 반환
        Grade[] values = Grade.values();
        System.out.println("values = " + Arrays.toString(values)); // values = [BASIC, GOLD, DIAMOND]

        // name() : ENUM 상수 이름 문자열로 반환
        // ordinal() : ENUM 상수의 선언 순서(0부터 시작)를 반환 ,, 사용하지 않을 것을 권장 --> 상수 사이에 새로운 상수가 추가 될 경우 값이 많이 바뀜
        for (Grade value : values) {
            System.out.println("name = " + value.name() + ", ordinal = " + value.ordinal());
            /**
             * name = BASIC, ordinal = 0
             * name = GOLD, ordinal = 1
             * name = DIAMOND, ordinal = 2
             */
        }
        // valueOf(A) : ENUM 상수의 목록 중 A와 일치하는 ENUM 상수 반환 , 반환 타입은 ENUM 타입
        // A가 ENUM 상수에 없는 대상이라면 IllegalArgumentException에러 발생
        String input = "DIAMOND";
        Grade gold = Grade.valueOf(input);
        Grade gold2 = Grade.valueOf("VIP");
        System.out.println("gold = " + gold); // gold = DIAMOND
        System.out.println("gold2 = " + gold2); // 런타임 에러 발생 
    }
}

• values() : 모든 ENUM 상수를 포함하는 배열을 반환
• valueOf(String name) : 주어진 이름과 일치하는 ENUM 상수를 반환
• name() : ENUM 상수의 이름을 문자열로 반환하다.
• ordinal() : ENUM 상수의 선언 순서를 반환한다.
• toString() : ENUM 상수의 이름을 문자열로 반환 (오버라이딩을 통해 반환 내용 변경 가능)

열거형 리팩토링

◻️ ClassGrade 리팩토링

BASIC,GOLD,DIAMOND등급에따라 할인율을 적용한 로직을 다시 살펴보자.

public class DiscountService {
    public int discount(Grade classGrade, int price) {
        int discountPercent = 0;

        if (classGrade == BASIC) { // classGrade == x001
            discountPercent = 10;
        } else if (classGrade == GOLD) { 
            discountPercent = 20;
        } else if (classGrade == DIAMOND) {
            discountPercent = 30;
        } else {
            System.out.println("할인X");
        }
        return price * discountPercent / 100;
    }
}

로직에서는 if-else를 통해 각 등급마다 할인율을 적용하는 것을 알 수 있다. 즉, 결국 등급에 의해 할인율이 결정되는 것이기 때문에 이를 등급 class에서 관리해보자.

public class ClassGrade {

    public static final ClassGrade BASIC = new ClassGrade(10);
    public static final ClassGrade GOLD = new ClassGrade(20);
    public static final ClassGrade DIAMOND = new ClassGrade(30);

    private final int discountRate;

    private ClassGrade(int discountRate) {
        this.discountRate = discountRate;
    }

    public int getDiscountRate() {
        return discountRate;
    }
}

• discountRate를 private생성자의 매개변수를 통해 받아 객체 내의 필드에 저장하도록 한다
• getDiscountRate를 통해 외부에서 할인율을 조회할 수 있는 기능을 추가한다.

이렇게 된다면 ClassGrade내에서 사전에 정의한 BASIC,GOLD,DIAMOND등급은 각각 10,20,30의 할인율을 갖게되고 할인율 조회도 가능해진다.

ClassGrade.BASIC.getDiscount() // 10

ClassGrade에서 등급마다 할인율을 관리하게 된다면 DiscountService로직은 더 이상 if-else의 분기를 통해 할인율을 관리할 필요가 없어진다.

public class DiscountService {

    public int discount(ClassGrade classGrade, int price) {
        return price * classGrade.getDiscountRate() / 100;
    }
}

리팩토링을 마치고 DiscountService 로직을 보니 단순한 할인율 계산을 하는 로직만 남았다. ClassGrade에서 각 등급마다 할인율을 갖도록 리팩토링 하였는데 추가로 각 등급마다 할인율을 계산하여 갖고 있게 할 수 없을까? 최종적으로 리팩토링을 진행하면 다음과 같다.

public class ClassGrade {

    public static final ClassGrade BASIC = new ClassGrade(10);
    public static final ClassGrade GOLD = new ClassGrade(20);
    public static final ClassGrade DIAMOND = new ClassGrade(30);

    private final int discountRate;

    private ClassGrade(int discountRate) {
        this.discountRate = discountRate;
    }

    public int getDiscountRate() {
        return discountRate;
    }

    public int discount(int price) {
        return price * discountRate / 100;
    }

}

◻️ ENUM 리팩토링

위의 ClassGrade와 동일한 방향으로 ENUM을 리팩토링 해보자.

public enum Grade {

    BASIC(10), // private static final Grade BASIC = new Grade(10);
    GOLD(20),
    DIAMOND(30);

    private final int discountRate;

    Grade(int discountRate) {
        this.discountRate = discountRate;
    }

    public int getDiscountRate() {
        return discountRate;
    }

    public int discount(int price) {
        return price * discountRate / 100;
    }
}

즉, 더이상 DiscountService로직은 필요 없고 ENUM 열거형에서 고정된 범위의 상수를 설정하고 해당 상수와 괄련된 기능(메서드)를 제공하고 외부에서 이를 조회할 수 있게되었다.

정리

열거형 패턴 : 타입안정성과 데이터 일관성이 보장 된 고정된 범위의 상수 집합, 데이터 타입

• 타입 안정성

  • private 생성자로 인한 외부에서 객체 생성 금지
  • 열거형 클래스 내에서 미리 정의된 동일 타입의 객체를 상수화하여 고정된 범위의 상수 구현
  • 상수와 관련된 기능을 객체지향 관점에서 클래스 내의 필드와 메서드를 통해 구현 가능

• 데이터 일관성 타입 안정성에서 발생한 제약으로인해 데이터의 일관성이 유지

우선, 글을 작성하기 전 이 글의 모든 내용은 김영한님의 JAVA 강의를 바탕으로 함을 알립니다.

💡열거형 ENUM 1

열거형(Enum Type)은 Java에서 고정된 상수 값들의 집합을 정의할 때 사용하는 데이터 타입이다. 열거형을 사용하면 코드의 가독성, 안정성, 유지보수성이 높아진다고 나와있다. 그렇다면 열거형을 사용하지 않았을 때의 문제 즉, 열거형의 필요성을 알아보기위해 열거형이 만들어진 근본적인 이유를 알아야한다.

문자열과 타입 안정성

열거형의 경우 주로 값의 범위가 고정적이고 제한적일 때 사용한다. 이를 열거형이 아닌 문자열을 사용한 예제를 통해 문제점을 살펴보자.

회원 등급과 가격을 입력하면 할인 금액을 계산해주는 예제

/**
 * 고객은 3등급으로 나누고, 상품 구매시 등급별로 할인을 적용한다. 할인시 소수점 이하는 버린다.
 * BASIC 10% 할인
 * GOLD 20% 할인
 * DIAMOND 30% 할인
 */
public class DiscountService {

    public int discount(String grade, int price) {
        int discountPercent = 0;

        if (grade.equals("BASIC")) {
            discountPercent = 10;
        } else if (grade.equals("GOLD")) {
            discountPercent = 20;
        } else if (grade.equals("DIAMOND")) {
            discountPercent = 30;
        } else {
            System.out.println(grade + ": 할인X");
        }
        return price * discountPercent / 100;
    }
}

public class StringGradeEx0_1 {

    public static void main(String[] args) {
        int price = 10000;

        DiscountService discountService = new DiscountService();
        int basic = discountService.discount("BASIC", price);
        int gold = discountService.discount("GOLD", price);
        int diamond = discountService.discount("DIAMOND", price);

        System.out.println("BASIC 등급의 할인 금액: " + basic); 
        System.out.println("GOLD 등급의 할인 금액: " + gold);
        System.out.println("DIAMOND 등급의 할인 금액: " + diamond);

        /**
         * 출력 결과
         * BASIC 등급의 할인 금액: 1000
         * GOLD 등급의 할인 금액: 2000
         * DIAMOND 등급의 할인 금액: 3000
         */

    }
}

위 코드는 고객의 등급에 따라 할인 비율을 책정하여 할인된 금액을 반환하는 예제로, 고객의 등급(grade)을 String타입으로 생성하였다. 출력의 결과만 보면 정상적으로 프로그램이 실행되고 문제가 없어보이지만 타입 안정성과 데이터 일관성측면에서 문제점이 존재한다.

public class StringGradeEx0_2 {

    public static void main(String[] args) {
        int price = 10000;

        DiscountService discountService = new DiscountService();

        // 존재하지 않는 등급
        int vip = discountService.discount("VIP", price);
        System.out.println("VIP 등급의 할인 금액: " + vip);

        // 오타
        int diamondd = discountService.discount("DIAMONDD", price);
        System.out.println("DIAMONDD 등급의 할인 금액: " + diamondd);

        // 소문자 입력
        int gold = discountService.discount("gold", price);
        System.out.println("gold 등급의 할인 금액: " + gold);

        /**
         * VIP: 할인X
         * VIP 등급의 할인 금액: 0
         * DIAMONDD: 할인X
         * DIAMONDD 등급의 할인 금액: 0
         * gold: 할인X
         * gold 등급의 할인 금액: 0
         */

    }
}

◻️ 문제점

• 값의 제한 부족

  • 예제의 목적은 기준 등급인 BASIC,DIAMOND,GOLD에 따른 고객의 할인 비율 계산 및 할인 된 가격 제공이다. 즉, 3개의 등급을 제외한 다른 값은 할인 적용이 불가능해야한다.
  • 존재하지 않는 등급(VIP), 오타(DIAMONDD), 소문자(gold)에 대해서는 제약이 필요하지만 제약이 발생하지 않는다

• 컴파일 시 에러 감지 불가

  • 위의 제약이 발생하지 않는 이유는 String타입에 맞게 코드가 작성되었기 때문이다. 즉, 컴파일 과정에서 에러는 발생하지 않기에 개발자가 런타임에서 디버깅을 직접하여 문제점을 파악해야한다.

◻️ 해결 방법

위의 문제를 해결하려면 등급(grade)을 특정 값으로 제한해야 한다. 즉, 등급으로 반드시 BASIC,GOLD,DIAMOND만 적용되도록 해야한다.

문자열 상수를 활용해보자.

public class StringGrade {
    public static final String BASIC = "BASIC";
    public static final String GOLD = "GOLD";
    public static final String DIAMOND = "DIAMOND";
}

public class DiscountService {

    public int discount(String grade, int price) {
        int discountPercent = 0;

        if (grade.equals(StringGrade.BASIC)) {
            discountPercent = 10;
        } else if (grade.equals(StringGrade.GOLD)) {
            discountPercent = 20;
        } else if (grade.equals(StringGrade.DIAMOND)) {
            discountPercent = 30;
        } else {
            System.out.println(grade + ": 할인X");
        }

        //10000 * 20
        return price * discountPercent / 100;
    }
}

public class StringGradeEx1_1 {
    public static void main(String[] args) {
        int price = 10000;

        DiscountService discountService = new DiscountService();
        int basic = discountService.discount(StringGrade.BASIC , price);
        int gold = discountService.discount(StringGrade.GOLD, price);
        int diamond = discountService.discount(StringGrade.DIAMOND, price);

        System.out.println("BASIC 등급의 할인 금액: " + basic);
        System.out.println("GOLD 등급의 할인 금액: " + gold);
        System.out.println("DIAMOND 등급의 할인 금액: " + diamond);
    }

}

문자열 상수를 사용하면 가독성이 올라가고, 상수형태의 등급을 사용하기 때문에 잘못된 문자열 상수값을 입력할 시 컴파일 에러가 발생하여 오류를 쉽고 빠르게 찾을 수 있다.

하지만, String타입으로 인해 다른 문자열이 입력되었을 때는 여전히 컴파일 과정에서 오류를 찾을 수 없다는 문제점에 직면한다. 또한 만약 코드가 길어지고 복잡하여 여러 개발자가 파트를 나누어 개발을 한다고 가정하자. A라는 개발자가 문자열 상수를 사용하였다면 이를 B라는 개발자는 직접 건네 듣거나, 주석을 달지 않는 이상 알수없다. 즉, 매우 비효율적인 개발 프로세스가 된다는 것이다.

◻️ 요약

고정된 범위의 값을 표현할 때 String타입을 사용할 시,

• 값의 제한 부족로 인한 타입 안정성 약화
• 컴파일 시 오류 감지 불가로인한 디버깅 어려움

이를 해결하기 위해 고정된 범위를 가독성 높게 표현하며 해당 범위의 이외의 값에 대해 강력한 제약을 제공해야한다

타입 안전 열거형 패턴

◻️ ENUM을 사용하지 않고 타입 안전 열거형 패턴 구현해보기

public class ClassGrade {

    public static final ClassGrade BASIC = new ClassGrade(); // x001
    public static final ClassGrade GOLD = new ClassGrade(); // x002
    public static final ClassGrade DIAMOND = new ClassGrade(); // x003

    //private 생성자 추가
    //private 생성자 --> ClassGrade 외부에서 객체를 생성하여 클래스로 접근하는 것을 방지
    private ClassGrade() {}
}

위의 코드는 ENUM과 거의 같은 코드이다. 두 가지 핵심에 대해 살펴보자.

[1]

public static final ClassGrade BASIC = new ClassGrade(); // x001
public static final ClassGrade GOLD = new ClassGrade(); // x002
public static final ClassGrade DIAMOND = new ClassGrade(); // x003

• public을 통해 외부에서 접근이 가능하되, final을 통해 값을 고정시켜 값 변경은 제한
• 클래스내에서 객체를 생성하여 메모리 참조값을 상수화하여 사용

[2]

private ClassGrade() {}

• private 생성자를 통해 클래스 외부에서 객체를 생성하는 것을 방지하여 클래스 내부에서만 객체를 생성하도록 설정
  • 이를 통해 오직 클래스 내부에서 정의한 상수를 통해 고정된 범위를 표현 가능
  • 외부에서 객체를 생성시 컴파일 에러 발생

위에서 만든 타입 안전 열거형 패턴을 기반으로 할인율을 적용하는 로직을 살펴보자.

public class DiscountService {

    public int discount(ClassGrade classGrade, int price) {
        int discountPercent = 0;

        if (classGrade == ClassGrade.BASIC) { // classGrade == x001
            discountPercent = 10;
        } else if (classGrade == ClassGrade.GOLD) {
            discountPercent = 20;
        } else if (classGrade == ClassGrade.DIAMOND) {
            discountPercent = 30;
        } else {
            System.out.println("할인X");
        }
        return price * discountPercent / 100;

    }
}

public class StringGradeEx2_1 {

    public static void main(String[] args) {
        int price = 10000;
        DiscountService discountService = new DiscountService();
        int basic = discountService.discount(ClassGrade.BASIC,price); // == discountService.discount(x001, price)
        int gold = discountService.discount(ClassGrade.GOLD,price);
        int diamond = discountService.discount(ClassGrade.DIAMOND,price);

        // 불가능한 경우 -> 컴파일 에러 발생 
        //int errorcase1 = discountService.discount(2,price);
        //int errorcase2 = discountService.discount(new ClassGrade(),price);
        //int errorcase3 = discountService.discount(ClassGrade.VIP,price);

        System.out.println("BASIC 등급의 할인 금액: " + basic);
        System.out.println("GOLD 등급의 할인 금액: " + gold);
        System.out.println("DIAMOND 등급의 할인 금액: " + diamond);
    }

• DiscountService 의 discount메서드를 보면 매개변수로 ClassGrade타입의 객체를 받아 BASIC,GOLD,DIAMOND와 동일성비교를 통해 할인율을 적용한다. 이때 매개변수인 ClassGrade는 외부에서 객체 생성이 불가능함을 확인하였고 main메서드의 불가능한 경우를 살펴보자
• 불가능한 경우를 살펴보면, ClassGrade에서 사전에 정의한 객체를 제외하고는 전부 매개변수로 사용할 수 없고 이로인해 컴파일 에러가 발생함을 알 수 있다.
• 이를 통해 잘못된 값을 입력하는 근본적인 문제를 해결하고 데이터의 일관성이 보장된다.

◻️ 정리

타입 안전 열거형 패턴(Type-Safe Enum Pattern)의 장점

1. 제한된 인스턴스 생성

   • 클래스는 클래스 내에서 사전에 정의된 인스턴스만 생성하고, 외부에서는 오로지 이 인스턴스들만 사용할 수 있도록하여 미리 정의된 값들만 사용하는 것을 보장

2. 타입 안정성

   • 1의 패턴을 통해 잘못된 값이 입력될 경우 컴파일 에러가 발생하여 사전에 방지 가능
   • ClassGrade의 경우 오로지 BASIC,GOLD,DIAMOND만 사용 가능

단점

1. private 생성자 추가에 유의해야함
2. 코드 작성이 길어짐

이 단점을 보완하고 편리하게 사용할 수 있도록 java에서는 열거형(Enum Type)을 제공한다.

다음 포스팅에서는 열거형(Enum Type)과 열거형 리팩토링에 대해 추가 포스팅을 진행할 예정이다.

우선, 글을 작성하기 전 이 글의 모든 내용은 김영한님의 JAVA 강의를 바탕으로 함을 알립니다.

💡래퍼 클래스

기본형의 한계

객체 지향 언어인 Java가 제공하는 기본형(Primitive Type)은 객체가 아니기에 두 가지의 한계점이 존재한다.

◻️ 객체가 아니다.

• 객체는 상태(필드)와 기능(메서드)를 통해 객체 지향적 프로그래밍을 장점을 살릴 수 있다.

  public class MyIntegerMethodMain0 {
  
    public static void main(String[] args) {
        int value = 10;
        int i1 = compareTo(value,5);
        int i2 = compareTo(value,10);
        int i3 = compareTo(value,20);
        System.out.println("i1 = " + i1);
        System.out.println("i2 = " + i2);
        System.out.println("i3  = " + i3);
  
    }
  
    public static int compareTo(int value, int target) {
        if (value < target) {
            return -1;
        } else if (value > target) {
            return 1;
        } else {
            return 0;
        }
    }
  }

  위의 예제를 보면 compareTo메서드를 통해 value와 다른 정수를 비교하여 비교에 따른 반환값을 반환하여 출력한다. 비교 대상을 보면 value와 다른 정수들이고 value는 계속해서 사용되는 것을 알 수 있다. 만약 value가 기본형이 아닌 참조형이었다면 value객체가 자기 자신과 다른 정수를 비교하는 compareTo메서드를 만드는 것이 객체 지향적이었을 것이다.

  public class MyInteger {
  
    private final int value; // int 타입의 기본형 변수를 하나 갖고 있고 클래스화 했기에 유용한 메서드를 만들어서 사용 가능
  
    public MyInteger(int value) {
        this.value = value;
    }
  
    public int getValue() {
        return value;
    }
  
    public int compareTo(int target) {
        if (value < target) {
            return -1;
        } else if (value > target) {
            return 1;
        } else {
            return 0;
        }
    }
  
    @Override
    public String toString() {
        return String.valueOf(value);
    }
  }

  위의 MyInteger클래스처럼 기본형을 참조형으로 만들었을 경우 메서드를 통해 자기 자신의 값(value)와 다른 정수를 비교할 수 있다. 즉, 객체 입장에서 문제를 해결할 수 있다.

◻️ null 값을 가질 수 없음

• 기본형은 없음의 개념을 표현 할 수 없다. 기본형은 항상 값을 가지기 때문에 없음을 표현할 수 없다. 다음 예제를 살펴보자

  public class MyIntegerNullMain0 {
  
    public static void main(String[] args) {
        int[] intArr = {-1, 0, 1, 2, 3};
        System.out.println(findValue(intArr,-1)); //-1
        System.out.println(findValue(intArr,0)); //0
        System.out.println(findValue(intArr,1)); //1
        System.out.println(findValue(intArr,100)); //-1
    }
  
    private static int findValue(int[] intArr, int target) {
        for (int value : intArr) {
            if (value == target) {
                return value;
            }
        }
        return -1; // int는 기본형으로 무조건 값이 있어야한다.
    }
  }

  위의 예제는 findValue메서드를 통해 intArr에 존재하는 정수와 target정수를 비교해서 동일하면 정수를 반환하고 다르면 -1을 반환하는 예제이다. 근데 여기서 문제점이 발생한다.

  System.out.println(findValue(intArr,-1)); //-1

  이 부분을 보면 target이 -1이고 intArr배열은 -1을 원소로 갖고 있다. findValue메서드에 의해 결과가 -1이 반환되었다면 value가 -1이어서 target과 동일하여 반환된 것인지, value가 -1이 아니어서 target과 다르기에 반환된 것인지 어떻게 알까? 기본형이기에 불가능한 것이다. 참조형을 살펴보자.

  public class MyIntegerNullMain {
  
    public static void main(String[] args) {
        MyInteger[] intArr = {new MyInteger(-1), new MyInteger(0), new MyInteger(1)};
        System.out.println(findValue(intArr, -1));
        System.out.println(findValue(intArr, 0));
        System.out.println(findValue(intArr, 1));
        System.out.println(findValue(intArr, 100));
  
    }
  
    private static MyInteger findValue(MyInteger[] intArr, int target) { // 래퍼 클래스 사용
        for (MyInteger myInteger : intArr) {
            if (myInteger.getValue() == target) {
                return myInteger;
            }
        }
        return null; // 래퍼클래스를 통해 참조형으로 바뀌어 null 사용 가능
    }
  }

  참조형의 경우 Null을 사용할 수 있기에 조건에 부합하지 않는경우 Null을 통해 표현이 가능하다.

래퍼 클래스(Wrapper class)란

기본형은 객체가 아니기에 '자기 자신'입장에서 특정 기능을 제공 할 수 없다는 것과 값이 '없음'을 표현할 수 없다는 단점을 갖는다. Java는 기본형의 단점을 보완할 수 있는 래퍼 클래스를 제공한다.

Wrap을 직역하면 "포장하다","감싸다"로 해석할 수 있다.

래퍼 클래스는 기본형을 객체로 감싸서 객체의 기능을 갖도록 하는 클래스이다. 즉, 기본형의 객체화라고 보면된다.

◻️ 래퍼 클래스 종류

• byte → Byte
• short → Short
• int → Integer
• long → Long
• float → Float
• double → Double
• char → Character
• boolean → Boolean

◻️ 래퍼 클래스 특징

1. 불변 객체이다
2. equals를 통해 동등성 비교를 해야한다

박싱(Boxing)과 언박싱(Unboxing)

• 박싱(boxing) : 물건을 박스에 넣는 행위, 기본형을 래퍼 클래스로 변경하는 것

• 언박싱(Unboxing) : 박스의 물건을 꺼내는 행위, 래퍼 클래스를 다시 기본형으로 꺼내는 것

  public class WrapperClassMain {
  
    public static void main(String[] args) {
        // 박싱(Boxing)
        Integer newInteger = new Integer(10); // 삭제 예정 -> valueOf() 사용 권장
        Integer integerObj = Integer.valueOf(10); 
        Long longObj = Long.valueOf(100);
        Double doubleObj = Double.valueOf(10.5);
  
        System.out.println("newInteger = " + newInteger); // newInteger = 10
        System.out.println("integerObj = " + integerObj); // integerObj = 10
        System.out.println("longObj = " + longObj); // longObj = 100
        System.out.println("doubleObj = " + doubleObj); // doubleObj = 10.5
  
        // 언박싱(Unboxing)
        System.out.println("내부 값 읽기");
        int intValue = integerObj.intValue(); // intValue = 10
        long longValue = longObj.longValue(); // longObj = 100
        System.out.println("intValue = " + intValue); 
        System.out.println("longObj = " + longValue);
  
        System.out.println("비교");
        System.out.println("==: " + (newInteger == integerObj)); // ==: false
        System.out.println("equals: " + newInteger.equals(integerObj)); // equals: true
    }
  }

• valueOf() - 박싱(Boxing)

  • Integer.valueOf(num)는 단순히 num에 해당하는 정수를 박싱하는 기능뿐만아니라 성능 최적화 기능이 있다.
  • -128~128 범위의 Integer 클래스를 미리 생성하고, 해당 범위의 값이 조회되면 미리 생성된 Integer 객체를 반환한다. 마치 문자열 풀과 비슷하게 미리 생성하고 필요시 제공하는 방식이다.

• intValue() - 언박싱(Unboxing)

• 비교는 equals()

  • 래퍼 클래스는 객체이기 때문에 동등성 비교를 통해 비교를 해야한다.

오토 박싱, 오토 언박싱

개발자들에 의해 박싱과 언박싱의 사용 빈도가 늘며 변환 과정에 있어서 더 나은 편의를 제공하기 위해 오토 박싱과 오토 언박싱을 지원한다.

오토박싱과 오토 언박싱은 valueOf(),intValue()와 같은 메서드를 사용하지 않고 박싱과 언박싱을 진행하는 것이다. 예제를 살펴보자

public class AutoboxingMain2 {

    public static void main(String[] args) {
        //Primitive -> Wrapper ,, boxing
        int value = 7;
//        Integer boxedValue = Integer.valueOf(value);
        Integer boxedValue = value; // 오토 박싱(Auto boxing)

        //Wrapper -> Primitive ,, unboxing
//        int unboxedValue = boxedValue.intValue();
        int unboxedValue = boxedValue; // 오토 언박싱(Auto unboxing)

        System.out.println("boxedValue = " + boxedValue);
        System.out.println("unboxedValue = " + unboxedValue;
     }
}

예제를 보면 오토 박싱과 오토 언박싱은 생성된 래퍼 클래스 객체에 일반 '값'을 저장하는 형태로 진행된다.

Integer boxedValue = value; // 오토 박싱(Auto boxing)
int unboxedValue = boxedValue; // 오토 언박싱(Auto unboxing)

오토 박싱과 오토 언박싱은 컴파일러가 대신 valueOf,xxxValue()의 코드를 추가해주는 기능이다.

래퍼 클래스의 주요 메서드

• valueOf() : 래퍼 타입 반환, 숫자, 문자열 모두 지원
• parseInt() : 기본형 타입 반환, 문자열을 기본형으로 변환
• compareTo() : 내 값과 인수로 넘어온 값을 비교. 내 값이 크면 1, 같으면 0, 작으면 -1을 반환
• Integer.sum(),Integer.min(),Integer.max() : static메서드, 간단한 사칙연산 수행

우선, 글을 작성하기 전 이 글의 모든 내용은 김영한님의 JAVA 강의를 바탕으로 함을 알립니다.

💡String

String 클래스 - 기본

◻️ 문자를 다루는 대표적인 타입 : char, String

JAVA에서 문자는 대표적으로 기본형인char와 참조형인String 타입을 사용하여 표현한다. 특징은 다음과 같다.

• char
  • 기본형
  • 문자 '하나'를 다룰 때 사용
  • 여러 문자를 다루기 위해서는 char[]를 사용
• String
  • 참조형 (불변 객체)
  • 문자를 다루는 다양한 기능을 메서드를 통해 제공

◻️ String 클래스 구조

public final class String {
    //문자열 보관
     private final char[] value;// 자바 9 이전
     private final byte[] value;// 자바 9 이후

     //여러 메서드
     public String concat(String str) {...}
     public int length() {...}
     ...
}

String은 참조형이기에 클래스의 고유 속성(필드)와 기능(메서드)를 갖는다. (주요 메서드는 포스팅 후반부에 작성할 예정이다) 따라서, 참조형은 변수에 객체의 메모리 참조값이 저장되기에 +와 같은 사칙연산은 불가능하다. 하지만 String은 가능하다.

public class StringConcatMain {

     public static void main(String[] args) {
         String a = "hello";
         String b = " java";

         String result1 = a.concat(b);
         String result2 = a + b;
         System.out.println("result1 = " + result1);
         System.out.println("result2 = " + result2);
     }
}

String의 경우 원칙적으로는 클래스에서 제공하는 concat()이라는 메서드를 통해 문자열을 더해야하한다. 하지만 result2 = a + b에서 a와 b는 문자열임에도 불구하고 +연산을 통해 hello java라는 결과를 출력한다. 그 이유는 String을 너무 자주 사용하기 때문에 java가 편의상 + 연산을 제공하기 때문이다.

String 클래스 - 비교

String 클래스는 ==가 아닌 항상 equals() 비교를 해야만한다. 동일성(identity)와 동등성(equality)에 대해 복습해보자.

• 동일성(Identity): ==연산자를 사용해서 두 객체의 참조가 동일한 객체를 가리키고 있는지 확인
• 동등성(Equality): equals() 메서드를 사용하여 두 객체가 논리적으로 같은지 확인

그러면 String은 왜 반드시 동등성 비교를 해야만할까? 이를 알아보기 전에 짚고 넘어가야하는 사항이 있다.

◻️ 문자열 리터럴, 문자열 풀

String str1 = new String("hello");
String str2 = "hello";

참조형인 클래스는 다른 참조형과 동일하게 new String(문자열)을 통해 객체를 생성하는게 원칙이나, String str2 = "hello"이 가능하다. 어떻게 가능한걸까?
String은 자주 사용되는 만큼 JAVA에서 제공하는 편의가 많다. 문자열 풀에 대해 알아보자

• JAVA가 실행되는 시점에 클래스에 문자열 리터럴이 존재하면 문자열 풀에 String인스턴스를 미리 생성한다. 같은 문자열인 경우에는 새로 만들지 않는다
• String str2 = "hello";와 같이 문자열 리터럴을 사용하면 문자열 풀에서 미리 생성한 "hello"를 갖고 있는 인스턴스를 찾아 해당 인스턴스의 참조값(x003)을 반환한다.
• 이때 String str3 = "hello";는 str2와 동일하게 "hello" 문자열 리터럴 상수를 사용하기 때문에 동일한 참조값이 변수에 저장되어 str2와 str3는 같은 객체를 참조하게 된다.

위와 같은 원리로 문자열 풀에 의해 문자를 사용하는 경우 메모리를 효율적으로 사용할 수 있다.

문자열 리터럴과 문자열 풀의 개념을 바탕으로 다시 동일성과 동등성에 대한 예제를 살펴보자

public class StringEqualsMain1 {

    public static void main(String[] args) {
        String str1 = new String("hello");
         String str2 = new String("hello");
         System.out.println("new String() == 비교: " + (str1 == str2)); //new String() == 비교: false
         System.out.println("new String() equals 비교: " + (str1.equals(str2))); //new String() equals 비교: true

         String str3 = "hello";
         String str4 = "hello";
         System.out.println("리터럴 == 비교: " + (str3 == str4)); //리터럴 == 비교: true
         System.out.println("리터럴 equals 비교: " + (str3.equals(str4))); //리터럴 equals 비교: true
 }
}

위의 예제에서 문자열 리터럴을 사용한 문자열 활용 부분을 보자.

• str3와 str4는 동일한 문자열 리터럴인 "hello"을 저장하고 있기에 문자열 풀에 의해 동일한 메모리 참조값을 갖게 된다.

• 즉, str3와 str4는 동일한 객체를 가리키고 이는 동일성 비교(identity)가 true임을 의미한다. 또한 두 문자열 모두 "hello"로 논리적으로도 동일하기에 동등성 비교(equality)도 true가 된다.

• str1과 str2는 new를 통해 서로 다른 인스턴스를 생성하였기에 동일성 비교는 false, 동등성 비교는 true가 된다.

정리하자면, String은 new를 통해 인스턴스를 생성하는 정석적인 방법과 문자열 풀을 사용한 방법을 통해 인스턴스를 생성하고 문자열을 저장한다. 이때 문자열 풀을 사용한 방식은 동일성 비교와 동등성 비교를 구분할 수 없기 때문에 new를 통해 인스턴스를 생성하는 방식에 맞추어 동등성 비교를 해야한다는 결론이 나온다.

즉, String은 equals()를 통한 동등성 비교를 진행해야 한다.

String 클래스 - 불변객체

String은 대표적으로 자주 사용되는 불변객체이다. 따라서, String은 내부의 문자열 값 변경이 불가능하다. (불변 객체 복습을 통해 복습하자!)

String 클래스 소스 코드의 일부를 확인해보자.

public final class String {
    //문자열 보관
     private final byte[] value;

     //여러 메서드
     public String concat(String str) {...}
     public int length() {...}
     ...
}

String 클래스의 문자열 보관 부분은 final키워드를 통해 값이 고정된 것을 확인할 수 있다. 그렇다면 String 클래스의 concat() 메서드를 살펴보자

// concat()
public String concat(String str) {
        if (str.isEmpty()) {
            return this;
        }
        return StringConcatHelper.simpleConcat(this, str);
    }

//simpleConcat()
static String simpleConcat(Object first, Object second) {
        String s1 = stringOf(first);
        String s2 = stringOf(second);
        if (s1.isEmpty()) {
            // newly created string required, see JLS 15.18.1
            return new String(s2);
        }
        if (s2.isEmpty()) {
            // newly created string required, see JLS 15.18.1
            return new String(s1);
        }
        // start "mixing" in length and coder or arguments, order is not
        // important
        long indexCoder = mix(initialCoder(), s1);
        indexCoder = mix(indexCoder, s2);
        byte[] buf = newArray(indexCoder);
        // prepend each argument in reverse order, since we prepending
        // from the end of the byte array
        indexCoder = prepend(indexCoder, buf, s2);
        indexCoder = prepend(indexCoder, buf, s1);
        return newString(buf, indexCoder);
    }

concat() 메서드를 보면 String 타입의 문자열을 매개변수로 받고 최종적으로 두 문자열을 연결하는 로직을 거쳐서 반환값으로 new String(문자열)형태로 새로운 String타입의 객체를 생성하여 반환하는 것을 알 수 있다. 이는 대표적인 불변 객체에서 나타나는 특징이다. 불변 객체의 경우 기본적으로 객체 내의 속성과 필드가 고정되어 있기 때문에 메서드를 통해 불가피하게 값을 변경해야하는 로직을 구현해야하는 경우 클래스와 동일 타입의 새로운 객체를 통해 이를 실현한다.

그렇다면 String은 왜 불변으로 설계된 것일까?

◻️ String이 불변으로 설계된 이유

String str3 = "hello";
String str4 = "hello";

Java는 문자열 풀을 제공하여 String을 최적화한다. 문자열 풀에 의해 str3와 str4는 문자열풀에 "hello"를 담고 있는 객체의 동일한 메모리 참조값을 저장한다. 만약 String이 가변 객체라면 str3가 참조하는 문자를 변경하면 str4가 참조하는 문자도 같이 변경되는 사이드 이펙트가 발생한다. 따라서 String은 불변 객체로 설계되었다.

StringBuilder - 가변 String

불변인 String의 단점에 대해 살펴보자. 두 문자를 더하는 경우를 살펴보자

"A" + "B"
String("A") + String("B")
String("A").concat(String("B"))
new String("AB")

String은 불변이기에 내부의 값을 변경할 수 없고, 변경해야하는 사항은 새로운 String 타입으로 반환해주어야한다. 그렇다면 더 많은 문자를 연결해야하는 경우는 어떨까?

String str = "A" + "B" + "C" + "D";
String str = String("A") + String("B") + String("C") + String("D");
String str = new String("AB") + String("C") + String("D"); // 추가1
String str = new String("ABC") + String("D"); // 추가2
String str = new String("ABCD"); // 추가3

문자를 4개를 더하는데 객체만 3개가 만들어진다. 즉, 문자를 자주 더하는 과정은 많은 String 객체를 만들고 많은 GC(Garbage Collect) 과정을 거치게 되고 그 만큼 CPU, 메모리등의 리소스를 많이 사용해야함을 의미한다. 매우 비효율적이다. 이를 해결하기 위해 Java는 가변 String인 StringBuilder를 제공한다.

예제를 보자.

public class StringBuilderMain1 {

    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("A"); // 문자열에 추가
        sb.append("B");
        sb.append("C");
        sb.append("D");
        System.out.println("sb = " + sb);

        sb.insert(4, "Java"); // 4번 인덱스에 문자열을 삽입
        System.out.println("insert = " + sb);

        sb.delete(4,8);
        System.out.println("delete = " + sb);

        sb.reverse();
        System.out.println("reverse = " + sb);

        //StringBuilder -> String
        String string = sb.toString();
        System.out.println("string = " + string);
    }
}

StringBuilder의 경우 하나의 객체 생성을 통해 append,insert,delete,reverse와 같은 제공되는 메서드를 통해 추가적인 객체 생성 없이 문자열 변경이 가능하다. 메모리 효율면에서 상당히 훌륭하지만 사이드 이펙트를 조심해야한다. 따라서, StringBuilder는 보통 문자열을 변경하는 동안 사용하고 toString()을 통해 최종적으로 String타입으로 변경하는 것을 권장한다.

String 최적화

◻️ 문자열 리터럴 최적화

Java는 문자열 리터럴 부분을 직접 더하는 것을 최적화 해준다.

//컴파일 전
String helloWorld = "Hello, " + " World!";
//컴파일 후
String helloWorld = "Hello, World!";

◻️ String 변수 최적화

문자열 변수의 경우 문자열 리터럴과 달리 실행중인 runtime에서 변수에 어떤 문자열이 존재하는 지 알 수 없기에 단순한 +연산으로 문자열을 합칠 수 없다.

String result = str1 + str2;
String reuslt = new StringBuilder().append(str1).append(str2).toString();

따라서, String변수 최적화의 경우 내부적으로는 두 번째와 같이 StringBuilder를 사용하여 최적화를 진행한다.

◻️ String 최적화가 어려운 이유

반복문을 통해 지속적으로 문자열을 더하는 예제를 살펴보자.

public class LoopStringMain {

    public static void main(String[] args) {
         long startTime = System.currentTimeMillis();

         String result = "";
         for (int i = 0; i < 100000; i++) {
             result += "Hello Java ";
         }
         long endTime = System.currentTimeMillis();

         System.out.println("result = " + result);
         System.out.println("time = " + (endTime - startTime) + "ms"); // 2490ms
     }
}

위의 예제를 이해하기 쉽게 StringBuilder를 통해 최적화하는 것을 나타내면 다음과 같다

String result = "";
for (int i = 0; i < 100000; i++) {
    result = new StringBuilder().append(result).append("Hello Java").toString();
}

코드를 보면 String 최적화가 잘 이루어지는 것처럼 보이지만, 반복문에 의해 한 사이클마다 StringBuilder의 객체가 생성되는 것을 알 수 있다. 즉, 연결될 문자열의 개수(100,000)만큼 객체가 생성되고 GC에의해 제거되고를 반복한다. 이 경우는 컴파일러가 최적화의 범위를 정확히 알 수 없고 결국 최적화가 최적화가 아닌 상황이 되버린다. 어떻게 해야할까?

StringBuilder를 직접 사용하자

public class LoopStringMain {

    public static void main(String[] args) {
         long startTime = System.currentTimeMillis();

         StringBuilder sb = new StringBuilder(); // StringBuilder 직접 사용하기 
         for (int i = 0; i < 100000; i++) {
             sb.append("Hello Java");
         }
        String result = sb.toString();
         long endTime = System.currentTimeMillis();

         System.out.println("result = " + result);
         System.out.println("time = " + (endTime - startTime) + "ms"); // 3ms
     }
}

코드처럼 result을 String이 아닌 StringBuilder 타입으로 직접 생성하고 반복문에서 append()메서드를 통해 문자열을 반복문 횟수만큼 추가한다면 하나의 객체만 생성하고 추가가 가능하다.

◻️ 정리

• 문자열을 합칠 때는 대부분 String 최적화가 가능하기에 +연산을 사용한다.

StringBuilder를 직접 사용해야하는 경우

• 반복문에서 문자열 연결을 반복할 때
• 조건문을 통해 문자열을 동적으로 변경할 때
• 복잡한 문자열의 특정 부분을 변경해야할 때
• 대용량 문자열을 다룰 때

메서드 체이닝 - Method Chaining

StringBuilder의 append() 메서드의 소스 코드를 살펴보자.

@Override
@IntrinsicCandidate
public StringBuilder append(String str) {
    super.append(str);
    return this;
}

public AbstractStringBuilder append(String str) {
    if (str == null) {
        return appendNull();
    }
    int len = str.length();
    ensureCapacityInternal(count + len);
    putStringAt(count, str);
    count += len;
    return this;
}

append() 메서드를 살펴보면 최종적으로 this 즉, 자기 자신에 대한 참조값을 반환하는 것을 알 수 있다. 즉, 메서드를 호출할 때마다 append와 관련된 로직을 처리하고 다시 자기 자신에 대한 참조값을 통해 자기 자신을 가리켜 자기 자신 객체의 필드와 멤버에 접근할 수 있다. StringBuilder의 대부분의 메서드는 반환값으로 자기자신을 반환하고 이러한 기능으로 인해 새로운 변수 선언 없이 메서드를 순서대로 호출할 수 있게 되었다. 이는 코드의 가독성을 높히고 메모리 사용도 효율적이다. 이를 메서드 체이닝 기법이라고 한다.

public class StringBuilderMain1_2 {

    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        String string = sb.append("A").append("B").append("C").append("D")
                 .insert(4, "Java")
                 .delete(4, 8)
                 .reverse()
                 .toString();

         System.out.println("string = " + string); // string = DCBA
     }
}

우선, 글을 작성하기 전 이 글의 모든 내용은 김영한님의 JAVA 강의를 바탕으로 함을 알립니다.

💡불변 객체

기본형과 참조형의 공유

자바의 데이터 타입은 크게 기본형(Primitive type)과 참조형(Reference type)으로 나뉜다.

• 기본형

  • 데이터를 직접 변수에 저장하는 타입

  • 고정된 메모리에 할당 됨

  • 하나의 값을 여러 변수에서 공유가 불가능

  • ex. byte, int, float, boolean

    public class PrimitiveMain {
      int a = 10;
      int b = a;
    
      System.out.println("a = " + a); // 10
      System.out.println("b = " + b); // 10, a의 값이 공유된 것이 아닌 복사된 것
    
      b = 20;
       System.out.println("a = " + a); // 10
       System.out.println("b = " + b); // 20

    예시 코드를 보면, 기본형으로 선언된 a,b는 데이터가 직접 저장됨을 알 수 있고 공유가 불가능함을 알 수 있다.

• 참조형

  • 객체(인스턴스)의 주소값(참조값)을 저장하는 타입

  • 실제 데이터는 힙 메모리에 저장되며, 변수는 힙 메모리의 주소값을 참조

  • 변수에 메모리 참조값을 저장하기에 참조값을 여러 변수가 공유하여 힙 메모리에 접근이 가능

  • ex. Class, Interface, Array, Enum, String

    public class Address {
    
      private String value;
    
       public Address(String value) {
           this.value = value;
       }
    
       public void setValue(String value) {
           this.value = value;
       }
    
       public String getValue() {
           return value;
       }
    
       @Override
       public String toString() {
           return "Address{" +
                   "value='" + value + '\'' +
                '}';
       }

    public class RefMain1_1 {
        public static void main(String[] args) {
    
            Address a = new Address("서울"); // 참조값을 x001이라고 가정하자
            Address b = a; 
             System.out.println("a = " + a); // a = Address{value='서울'}
             System.out.println("b = " + b); // b = Address{value='서울'}
    
             b.setValue("부산"); //b의 값을 부산으로 변경해야함
             System.out.println("부산 -> b");
             System.out.println("a = " + a); //사이드 이펙트 발생 , a = Address{value='부산'}
             System.out.println("b = " + b); // b = Address{value='부산'}
         }
     }

    Address 클래스에 대한 객체를 생성하면 힙 메모리 영역에 객체에 대한 정보가 저장되고 참조값(x001)이 a 변수에 저장된다. 이때 Address b = a;부분에서 참조값이 복사되어 b변수에도 저장되고, 이는 a,b가 모두 같은 객체를 참조하고 있으며 같은 객체를 참조하고 있기에 a,b 모두 객체 내의 동일한 멤버를 조작 가능함을 의미한다. 위의 코드에는 치명적인 문제가 존재한다. b.setValue("부산")을 살펴보자. 이 부분은 b를 통해 value의 값을 서울에서 부산으로 바꾸려는 시도이다. b와 a는 동일한 객체를 바라보고 있기에 b의 value만 바뀌는 것이 아닌 a의 value도 같이 바뀌는 문제가 발생하고 이를 사이드 이팩트라고 한다.

공유 참조와 사이드 이팩트

사이드 이펙트(Side Effect)는 직역하면 '부작용'을 의미한다. 프로그래밍에서 사이드 이팩트는 특정 계산이 의도한 작업 이외의 부수 효과를 발생시키는 것을 의미한다. 프로그래밍에서의 사이드 이팩트는 부정적인 의미이다. 사이드 이팩트가 발생하면 프로그램에서의 특정 부분 변경이 의도치 않은 다른 부분에서의 변경까지 초래하기 때문이다. 이로인해 유지보수와 디버깅에 어려움을 갖게된다.

참조형의 예시코드에서 발생한 사이드 이팩트 부분을 도식화하여 다시 살펴보자.

그럼 사이드 이팩트를 어떻게 해결할까?

a와 b가 각각 다른 객체를 가리키게 하면 된다.

Address a = new Address("서울");
Address b = new Address("서울");

Address 클래스에 대한 새로운 객체를 하나 더 생성하여 b가 해당 객체를 참조하도록 한다면 value값을 바꾸어도 a의 상태는 변하지 않는다. 정말 간단히 문제를 해결할 수 있다. 하지만...

좋은 코드는 '제약'을 통해 개발자의 잘못된 부분을 방지할 수 있는 것이 좋은 코드라고 영한님이 말씀해주신다. 즉, a와 b의 변수에 각각 다른 객체의 참조값을 저장하면 간단히 해결되지만 이를 강제할 방법은 없다는 것이다. 만약에 엄청나게 긴 코드를 개발하고 있고 개발자가 실수로 Address b = a;를 작성하여 사이드 이펙트가 발생했다고 가정하자. 제약이 발생하지 않아 예외처리가 불가능하다. 과연 이 부분을 지금처럼 가볍게 해결할 수 있을까? 어떻게 해야할까?

불변객체 도입

불변 객체(Immutable Object)는 객체의 상태(객체 내부의 멤버 변수, 필드, 값)가 변하지 않는 객체를 의미한다. 불변 객체를 만드는 것은 간단하다.

• final 키워드를 통해 내부 값을 고정시킨다.
• setter의 사용을 금지하여 외부에서 객체의 멤버 변수에 접근하지 못하도록 막는다.

위의 내용을 토대로 ImmutableAddress 클래스를 만들면 다음과 같다.

public class ImmutableAddress {
    private final String value; // final을 통해 value 필드를 고정

    public ImmutableAddress(String value) {
        this.value = value;
     }

     public String getValue() {
         return value;
     }

    @Override
     public String toString() {
         return "Address{" +
                 "value='" + value + '\'' +
                 '}';
     }
}

ImmutableAddress의 특징은 오직 생성자를 통해서만 value 필드에 접근하여 값을 저장할 수 있고, 한번 저장된 value는 final 키워드에 의해 변경이 불가능하다는 점이다.

불변객체에서 값을 변경하려면 어떻게 해야할까?

불변 객체를 사용하지만 그래도 값을 변경 해야하는 메서드가 존재한다면 어떻게 해야할까? 기존의 값에 새로운 값을 더하는 add()가 존재하는 클래스를 만들어보자

public class ImmutableObj {

    private final int value;

    public MutableObj(int value) {
        this.value = value
    }

    public int getValue() {
        return value;
    }

    public ImmutableObj add(int addValue) {
        int value = value + addValue;
        return new ImmutableObj(value)
    }
}

ImmutableObj 클래스의 add 메서드를 살펴보자. 메서드의 타입을 ImmutableObj 타입으로 생성하여 기존의 value와 addValue를 더한 값을 매개변수로 하는 새로운 ImmutalbleObj의 객체를 반환한다. 이렇게 메서드를 생성하면 기존의 객체의 변경없이 동일한 타입의 새로운 객체를 반환하여 새로운 결과를 만들 수 있다.

ImmutableObj obj1 = new ImmutableObj(10);
ImmutableObj obj2 = obj1.add(20);

정리

1. 참조형인 객체의 경우 사이드 이펙트가 발생하여 특정 부분의 변경사항이 의도하지 않은 부분의 변경을 발생시킬수 있다.
2. 사이드 이펙트를 방지하기 위해 불변객체를 사용해야한다.
   • final 키워드를 통해 필드를 하나의 값으로 고정시키기
   • setValue(setter)의 사용을 금지하여 외부에서 객체의 필드로의 직접 접근을 막기
3. 불변객체 내에서 변경 가능한 곳이 존재하도록 하려면 해당 불변객체 타입의 메서드를 통해 새로운 객체를 반환해야한다.

불변객체가 중요한 이유가 뭘까

• 자주 사용하는 String, 래퍼 클래스(Integer), LocalDate등 자바가 기본으로 제공하는 수많은 클래스가 불변 객체이기에 불변 객체의 기본 원리를 아는 것이 매우 중요하다.

즉, String, 래퍼 클래스, LocalDate(시간관련 클래스)는 모두 위의 불변 객체와 동일한 형태로 설계가 되어 있음을 알 수 있고 왜 해당 클래스들의 특정 메서드의 반환값을 새로운 동일한 불변 객체 타입으로 저장되어야 하는지 알 수 있을 것이다.

다음은 래퍼 클래스에 대해 알아보자

우선, 글을 작성하기 전 이 글의 모든 내용은 김영한님의 JAVA 강의를 바탕으로 함을 알립니다.

💡Object 클래스

java.lang 패키지

java.lang 패키지는 java가 제공하는 가장 기본이 되는 라이브러리로, java를 이루는 가장 기본적인 클래스들의 모음이라고 보면 된다. java.lang 패키지의 대표적인 클래스는 다음과 같다.

• Object : 모든 java 클래스의 부모 클래스
• String : 문자열 클래스
• Integer, Long, Double : 래퍼 타입 클래스 (기본형 데이터를 객체화한 것)
• Class : 클래스의 메타 정보에 관한 클래스
• System : 시스템과 관련된 기본 기능 제공

Object 클래스

java에서 항상 최상위 클래스는 Object 클래스이다. 즉, extends로 직접 부모 클래스를 언급하지 않았다는 것은 Object 클래스를 상속 받고 있음을 나타낸다.

묵시적 상속 vs 명시적 상속

위에서 언급했듯이, 직접 부모 클래스를 언급하지 않았다는 것은 '묵시적 상속'을 의미한다.

• 묵시적(Implicit) : 개발자가 코드에 직접 기술하지 않아도 시스템 또는 컴파일러에 의해 자동으로 수행됨을 의미
• 명시적(Explicit) : 개발자가 코드에 직접 기술하여 작동하는 것을 의미

Object 클래스의 기능

공통 기능 제공

• 객체의 정보 제공, 객체간의 비교(동일성, 동등성), 객체가 어떤 클래스로 만들어졌는지 확인하는 기능은 모든 객체에게서 공통적으로 필요한 기능
• 위의 기능이 공통 기능이 아닌 사용자 정의 기능이었다면 일관성이 없고 관리도 어려움
• Object가 제공하는 공통 기능
  • toString() : 객체의 정보 제공 메서드
  • equals() : 객체의 같음을 비교하는 메서드 (동등성 비교)
  • getClass() : 객체의 클래스 정보를 제공하는 메서드
  • 이외의 다른 메서드

다형성의 기본 구현

Object는 모든 클래스의 부모 클래스이다. 즉, Object는 다형적 참조에 의해 모든 객체를 참조할 수 있음을 의미한다. 타입이 다른 객체들을 어딘가에 보관해야한다? Object 타입에 보관하면 된다.

Object 다형성

다음 예시를 보자

class Car {
    public void move() {
        System.out.println("자동차 이동");
    }
}

class Dog {
    public void sound() {
        System.out.println("멍멍");
    }
}

public class ObjectPolyExample1 {

    public static void main(String[] args) {
        Dog dog = new Dog();
        Car car = new Car();

        action(dog);
        action(car);
    }

    private static void action(Object obj) {
        // obj.sound(); // 컴파일 오류 , Object는 sound() 없음
        // obj.move(); // 컴파일 오류, Object는 move() 없음

        //객체에 맞는 다운캐스팅 필요
        if (obj instanceof Dog dog) {
            dog.sound();
        } else if (obj instance of Car car) {
            car.move();
        }
     }
}

위의 코드를 통해 Object 클래스의 장단점에 대해 알아보면 다음과 같다.

Ojbect 다형성의 장점

private static void action(Object obj) { ''' }

action 메서드의 매개변수는 Object 타입이다. 즉, Object는 모든 객체의 부모이기에 어떤 객체든지 인자로 전달이 가능함을 나타낸다.

Object 다형성의 한계

action(dog) //main에서 dog 전달
private static void action(Object obj) {
    obj.sound(); //컴파일 오류, Object는 sound()가 없다.
}

action() 메서드 안에서 obj.sound()를 호출하면 당연히 Object 클래스에는 sound()메서드가 없기에 오버라이딩이 불가능하고, sound()를 사용하기 위해서는 다운 캐스팅을 진행해야 한다.

정리하면,

• Object 클래스는 모든 클래스의 부모 클래스이기에 모든 객체를 상대로 다형적 참조가 가능하다
• Object 타입을 통해 전달 받은 객체를 호출 하기위해서는 해당 객체로 다운 캐스팅이 필요하다.

다형적 참조는 OOP의 핵심중 하나로 제대로 활용하기 위해서는 다형적 참조와 메서드 오버라이딩을 함께 사용해야한다. 물론 Object가 제공하는 toString(), equals(), getClass()와 같은 메서드는 오버라이딩이 가능하나 특정 객체가 갖고 있는 고유한 기능은 Object 클래스에 정의되어 있지 않기에 다운 캐스팅이 수반되어야 하고 이는 Object 클래스의 다형성이 한계가 있음을 보여준다. 그렇다면 Object 클래스는 언제 최대로 활용할 수 있을까?

Obejct 배열

Object는 모든 객체를 담을 수 있다. 따라서 Object 타입의 배열은 모든 객체를 담을 수 있는 배열이 된다.

public class ObjectPolyExample2 {
    public static void main(String[] args) {
         Dog dog = new Dog();
         Car car = new Car();
         Object object = new Object(); //Object 인스턴스도 만들 수 있다.

         Object[] objects = {dog, car, object};
         size(objects);
     }

     private static void size(Object[] objects) {
         System.out.println("전달된 객체의 수는: " + objects.length);
     }
}

위의 Object 배열을 메모리 관점에서 보면 다음과 같다.

toString()

Object 클래스의 toString()메서드는 객체의 정보를 제공하는 역할을 한다. 기본적으로 패키지를 포함한 객체 이름과 객체 참조값을 제공한다. 실행 결과 예시는 다음과 같다.

java.lang.Object@a09ee92 // 패키지명+객체이름+객체 참조값

Object 클래스의 toString()은 위와 같은 결과를 제공하는데, 위와 같이 객체의 참조값이 아닌 사용자 정의에 의해 특정 형태로 객체의 정보를 제공하고 싶다면 모두의 부모인 Object를 상속받아 오버라이딩을 진행하여 toString()을 재정의하면 된다.

public class Dog {
    private String dogName;
     private int age;

     public Dog(String dogName, int age) {
         this.dogName = dogName;
         this.age = age;
     }

   @Override
   public String toString() { // toString() 재정의 
      return "Dog{" +
              "dogName='" + dogName + '\'' +
              ", age=" + age +
              '}';
     }
}

기본적으로 toString()은 객체의 메모리 참조값을 제공하는데, 오버라이딩을 통해 재정의할 경우 다른 정보를 출력할 수 있다. 이런 경우 참조값을 따로 출력하고 싶으면 다음과 같이 진행하면 된다.

String refValue = Integer.toHexString(System.identifyHashCode(dog1))
System.out.println("refValue = " + refValue);  // refValue = 72ea2f77

Object와 OCP

public class ObjectPrinter {
    public static void print(Object obj) {
         String string = "객체 정보 출력: " + obj.toString();
         System.out.println(string);
     }
}

OCP(Open-Closed Principle)

OCP는 객체지향 설계 원칙 중 하나로, "클래스는 확장에 열려 있고 변경에는 닫혀 있어야 한다"는 개념을 의미한다.

• Open : 확장에 열려 있다
  • 새로운 기능이나 요구사항이 추가될 때, 기존 코드를 변경하지 않고도 확장이 가능해야 한다
• Closed : 수정에 닫혀 있다
  • 기존 코드는 안정적이어야 하며, 변경하지 않아도 새로운 요구사항을 반영할 수 있도록 설계되어야 한다.

Object와 OCP

• Open : 새로운 클래스를 추가하고, toString()을 오버라이딩하여 기능 확장이 가능하다
• Closed : 새로운 클래스를 계속해서 추가해도 Object와 toString()을 사용하는 클라이언트 코드인 ObjectPrinter은 변경없이 사용 가능

equals() - 동일성과 동등성

java는 두 객체의 '같음'을 2가지로 표현한다.

1. 동일성(Identity) : ==연산자를 통해 두 객체가 동일한 메모리를 가리키고 있는지 확인
2. 동등성(Equality) : equals() 메서드를 사용하여 두 객체가 논리적으로 동등한지 확인

User a = new User("id-100") //참조 x001
User b = new User("id-100") //참조 x002

위의 예시의 경우 물리적으로 다른 객체에 존재하지만 논리적으로 동일한 회원 번호를 갖고 있기에 같은 회원으로 볼 수 있다. 따라서 동일성은 false이지만 동등성은 true인 것이다.

예제를 통해 동일성과 동등성에 대해 알아보자

public class UserV1 {

    private String id;
    //constructor
    public UserV1(String id) {
        this.id = id;
     }
}

public class EqualsMainV1 {

    public static void main(String[] args) {
        UserV1 user1 = new UserV1("id-100");
         UserV1 user2 = new UserV1("id-100");

         System.out.println("identity = " + (user1 == user2));  //false
         System.out.println("equality = " + user1.equals(user2)); //false
     }
}

id값이 id-100으로 동일한 user1과 user2의 identity(동일성)과 equality(동등성)을 확인한 것으로, 위에서 언급한 동일성과 동등성 개념에 의하면 true, false가 출력되어야 한다. 하지만 equality(동등성)는 id값이 동일함에도 불구하고 false가 나왔다. 어떻게 된것일까?

Object.equals()의 소스 코드를 살펴보자.

public boolean equals(Object obj) {
    return (this == obj);
}

소스코드에 의하면, equals는 this==obj 즉, 동일성을 기반으로 작성되어 있음을 확인할 수 있다. 따라서, 서로 다른 객체인 user1과 user2의 참조값은 다르기에 equals()를 사용한 비교도 false가 출력될 수 밖에 없다.

그렇다면 동등성 비교는 어떻게 해야하는 걸까?

동등성(equality) 비교를 논리적으로 생각해보면 동등성 비교는 비교 순간마다 비교의 기준이 달라질 수 있음을 알아야한다. 즉, 동등함의 기준이 id일수도 있고 주민번호일수도 있으며 연락처일수도 있는 것이다. 따라서, 동등성 비교를 해야한다면 Object.equals()를 오버라이딩을 통한 재정의를 해야한다.

equals()의 경우 intellij에서 제공하는 Alt+Insert를 통해 제공하는 equals()를 보편적으로 사용한다.

public class UserV2 {
    private String id;

     public UserV2(String id) {
         this.id = id;
     }

    //equals() 재정의 
     @Override
     public boolean equals(Object obj) {
         UserV2 user = (UserV2) obj;
         return id.equals(user.id);
     }
}

인터페이스란?

이전 포스팅에서 '추상 클래스'에 대해 알아보았고, 순수 추상 클래스는 클래스를 이루는 모든 메서드가 추상 메서드인 추상 클래스를 의미한다. 인터페이스는 순수 추상 클래스를 더 편리하게 사용가능한 기능이다.

순수 추상 클래스

// 순수 추상 클래스
public abstract class AbstractAnimal {
    public abstract void sound();
    public abstract void move();
}

• 인스턴스 생성 불가능
• 상속시 모든 메서드를 overriding 해야한다
• 주로 다형성을 위해 사용

인터페이스

인터페이스는 abstract가 아닌 interface 키워드를 사용하면 된다. 또한, 인터페이스는 public abstract 키워드의 생략이 가능하고 권장된다.

public interface InterfaceAnimal {
    void sound();
    void move();
}

• 인터페이스는 순수 추상 클래스와 같다
• 메서드는 모두 추상 메서드인데, public abstract 키워는 생략 가능하고, 권장된다
• 인터페이스는 다중 상속(구현)이 가능하다

인터페이스와 멤버변수

public interface InterfaceAnimal {
    // public static final double MY_PI = 3.14;
    double MY_PI = 3.14;
}

인터페이스에서 멤버변수는 '상수'이다. 또한 인터페이스의 상수는 메서드와 동일하게 public static final이 생략이 가능하고 권장된다.

예제

public interface InterfaceAnimal {
    void sound();
    void move();
}

public class Dog implements InterfaceAnimal {
    @Override
    public void sound() {
        System.out.println("멍멍");
    }

    @Override
    public void move() {
        System.out.println("개 이동");
    }
}

public class Cat implements InterfaceAnimal {
    @Override
    public void sound() {
        System.out.println("냐옹");
    }

    @Override
    public void move() {
        System.out.println("고양이 이동");
    }
}

public class Cow implements InterfaceAnimal {
    @Override
    public void sound() {
        System.out.println("음메");
    }

    @Override
    public void move() {
        System.out.println("소 이동");
    }
}
// -----------------------------Main Method----------------------------------

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

        // 인터페이스 생성 불가
        // InterfaceAnimal interfaceMain1 = new InterfaceAnimal();

        Cat cat = new Cat();
        Dog dog = new Dog();
        Caw caw = new Caw();

        soundAnimal(cat);
        soundAnimal(dog);
        soundAnimal(caw);

    }

    private static void soundAnimal(InterfaceAnimal animal) {
        System.out.println("동물 소리 테스트 시작");
        animal.sound();
        System.out.println("동물 소리 테스트 종료");
    }
}

위의 예제를 보면 인터페이스와 순수 추상 클래스의 차이점이 거의 없음을 알수있다. 실제로 메모리 구조상 클래스, 추상 클래스, 인터페이스의 차이는 없다.

인터페이스, 왜 사용할까?

형태만 보면 인터페이스는 abstract키워드만 사용하지 않을 뿐 순수 추상 클래스와 동일한 기능을 한다. 그렇다면 왜 순수 추상 클래스를 사용하지 않고 인터페이스를 사용해야할까?

• 제약

  • 인터페이스는 '반드시 구현해야한다'라는 제약사항이 있다. 즉, 인터페이스안의 메서드는 반드시 순수 추상 메서드 형태이어야하고 자식 클래스는 반드시 해당 메서드를 오버라이딩 해야한다. _순수 추상 클래스와의 차이점은 순수 추상 클래스는 미래 특정 시점에 순수 추상 메서드가 아닌 일반 메서드를 추가하여 일반 추상 클래스로의 전환 가능성이 있다는 점_이다. 인터페이스를 사용하여 이런 점을 원천 방지가 가능하다

• 다중구현

  • java에서 클래스 상속은 하나의 부모에게서만 가능하다. 하지만 인터페이스의 경우 자식 입장에서 여러 인터페이스로부터 상속이 가능하다.

상속 vs 구현

부모 클래스의 기능을 자식 클래스가 상속 받을 때, 클래스 상속이라고 표현한다. 하지만 부모 인터페이스의 내용을 자식 클래스가 상속 받을 때는 클래스 '구현'이라고 표현한다. 인터페이스는 모든 메서드가 순수 추상 메서드 즉, 본문이 전혀 없는 메서드이다. 따라서 부모 인터페이스로부터 물려받을 기능은 존재하지 않고 오히려 자식 클래스에서 이를 오버라이딩하여 기능을 '구현'해야한다. 따라서 인터페이스를 '구현'한다고 표현한다.

인터페이스의 다중 구현

다이아몬드 문제

만약 위의 그림과 같이 AirplaneCar클래스가 Airplane, Car 두 개의 부모 클래스로 부터 다중 상속을 받는다고 가정하자. 두 개의 부모 클래스에는 모두 move() 메서드가 존재하고 이를 자식 클래스에서 사용하려고 한다면 어떤 부모의 메서드를 사용해야할까? 이를 다이아몬드 문제라고 하고, 이러한 이유로 다중 상속은 허용되지 않는다. 하지만 인터페이스의 다중 구현을 통해 이러한 문제를 피하고 구현 가능하다.

InterfaceA, InterfaceB는 모두 methodCommon()을 갖는다. 자식 클래스인 Child 입장에서는 두 인터페이스를 구현해야하는데, 상속의 경우 두 부모 클래스의 methodCommon()중 어떤 메서드를 사용할 것인가의 다이아몬드 문제가 발생한다. 하지만 인터페이스의 메서드는 기능을 가지지 않기에 해당 인터페이스를 구현하는 자식 클래스에서 해당 기능을 구현해야한다. 즉, InterfaceA, InterfaceB는 모두 methodCommon()을 제공하지만 최종구현은 Child에서 구현되어야 하며, 오버라이딩에 의해 호출도 Child의 methodCommon()이 우선 호출되기에 다이아몬드 문제가 발생하지 않는다.

추상 클래스란?

추상 클래스는 부모 클래스는 제공하지만 실제로 객체를 생성할 수 없는 클래스를 의미한다. 추상적인 개념을 제공하는 의미로 객체 생성이 불가능하다.

public abstract class AbstractAnimal {}

• abstract 키워드를 통해 추상 클래스임을 표시할 수 있다.
• 추상 클래스는 기존 클래스와 같지만, new AbstractAnimal(); 와 같이 객체를 직접 생성할 수 없다는 제약이 추가된다.

추상 메서드

부모 클래스를 상속 받는 자식 클래스에서 반드시 오버라이딩 해야하는 메서드를 부모 클래스에 정의할 수 있고, 이를 추상 메서드라고 한다.

public abstract void sound();

• 추상 메서드는 추상 클래스와 동일하게, 생성시 abstract 키워드를 붙이면 된다.
• 부모 클래스의 메서드중 하나라도 추상 메서드인 경우 해당 부모는 반드시 추상 클래스이어야 한다.
• 추상 메서드는 _자식 클래스가 반드시 오버라이딩 해야하는 대상_으로 본문(body)가 존재하지 않는 메서드이다.

예시를 살펴보자. 부모 클래스 AbstractAnimal과 자식클래스들을 구현해보자.

public abstract class AbstractAnimal {

    public abstract void sound();  

    public void move() {
        System.out.println("동물이 움직입니다.");
    }
}

public class Dog extends AbstractAnimal {
    @Override
    public  void sound() {
        System.out.println("멍멍");
    }
}

public class Cat extends AbstractAnimal {
    @Override
    public  void sound() {
        System.out.println("냐옹");
    }
}

public class Cow extends AbstractAnimal {
    @Override
    public  void sound() {
        System.out.println("음메");
    }
}
// -----------------------main method---------------------------------
public class AbstractMain {
    public static void main(String[] args) {
     //추상클래스 생성 불가
     //AbstractAnimal animal = new AbstractAnimal();

     Dog dog = new Dog();
    Cat cat = new Cat();
     Caw caw = new Caw();

     cat.sound();
     cat.move();

     soundAnimal(cat);
     soundAnimal(dog);
     soundAnimal(caw);
 }

 //동물이 추가 되어도 변하지 않는 코드
 private static void soundAnimal(AbstractAnimal animal) {
     System.out.println("동물 소리 테스트 시작");
     animal.sound();
     System.out.println("동물 소리 테스트 종료");
 }

}

위의 코드에서 컴파일 에러가 발생할 수 있는 경우를 정리해보자.

1. 추상 클래스의 인스턴스를 직접 생성할 경우

   AbstractAnimal animal = new AbstractAnimal();
   

//java: poly.ex3.AbstractAnimal is abstract; cannot be instantiated

2. 추상 메서드를 오버라이딩하지 않은 경우 
```java
public class Dog extends AbstractAnimal {

/*
     @Override
     public void sound() {
         System.out.println("멍멍");
     }
*/

}

// java: poly.ex3.Dog is not abstract and does not override abstract method sound()in poly.ex3.AbstractAnimal

즉, 결론적으로 추상 클래스는 일반 클래스에 '제약'이 추가된 클래스라고 볼 수 있다. 이를 제외하고는 모든 것이 동일하다. 해당 제약으로 인해 실수로 클래스 객체를 직접 생성하거나 sound()를 오버라이딩 하지 않는 문제를 근본적으로 해결이 가능하다고 볼 수 있다.

순수 추상 클래스

위의 AbstractAnimal 추상 클래스를 살펴보면, 추상 메서드인 sound()와 일반 메서드인 move()로 이루어져 있음을 알 수 있다. 순수 추상 클래스란 모든 메서드가 추상 메서드인 추상 클래스를 의미한다.

public abstract class AbstractAnimal {
    public abstract void sound();
    public abstract void move();
}

순수 추상 클래스의 특징

• 인스턴스를 생성 할 수 없다.
• 상속시 자식은 모든 메서드를 오버라이딩 해야 한다
• 주로 다형성을 위해 사용된다

순수 추상 클래스는 특별한 로직은 없고 다형성을 위한 껍데기 역할을 한다. 순수 추상 클래스의 모든 메서드는 자식 클래스가 반드시 오버라이딩을 진행해야 하는데 이는 특정 규격을 맞춰 구현하는 과정처럼 느껴진다.

다음 포스팅에서는 순수 추상 클래스를 더 편리하게 사용하기 위한 '인터페이스'에 대해 포스팅 할 예정이다.

우선, 글을 작성하기 전 이 글의 모든 내용은 김영한님의 JAVA 강의를 바탕으로 함을 알립니다.

💡다형성의 활용

앞선 포스팅 다형성1에서는 다형성의 의미와 핵심기능을 살펴보았다. 이번 포스팅에서는 다형성의 목적과 활용에 대해서 포스팅한다.

다형성의 핵심기능 두 가지 다시 짚고 넘어가보자.

1. 다형적 참조 , "부모는 자식을 품을 수 있으나 자식은 부모를 품지 못한다"
2. 메서드 오버라이딩 , "자식 클래스에서 부모 클래스의 매서드를 재정의하여 사용할 수 있으며 해당 메서드는 가장 높은 우선순위를 갖는다"

다형성의 필요성을 설명하기 위해 다형성을 사용하지 않은 코드와 다형성을 사용한 코드를 비교해보자.

public class Dog {
    public void sound(){
        System.out.println("멍멍!");
    }
}

public class Cat {
    public void sound(){
        System.out.println("냐옹~");
    }
}

public class Cow {
    public void sound(){
        System.out.println("음메~~~");
    }
}

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

        Dog dog = new Dog();
        Cat cat = new Cat();
        Caw caw = new Caw();

        System.out.println("동물 소리 테스트 시작");
        dog.sound();
        System.out.println("동물 소리 테스트 종료");

        System.out.println("동물 소리 테스트 시작");
        cat.sound();
        System.out.println("동물 소리 테스트 종료");

        System.out.println("동물 소리 테스트 시작");
        caw.sound();
        System.out.println("동물 소리 테스트 종료");
    }
}

위의 코드는 개,고양이,소의 울음소리를 출력문으로 구현하기 위해 Dog,Cat,Cow 클래스를 구현한 것이다. main메서드를 보면 클래스에 대한 객체를 생성하고 해당 클래스에 대한 sound 메서드를 순차적으로 호출하여 각 동물에 대한 울음소리를 구현한다.

근데 더 많은 종류의 동물들이 추가되면 어떻게 될까...?

• 해당 동물에 대한 클래스를 형성해야한다
• 해당 동물들에 대한 객체를 생성해야한다
• main 메서드에 동물 클래스가 추가될 때마다 출력문도 추가해야한다

즉, 새로운 클래스가 추가될 때마다 중복 코드가 계속해서 늘어난다. 중복 코드를 없애기 위해 두 가지 방법을 사용해보자.

1. 메서드 생성

   private static void soundCaw(Cow cow) {
   
   System.out.println("동물 소리 테스트 시작");
   caw.sound();
   System.out.println("동물 소리 테스트 종료");
   

}

2. for문과 배열 사용
```java
Caw[] cawArr = {cat, dog, caw}; //컴파일 오류 발생!

System.out.println("동물 소리 테스트 시작");

for (Caw caw : cawArr) {
    cawArr.sound();
    }

첫 번째, 메서드를 생성하는 것은 해당 메서드만 호출하면 출력문과 sound()메서드를 호출하는 부분의 중복을 제거 할 수 있다. 하지만 매개변수로 특정 클래스 타입을 받아야 하기에 해당 메서드도 클래스의 개수 만큼 호출해야한다는 단점이 존재한다.

두 번째, for문과 배열을 사용한 부분은 배열을 생성하는 부분에서 배열의 타입에 의해 컴파일 에러가 발생한다.

두 방법 모두 선언 '타입'에 의해 단점이 존재하고 에러가 발생함을 알 수 있다. 이를 해결하기위해 '공통'의 타입이 필요하다. Animal 부모클래스를 만들고 Dog, Cat, Cow 클래스를 상속을 통해 자식 클래스화 해보면 다음과 같다.

public class Animal {
    public void sound() {
        System.out.println("동물 울음 소리");
    }
}

public class Dog extends Animal    {
    @Override
    public void sound(){
        System.out.println("멍멍!");
    }
}

public class Cat extends Animal    {
    @Override
    public void sound(){
        System.out.println("냐옹~");
    }
}

public class Cow extends Animal    {
    @Override
    public void sound(){
        System.out.println("음메~~~");
    }
}

public class AnimalPolyMain3 {
    public static void main(String[] args) {
        Animal[] animalArr = {new Dog(), new Cat(), new Caw()};
        for (Animal animal : animalArr) {
            soundAnimal(animal);
        }
    }

    //동물이 추가 되어도 변하지 않는 코드
    private static void soundAnimal(Animal animal) {
        System.out.println("동물 소리 테스트 시작");
        animal.sound();
        System.out.println("동물 소리 테스트 종료");
    }

위 코드의 핵심은 다음과 같다

Animal[] animalArr = {new Dog(), new Cat(), new Caw()};
for (Animal animal : animalArr) {
    soundAnimal(animal);
}

• 다형적 참조에 의해 Animal 타입의 변수에 자식 클래스 객체 저장
• 배열과 for each문을 사용하여 코드 간결화
• soundAnimal() 메서드를 for each문을 통해 반복 호출하여 출력문과 오버라이딩 된 메서드를 호출하여 Dog, Cat, Cow의 고유 기능을 사용 즉, 하나의 동물을 받아서 로직을 처리

장점

위 처럼 다형성을 고려한 코드는 새로운 '동물'을 추가하여도 soundAnimal() 메서드는 변경이 필요없다. 이 부분이 가능한 이유는 동물 마다 (Dog, Cat, Cow) 참조하는 것이 아니라 Animal이라는 부모 클래스만 참조하기 때문에 가능한 것이다.

단점

위 코드는 다형성을 고려한 유지보수가 용이한 코드이다. 하지만 위 코드에는 두 가지의 문제점이 존재한다.

*1. 부모 클래스 Animal 클래스의 인스턴스를 생성할 문제 *

기존의 코드의 문제점은 각 동물 객체를 추가할 때마다 메인 로직을 변경해야 한다는 점이고 이를 해결하기 위해 상속을 도입하여 다형적 참조를 진행하였다. 하지만, Animal 부모 클래스는 오직 다형적 참조을 위해 생성 된 것이지 직접 인스턴스를 생성하여 사용 할 이유도 없고 혼란을 야기한다.

  Animal animal = new Animal();

*2. Animal 클래스를 상속 받는 곳에서 sound() 메서드 오버라이딩을 하지 않을 가능성 *

Pig라는 새로운 자식 클래스를 추가했다고 가정하자. 근데 개발자가 실수로 오버라이딩 해야하는 메서드를 오버라이딩 하지 않았다면 어떻게 될까? 만약 부모 클래스의 특정 메서드를 오버라이딩하지 않는다면 자식 클래스가 아닌 부모 클래스의 메서드 기능이 호출과 동시에 실행 되어 목적에 맞지 않는 기능을 구현하게 된다. 하지만 진짜 문제점이 이 부분이다. 오류가 발생하지 않는다는 것이다. 당장 Pig 클래스만 보면 큰 문제가 없다고 생각할수도 있으나 코드가 더 복잡해지고 길어진다면 유지보수 측면에서 틀린부분을 고치는 것은 어려울 것이다. 제약을 걸어 줄 수 없을까?

다음 포스팅에서는 다형성의 단점 부분을 보완하는 개념인 추상 클래스와 인터페이스에 대해 포스팅 해보겠다. 끝!

우선, 글을 작성하기 전 이 글의 모든 내용은 김영한님의 JAVA 강의를 바탕으로 함을 알립니다.

💡 다형성(Polymorphism)이란?

다형성(Polymorphism)은 객체지향 프로그래밍(Object Oriented Programming)의 대표적인 특징 중 하나로 '다양한 형태'를 의미한다. 프로그래밍에서 다형성은 _'한 객체가 여러 타입의 객체로 취급되는 것'_을 의미한다.

다형성은 객체 지향 프로그래밍의 상속과 인터페이스를 기반으로 한다.

💡 다형성의 2가지 핵심이론

다형적 참조

java에서 클래스를 생성하면 클래스의 속성(필드, 메서드)에 접근하기 위해 객체(인스턴스)를 생성해야한다. 객체가 생성되면 힙메모리 영역에 해당 객체의 클래스에 대한 내용이 저장되고, 이때 상속관계가 있다면 부모 클래스와 자식 클래스 모두 하나의 메모리 영역에 저장된다. 우리가 살펴보아할 경우는 '상속'관계가 존재하는 객체이다.

일반적으로, 객체를 생성하면 해당 객체가 생성된 힙메모리영역의 참조값을 해당 클래스 형태의 변수에 저장한다.

Parent parent = new Parent(); 
Child child = new Child();

예를들어, new Parent();를 통해 객체를 통해 생성된 메모리의 참조값을 x001이라고 가정하면 다음과 같다고 볼 수 있다.

Parent parent = x001;

하지만 java는 다형적 참조에의해 상속관계에 놓인 Parent와 Child 사이에서 부모클래스인 Parent는 Parent와 자식 클래스 Child 모두를 참조할 수 있다. 이 개념이 '다형적 참조'이다.

Parent poly = new Child();

즉, 다형적 참조의 핵심은 "부모는 자식을 품을 수 있다"라는 것이다. 이는 '캐스팅'의 개념과 연결된다.

캐스팅

위에서 언급했듯이, 상속관계가 존재하는 클래스에 대해 객체를 생성하면 메모리 영역에 부모클래스와 자식클래스에 대한 속성이 메모리 영역에 저장된다. 그렇다면 정확히 어떤 클래스를 우선 참조할까? 정답은 ,, 타입에 의존한다는 것이다.

Child child = new Child(); // Child 타입 변수 --> Child 클래스를 우선 참조
Parent poly = new Child(); // 다형적 참조 --> Parent 클래스를 우선 참조 

다형적 참조의 경우 부모 타입의 변수에 참조값이 저장되었기에 우선적으로 메모리의 부모 클래스에 대한 속성을 참조하게 되고 직접적으로는 부모 클래스에 대한 속성만 사용이 가능하다. 즉, 다형적 참조에서 객체를 통한 직접적인 자식 클래스에 대한 속성을 사용하는 것은 컴파일 에러를 야기한다.

이럴때 자식 클래스의 속성을 사용하고 싶다면,, 어떻게 해야할까? '다운 캐스팅'

다운 캐스팅과 업 캐스팅

다운 캐스팅은 말 그대로 부모 -> 자식으로 캐스팅 하는 것이고, 업 캐스팅은 자식 -> 부모로 캐스팅하는 것이다. 일시적 다운 캐스팅은 자식 클래스의 메소드를 호출할 때만 일시적으로 다운 캐스팅 되는 경우를 의미한다.

// 다운 캐스팅
Parent poly = new Child();
Child child = (Child) poly; 

// 일시적 다운 캐스팅
Parent poly = new Child();
((Child)poly).childMethod() 

// 업 캐스팅
Child child = new Child();
Parent parent1 = (Parent) child;
Parent parent2 = child;        //  parent2 처럼 업캐스팅은 생략을 권장한다. 

다운 캐스팅의 주의점

부모는 자식을 품을 수 있다. 단, 서로 부모-자식 관계가 성립이 되어야 가능하다. 이게 무슨 말일까? 상속관계의 클래스는 객체 생성시 메모리에 부모, 자식 속성이 모두 저장된다고 했다. 이렇게 상속관계에 의해 메모리에 부모와 자식이 모두 존재할 때 비로소 다운 캐스팅이 가능하다.

다운캐스팅이 불가능한 경우는 다음과 같다.

Parent parent = new Parent();
Child child = (Child) parent;

상속관계가 없는 경우에는 메모리상에 부모와 자식이 공존하지 않기에 다운 캐스팅이 불가능하다.

메서드 오버라이딩

다형성의 두 번째 핵심이론은 '메서드 오버라이딩'이다. 메서드 오버라이딩이 뭘까? Override, "덮어쓰기"라는 의미이다. 직역하면 메서드 오버라이딩은 메서드를 덮어쓰는 것을 의미한다. 즉, 메서드 오버라이딩이란 상속관계가 존재하는 부모클래스의 특정 메서드를 자식 클래스에서 재정의하여 사용하는 것을 의미한다.

public class Parent {

    public String value = "Parent";

    public void method() {
        System.out.println("Parent.method");
    }
}

public class Child extends Parent {

    public String value = "child";

    @Override
    public void method() {
        System.out.println("Child.method");
    }
}

위의 예제를 보면 Child에서 Parent의 method()를 재정의한 것을 볼 수 있다. 이를 그림으로 도식화하면 다음과 같다.

그러면 여기서 한 가지 의문점이 발생한다. 그냥 굳이 오버라이딩을 하지않고 자식 클래스에 동일한 이름의 메서드를 만들고 해당 메서드의 고유 기능을 정의하면 되는 것 아닐까??

이 부분에서 메서드 오버라이디의 두 가지 특징을 살펴본다.

메서드 오버라이딩의 특징

1. 부모클래스의 메서드를 재정의한다.
2. 오버라이딩 된 메서드는 항상 우선권을 가진다.

메서드 오버라이딩의 특징과 다형적 참조를 연결지어보면 다음과 같다.

Parent poly = new Child();
poly.method(); 

위의 코드를 도식화하면 다음과 같다.

• 다형적 참조에 의해, 우선 메모리상의 부모클래스를 참조한다
• 메서드 오버라이딩에 의해 우선순위가 높은 자식 클래스의 method()가 호출된다.

즉, 메서드 오버라이딩에 의해 부모 클래스의 고유 기능은 유지하며 여러 자식 클래스에 특화된 동작이 가능해진 것이다. 이는 객체지향 프로그래밍에서 코드의 유지보수를 용이하게 하는 방법 중 하나이다.

우아한테크코스에 지원하다

올해 2월 자대 공학계열을 졸업하였다. 군대를 전역하고 나는 어떤 길을 걸어가야할까?라는 스스로에게 던진 질문에 대답하기위해 많은 생각을 하였고, 전공자 친구와 함께 처음으로 프로그래밍을 접하였다. 지금 생각해보면 지나간 시간이지만 이 시기가 가장 아쉬웠다.. 프로그래밍을 처음으로 접했고 언어를 배우며 나름 배움에 만족하던 나였기에 더 나아가 프로그래밍을 배워서 '어떤'일을 하는 프로그래머가 되고 싶은지에 대한 생각이 짧았다고 생각한다. 그 후 공부를 심화하기위해 자대의 연구실에 학부연구생으로 들어가게 되었고 약 2년간 연구실 생활과 전공,부전공 수업등을 통해 프로그래밍, 펌웨어, AI등을 접하게 되었다. 정확히 연구실 1년차까지는 나름 연구실 생활에 만족하였고, 전공에 대해서도 거리감이 없었기에 무난히 연구실에서 석사과정을 밟으리라 생각했다. 하지만 3학년 2학기 부전공 수업 AI 프로그래밍과 겨울방학때 연구실내 AI 세미나를 통해 AI를 접하게 되며 진로에 대한 전환점이 생기게 된다. AI와 데이터를 공부하며 데이터 엔지니어링에 관심을 갖게 되었고, 데이터 엔지니어링을 접하니 자연스레 백엔드 개발에도 관심이 가게되었다. 졸업작품을 만들고 학회에 논문을 투고하는 것을 끝으로 연구실을 나왔다. 그리고 졸업을 하였다. 연구실 생활과 펌웨어에 대해서 불만은 없다. 펌웨어 프로그래밍도 나름? 재밌고 목표 직무로 삼을 수 있다고 생각했지만 프로그래머로써 진정 '내가 하고 싶은 분야'가 생기고 말았다.

졸업 후 데이터 엔지니어링 국비지원을 알게되었고 국비지원에 대한 안좋은 시선을 구글에서 많이 보았지만 학원측과 면담 후 '내가 가고싶은 길'이기에 일단 앞으로 나아가 보기로 했다. 6개월이라는 기간동안... 힘들었다. 배움이 힘든것이 아니라 솔직히 국비지원에 대한 소문(?)은 어느정도 맞았다... 안좋은 얘기를 장황하게 할 필요는 없다고 생각하니... 국비지원을 생각한다면 반드시 '강사님의 이력'이 있는 근거가 있는 곳으로 가길 바란다. 뭐가됐든 이수를 하였고, 과정 전부 너무 중요한 내용들이었으나 가장 중요하다고 생각한 백엔드에 대해서 딥하게 학습하지 못하였고 백엔드 엔지니어링에 대한 나만의 갈증이 증폭되었다. 현재 김영한님의 훌륭한! 강의를 들으며 자바를 처음부터 열심히(?) 공부하고 있는 와중에 ,, 우테코 모집을 보게되었다...!

맞다, 우아한테크코스,, 훌륭한 커리큘럼과 유튜브로 가끔 보던 훌륭하신 분들의 테코톡을 보며 대단하다, 멋지다, 나도 해보고 싶다라는 생각이 들던 그 우아한테크코스다. 맞다, 들어가기 힘들다. 이번에 설명회를 유튜브를 통해 보았는데 작년 경쟁률이 거의 40:1? 이었던 것으로 기억한다. 괜찮다. 우아한테크코스를 위해 이력서를 작성하는 과정, 프리코스의 과정 모두 나의 성장에 이바지 할것이다.

프리코스의 목표는 다음과 같다.

1. java가 처음이지만 리팩토링을 통해 클린 코드를 작성해볼 것
   2. 디자인 패턴을 학습하고 디자인 패턴을 적용해서 코딩해볼 것
   3. 프리코스 커뮤니티 활동을 활발히 해볼 것

프리코스에 대하여

프리코스 첫 번째 미션은 문자열 덧셈 계산기이다. 자세한 설명은 하이퍼링크로 대체하겠다. 처음부터 막막했다. 요구사항에 맞게 기능을 분기하는 것도 어려웠지만 이를 올바른 패키지명으로 디렉토리 트리를 구성하는 것이 상당히 어려웠다. 이 부분이 안되면 프로그래밍 시작이 안되었기에 결국,, 서칭과 생성형 AI 교수님?의 도움을 조금 받아 디렉토리 트리를 정하였다.(다음부터는 이러지 않겠..) 그리고 초반에 막혔던 부분이 intellij 개발환경설정이었다. 우테코에서 제시한 요구사항에 테스트 build에 대한 내용이 있는데 지속적으로 오류가 발생하였고 원인불명이었다. 이 부분은 따로 포스팅할 예정이나 간단히 말하면 intellij의 경우 java 파일 디렉토리에 '한글'을 최대한 배제하는 것이 좋다. 윈도우를 사용하는 나는 자연스레 '바탕화면'을 상위 디렉토리로 하는 디렉토리내에 java파일을 위치하였더니 build가 안되었고 이를 수정하였더니 바로 정상적으로 빌드가 되는것을 확인할 수 있었다. 이번 프리코스에서 커뮤니티의 존재를 늦게 알게되어 뒤늦게 합류하였으나 짧은 기간이어도 많은 유익한 점을 알게되었다. 먼저 프리코스 미션과 관련하여 '정규식'표현에 대해 알게되었고 java에서 제공하는 정규식 처리 클래인 Pattern와 Matcher에 대해 알게되어 학습할 수 있어 좋았다.(이 부분도 따로 포스팅 할 예정이다) 커뮤니티에서 다른 지원자분께서 정규식 표현을 정리한 문서를 공유해주셔서 많은 도움이 되었고, 이것이 커뮤니티의 순기능이구나라는 깨달음을 얻게 되었다. 프리코스 미션 이외에도 커뮤니티를 통해 훌륭한 개발 서적에 대해 알게되었고 다양한 개발론에 대해서 토의와 토론을 하시는 분들을 보고 조금의 경외감이 들기도 하였다. 나도 할 수 있다. 이제 4주간의 프리코스가 남았는데 위에서 작성한 프리코스 목표를 이행하여 한층 더 성장한 사람이 되도록 하겠다. 끝!

sqoop은 일반적으로 사용하는 RDBMS(MySQL, Oracle)와 HDFS(Hive, HBase)간 데이터를 전송하기 위해 사용하는 툴이다.

HDFS 저장소를 기준으로 import(RDBMS -> HDFS), export(HDFS -> RDBMS) 기능을 제공하며, MapReduce방식으로 동작한다.

Sqoop download

환경변수 및 환경설정

1. 경로 설정

• gedit ~/.bashrc
• source ~/.bashrc

2. sqoop 환경설정

• cp sqoop/conf/sqoop-env-template.sh sqoop-env.sh를 통해 환경설정파일 카피
  • gedit sqoop/conf/sqoop-env.sh

MySQL DB 설정

1. MySQL 설치

mysql 설치 후 필요한 설정 및 진행 단계를 다음 명령어를 통해 진행

dnf install mysql-server systemctl start mysqld.service systemctl enable mysqld systemctl status mysqld mysql_secure_installation

• mysql user 생성

  CREATE USER ''@'localhost' IDENTIFIED BY >''; GRANT ALL PRIVILEGES ON . TO ''@'localhost'; FLUSH PRIVILEGES; systemctl restart mysqld

2. MySQL 접속

• Mysql 접속

  mysql -u root -p

# 접속 예시 

[sshuser@m-001-example-1fx8-hd ~]$ mysql -u example -p
Enter password:
Welcome to the MySQL monitor.  Commands end with ; or ㅓ\g.
Your MySQL connection id is 37
Server version: 5.6.35-log MySQL Community Server (GPL)
Copyright (c) 2000, 2018, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its affiliates. Other names may be trademarks of their respective owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql>

3. MySQL 데이터 스키마 생성 및 확인

create database hadoopguide;

GRANT ALL PRIVILEGES ON hadoopguide.* TO 'username'@'localhost' IDENTIFIED BY 'password'; # 권한 부여 : 로컬 사용자가 해당 db를 보고 수정할 수 있도록 권한 부여

3. sqoop 설정 정리

   Sqoop 1.4.7 환경 설정 후 ,

   1. commons-lang-2.6.jar 다운(기존에 있던 commons-lang은 전부 지우거나 파일 다른곳으로 이동)

   2. CREATE USER 계정명입력@localhost identified by '비밀번호';

   3. GRANT ALL PRIVILEGES ON 데베명입력.* TO 계정명입력@localhost;

   4. flush privileges;

   5. SHOW GRANTS FOR 계정명@localhost;

Sqoop 활용

1. 커넥터 설치 및 압축해제 (connector/J)

Sqoop은 관계형 데이터베이스 시스템과 Hadoop의 상호 작용을 용이하게 하기 위해 설계되었는데, 이 때 다양한 데이터베이스 시스템과의 연결은 Sqoop connector를 통해 이루어짐

wget https://downloads.mysql.com/archives/get/p/3/file/mysql-connector-java-5.1.46.tar.gz

tar xvfz mysql-connector-java-5.1.46.tar.gz

error : _java.lang.NoClassDefFoundError: org/apache/commons/lang/StringUtils _ 해당 오류는 commons-lang 파일이 있어야 해결된다.

2. commons-lang 파일 다운로드

apache-lang-download

wget https://dlcdn.apache.org//commons/lang/binaries/commons-lang3-3.14.0-bin.tar.gz

3. Sqoop import

Sqoop 명령어 import를 사용하여 특정 데이터베이스, 특정 테이블, 쿼리 수행 결과 등 가져올 수 있다.

# Sqoop import 

sqoop import --connect jdbc:mysql://[마스터 노드 Private IP]:3306/[데이터베이스이름] --username [클러스터 관리자 계정명] --password [클러스터 관리자 패스워드] --table [대상테이블]

ex1.
  sqoop import \
  --connect jdbc:mysql://localhost/hadoopguide \
  --table test2 \
  --target-dir /user/root/test2 \
  --username hadoopguide \
  --P \
  -m 1

ex2.
  #스쿱으로 가져온 데이터의 순서가 틀어지면 임의로 query문을 추가하여 정렬해서 가져온다
  #이때 주의할 점은 , where $CONDITIONS를 반드시 작성해야 error가 발생하지 않는다는 점이다. 해당절을 작성하지 않고 order by를 작성하면 오류가 발생한다. 

  sqoop import 
  --connect jdbc:mysql://localhost/hadoopguide \
  --target-dir widget \
  --username hadoopguide \
  --P  \
  --query "select * from widget where \$CONDITIONS order by id" \
  -m 1

실습>

Warning: /root/sqoop/../hbase does not exist! HBase imports will fail.
Please set $HBASE_HOME to the root of your HBase installation.
Warning: /root/sqoop/../hcatalog does not exist! HCatalog jobs will fail.
Please set $HCAT_HOME to the root of your HCatalog installation.
Warning: /root/sqoop/../accumulo does not exist! Accumulo imports will fail.
Please set $ACCUMULO_HOME to the root of your Accumulo installation.
Warning: /root/sqoop/../zookeeper does not exist! Accumulo imports will fail.
Please set $ZOOKEEPER_HOME to the root of your Zookeeper installation.
2024-03-12 14:04:32,758 INFO sqoop.Sqoop: Running Sqoop version: 1.4.7
Enter password: 
2024-03-12 14:04:36,680 INFO manager.MySQLManager: Preparing to use a MySQL streaming resultset.
2024-03-12 14:04:36,684 INFO tool.CodeGenTool: Beginning code generation
Tue Mar 12 14:04:37 KST 2024 WARN: Establishing SSL connection without server's identity verification is not recommended. According to MySQL 5.5.45+, 5.6.26+ and 5.7.6+ requirements SSL connection must be established by default if explicit option isn't set. For compliance with existing applications not using SSL the verifyServerCertificate property is set to 'false'. You need either to explicitly disable SSL by setting useSSL=false, or set useSSL=true and provide truststore for server certificate verification.
2024-03-12 14:04:38,549 INFO manager.SqlManager: Executing SQL statement: select * from widget where  (1 = 0)  order by id
2024-03-12 14:04:38,567 INFO manager.SqlManager: Executing SQL statement: select * from widget where  (1 = 0)  order by id
2024-03-12 14:04:38,635 INFO manager.SqlManager: Executing SQL statement: select * from widget where  (1 = 0)  order by id
2024-03-12 14:04:38,677 INFO orm.CompilationManager: HADOOP_MAPRED_HOME is /root/hadoop-3.3.6
Note: /tmp/sqoop-root/compile/a1649ef2c28b7580e54d7c867471195d/QueryResult.java uses or overrides a deprecated API.
Note: Recompile with -Xlint:deprecation for details.
2024-03-12 14:04:44,725 INFO orm.CompilationManager: Writing jar file: /tmp/sqoop-root/compile/a1649ef2c28b7580e54d7c867471195d/QueryResult.jar
2024-03-12 14:04:44,801 INFO mapreduce.ImportJobBase: Beginning query import.
2024-03-12 14:04:44,802 INFO Configuration.deprecation: mapred.job.tracker is deprecated. Instead, use mapreduce.jobtracker.address
2024-03-12 14:04:45,328 INFO Configuration.deprecation: mapred.jar is deprecated. Instead, use mapreduce.job.jar
Tue Mar 12 14:04:45 KST 2024 WARN: Caught while disconnecting...

EXCEPTION STACK TRACE:



** BEGIN NESTED EXCEPTION ** 

javax.net.ssl.SSLException
MESSAGE: closing inbound before receiving peer's close_notify

STACKTRACE:

javax.net.ssl.SSLException: closing inbound before receiving peer's close_notify
    at sun.security.ssl.SSLSocketImpl.shutdownInput(SSLSocketImpl.java:740)
    at sun.security.ssl.SSLSocketImpl.shutdownInput(SSLSocketImpl.java:719)
    at com.mysql.jdbc.MysqlIO.quit(MysqlIO.java:2249)
    at com.mysql.jdbc.ConnectionImpl.realClose(ConnectionImpl.java:4221)
    at com.mysql.jdbc.ConnectionImpl.close(ConnectionImpl.java:1464)
    at org.apache.sqoop.manager.GenericJdbcManager.discardConnection(GenericJdbcManager.java:78)
    at org.apache.sqoop.manager.GenericJdbcManager.close(GenericJdbcManager.java:88)
    at org.apache.sqoop.mapreduce.DataDrivenImportJob.configureInputFormat(DataDrivenImportJob.java:335)
    at org.apache.sqoop.mapreduce.ImportJobBase.runImport(ImportJobBase.java:262)
    at org.apache.sqoop.manager.SqlManager.importQuery(SqlManager.java:748)
    at org.apache.sqoop.tool.ImportTool.importTable(ImportTool.java:522)
    at org.apache.sqoop.tool.ImportTool.run(ImportTool.java:628)
    at org.apache.sqoop.Sqoop.run(Sqoop.java:147)
    at org.apache.hadoop.util.ToolRunner.run(ToolRunner.java:82)
    at org.apache.sqoop.Sqoop.runSqoop(Sqoop.java:183)
    at org.apache.sqoop.Sqoop.runTool(Sqoop.java:234)
    at org.apache.sqoop.Sqoop.runTool(Sqoop.java:243)
    at org.apache.sqoop.Sqoop.main(Sqoop.java:252)


** END NESTED EXCEPTION **


2024-03-12 14:04:47,676 INFO Configuration.deprecation: mapred.map.tasks is deprecated. Instead, use mapreduce.job.maps
2024-03-12 14:04:48,032 INFO client.DefaultNoHARMFailoverProxyProvider: Connecting to ResourceManager at /0.0.0.0:8032
2024-03-12 14:04:51,141 INFO mapreduce.JobResourceUploader: Disabling Erasure Coding for path: /tmp/hadoop-yarn/staging/root/.staging/job_1710213620221_0002
Tue Mar 12 14:04:57 KST 2024 WARN: Establishing SSL connection without server's identity verification is not recommended. According to MySQL 5.5.45+, 5.6.26+ and 5.7.6+ requirements SSL connection must be established by default if explicit option isn't set. For compliance with existing applications not using SSL the verifyServerCertificate property is set to 'false'. You need either to explicitly disable SSL by setting useSSL=false, or set useSSL=true and provide truststore for server certificate verification.
2024-03-12 14:04:58,150 INFO db.DBInputFormat: Using read commited transaction isolation
2024-03-12 14:04:58,815 INFO mapreduce.JobSubmitter: number of splits:1
2024-03-12 14:04:59,609 INFO mapreduce.JobSubmitter: Submitting tokens for job: job_1710213620221_0002
2024-03-12 14:04:59,609 INFO mapreduce.JobSubmitter: Executing with tokens: []
2024-03-12 14:05:00,579 INFO conf.Configuration: resource-types.xml not found
2024-03-12 14:05:00,581 INFO resource.ResourceUtils: Unable to find 'resource-types.xml'.
2024-03-12 14:05:01,366 INFO impl.YarnClientImpl: Submitted application application_1710213620221_0002
2024-03-12 14:05:01,491 INFO mapreduce.Job: The url to track the job: http://localhost:8088/proxy/application_1710213620221_0002/
2024-03-12 14:05:01,493 INFO mapreduce.Job: Running job: job_1710213620221_0002
2024-03-12 14:05:27,705 INFO mapreduce.Job: Job job_1710213620221_0002 running in uber mode : false
2024-03-12 14:05:27,724 INFO mapreduce.Job:  map 0% reduce 0%
2024-03-12 14:05:45,264 INFO mapreduce.Job:  map 100% reduce 0%
2024-03-12 14:05:46,355 INFO mapreduce.Job: Job job_1710213620221_0002 completed successfully
2024-03-12 14:05:46,910 INFO mapreduce.Job: Counters: 33
    File System Counters
        FILE: Number of bytes read=0
        FILE: Number of bytes written=283653
        FILE: Number of read operations=0
        FILE: Number of large read operations=0
        FILE: Number of write operations=0
        HDFS: Number of bytes read=87
        HDFS: Number of bytes written=130
        HDFS: Number of read operations=6
        HDFS: Number of large read operations=0
        HDFS: Number of write operations=2
        HDFS: Number of bytes read erasure-coded=0
    Job Counters 
        Launched map tasks=1
        Other local map tasks=1
        Total time spent by all maps in occupied slots (ms)=14246
        Total time spent by all reduces in occupied slots (ms)=0
        Total time spent by all map tasks (ms)=14246
        Total vcore-milliseconds taken by all map tasks=14246
        Total megabyte-milliseconds taken by all map tasks=14587904
    Map-Reduce Framework
        Map input records=3
        Map output records=3
        Input split bytes=87
        Spilled Records=0
        Failed Shuffles=0
        Merged Map outputs=0
        GC time elapsed (ms)=340
        CPU time spent (ms)=2970
        Physical memory (bytes) snapshot=141488128
        Virtual memory (bytes) snapshot=2946174976
        Total committed heap usage (bytes)=28442624
        Peak Map Physical memory (bytes)=141488128
        Peak Map Virtual memory (bytes)=2946174976
    File Input Format Counters 
        Bytes Read=0
    File Output Format Counters 
        Bytes Written=130
2024-03-12 14:05:46,954 INFO mapreduce.ImportJobBase: Transferred 130 bytes in 59.1995 seconds (2.196 bytes/sec)
2024-03-12 14:05:46,978 INFO mapreduce.ImportJobBase: Retrieved 3 records.

4. Sqoop export

Sqoop export는 Hadoop 파일 시스템에 저장된 데이터를 외부 데이터베이스나 데이터 웨어하우스로 내보내는 작업을 수행하는 Sqoop 명령어

Sqoop import : 외부 DB의 데이터를 Hadoop 내부로 갖고오기 Sqoop export : Hadoop 내부의 데이터를 외부 DB로 내보내기

위 그림은 mysql로 형성한 test 테이블이며 테이블 내용은 사진과 같다. 해당 테이블은 Sqoop import를 통해 /user/root/test/으로 import를 한 상태이다. Hadoop 경로로 들어간 해당 테이블의 내용과 export를 사용하여 다시 mysql의 빈 테이블인 tbl_test 테이블로 갖고오는 작업을 진행하였다.

• export 기본 구조

  # mysql -u hadoopguide -p를 통해 mysql 접속후 빈 테이블을 하나 형성한다. 이 과정은 설명 생략한다
  # Hadoop 내부에 저장되어 있는 /user/root/test/part-m-0000 파일을 MySQL DB로 내보내기
  
  

sqoop export --connect jdbc:mysql://localhost/hadoopguide --table tbl_target --export-dir /user/root/test/part-m-00000 --username hadoopguide --password password

mysql을 확인해보면 hadoop 내부의 /user/root/test 에 있는 part-m-0000의 내용이 tbl_target에 들어간 것을 알 수 있다. 
![](https://velog.velcdn.com/images/usnijee_2/post/1004e5b8-480b-41cb-b967-068e4b9fde6d/image.png)