서브쿼리란?

• 하나의 SQL문 안에 포함되어 있는 또 다른 SQL문!
• 반드시 괄호로 묶어야 한다! EX) SELECT 안에 SELECT 문, INSERT, UPDATE, DELETE 안의 SELECT문

서브쿼리 사용 가능한 곳

1. SELECT절
2. FROM절
3. WHERE절
4. HAVING절
5. ORDER BY절
6. 기타 DML (INSERT, DELETE, UPDATE)절

다만 GROUP BY절에는 서브쿼리를 사용할 수 없다.

서브 쿼리 종류

_1. 동작하는 방식에 따라 _

1) UN-CORRELATED(비연관) 서브쿼리

• 서브쿼리가 메인쿼리 컬럼을 가지고 있지 않은 형태의 서브쿼리
• 메인쿼리에 서브쿼리가 실행된 결과 값을 제공하기 위한 목적으로 사용

2) CORRELATED(연관) 서브쿼리

• 서브쿼리가 메인쿼리 컬럼을 가지고 있는 형태의 서브 쿼리
• 일반적으로 메인쿼리가 먼저 수행된 후에 서브쿼리에서 조건이 맞는지 확인하고자 할 때 사용

2. 위치에 따라

1) 스칼라 서브쿼리 (Scalar Subquery)

• SELECT절에 사용하는 서브쿼리
• 서브쿼리 결과를 마치 하나의 컬럼처럼 사용하기 위해 주로 사용
• 단일값을 반환 (값을 계산), 즉 각 행마다 스칼라 서브쿼리 결과가 하나여야 한다. (단일행 서브쿼리 형태)

  SELECT 
    emp_name,
    salary,
    (SELECT AVG(salary) FROM employees) AS avg_salary,
    (SELECT dept_name FROM departments d WHERE d.dept_id = e.dept_id) AS dept_name
  FROM employees e;

2) 인라인 뷰 (Inline View)

• FROM절에 사용하는 서브쿼리
• 서브쿼리 결과를 테이블처럼 사용하기 위해 주로 사용 (임시 테이블처럼 사용)
• 데이터 가공 역할
• 테이블명이 존재하지 않기 때문에 다른 테이블과 조인 시 반드시 테이블 별칭 명시 (단독으로 사용하는 경우 불필요)
• WHERE절 서브쿼리와 다르게 서브쿼리 결과를 메인 쿼리의 어느 절에서도 사용할 수 있다.
• 인라인뷰의 결과와 메인쿼리 테이블과 조인할 목적으로 주로 사용
• 모든 연산자 사용 가능

SELECT 
    dept_summary.dept_id,
    dept_summary.avg_salary,
    d.dept_name
FROM (
    SELECT 
        dept_id,
        AVG(salary) as avg_salary,
        COUNT(*) as emp_count
    FROM employees 
    GROUP BY dept_id
) dept_summary
JOIN departments d ON dept_summary.dept_id = d.dept_id
WHERE dept_summary.avg_salary > 5000;

3) WHERE절 서브쿼리

• 가장 일반적인 서브쿼리
• 비교 상수 자리에 값을 전달하기 위한 목적으로 주로 사용(상수항의 대체)
• 리턴 데이터의 형태에 따라 단일행 서브쿼리, 다중행 서브쿼리, 다중컬럼 서브쿼리, 상호연관 서브쿼리로 구분
• 필터링 조건으로 사용 (조건 설정)

WHERE절 서브쿼리 종류

1) 단일행 서브쿼리 (Single Row Subquery)

• *서브쿼리 결과가 1개의 행이 리턴되는 형태 *
• 단일행 서브쿼리 연산자 종류
• =, >, <, >=, <=, <> (같지 않다) ```SQL
• • 평균 급여보다 높은 급여를 받는 직원 SELECT emp_name, salary FROM employees WHERE salary > (SELECT AVG(salary) FROM employees);

-- 최고 급여를 받는 직원 SELECT emp_name, salary FROM employees WHERE salary = (SELECT MAX(salary) FROM employees);

### 2) 다중행 서브쿼리 (Multiple Row Subquery)
- **서브쿼리 결과가 여러 행이 리턴되는 형태 (여러 개의 행 반환)**
- `IN`, `ANY`, `ALL`, `EXISTS` 연산자
- 다중행 서브쿼리 연산자 

| 연산자 | 의미 |
| --- | --- |
|   IN  | 같은 값을 찾음 |
| > ANY | 최솟값을 반환 |
| < ANY | 최댓값을 반환 |
| < ALL | 최솟값을 반환 |
| > ALL | 최댓값을 반환 |

- 예시
> ALL(2000, 3000) : 최대값(3000)보다 큰 행들 반환
< ALL(2000, 3000) : 최소값(2000)보다 작은 행들 반환
> ANY(2000, 3000) : 최소값(2000)보다 큰 행들 반환
< ANY(2000, 3000) : 최대값(3000)보다 작은 행들 반환


```sql
-- IN 사용: 서울에 있는 부서의 직원들
SELECT emp_name, dept_id
FROM employees
WHERE dept_id IN (
    SELECT dept_id 
    FROM departments 
    WHERE location = '서울'
);

-- ANY 사용: 어떤 부서의 평균급여보다라도 높은 급여를 받는 직원
SELECT emp_name, salary
FROM employees
WHERE salary > ANY (
    SELECT AVG(salary) 
    FROM employees 
    GROUP BY dept_id
);

-- ALL 사용: 모든 부서의 평균급여보다 높은 급여를 받는 직원
SELECT emp_name, salary
FROM employees
WHERE salary > ALL (
    SELECT AVG(salary) 
    FROM employees 
    GROUP BY dept_id
);

3) 다중컬럼 서브쿼리 (Multiple Column Subquery)

• 여러 개의 컬럼을 반환하여 동시에 비교
• 메인쿼리와의 비교 컬럼이 2개 이상
• 대소 비교 전달 불가 (두 값을 동시에 묶어 비교 x) ```sql
• • 각 부서별 최고급여와 최소급여를 동시에 받는 직원 SELECT emp_name, dept_id, salary FROM employees WHERE (dept_id, salary) IN ( SELECT dept_id, MAX(salary) FROM employees GROUP BY dept_id UNION SELECT dept_id, MIN(salary) FROM employees GROUP BY dept_id );

-- 특정 부서의 특정 직급과 일치하는 직원 SELECT emp_name, dept_id, job_title FROM employees WHERE (dept_id, job_title) = ( SELECT dept_id, job_title FROM employees WHERE emp_name = '김철수' );

### 4) 상호연관 서브쿼리 (Correlated Subquery)
- **메인쿼리와 서브쿼리의 비교를 수행하는 형태**
- 비교할 집단이나 조건은 서브쿼리에 명시 (메인쿼리절에는 서브쿼리 컬럼이 정의되지 않았기 때문에 에러 발생)
- 외부쿼리의 컬럼을 참조하는 서브쿼리. 외부 쿼리의 각 행마다 서브쿼리가 실행된다.
```sql
-- 같은 부서 내에서 평균급여보다 높은 급여를 받는 직원
SELECT emp_name, dept_id, salary
FROM employees e1
WHERE salary > (
    SELECT AVG(salary)
    FROM employees e2
    WHERE e2.dept_id = e1.dept_id  -- 외부 쿼리 참조
);

-- EXISTS 사용: 부하직원이 있는 매니저
SELECT emp_name, emp_id
FROM employees manager
WHERE EXISTS (
    SELECT 1
    FROM employees subordinate
    WHERE subordinate.manager_id = manager.emp_id  -- 외부 쿼리 참조
);

-- NOT EXISTS 사용: 부하직원이 없는 직원
SELECT emp_name, emp_id
FROM employees e1
WHERE NOT EXISTS (
    SELECT 1
    FROM employees e2
    WHERE e2.manager_id = e1.emp_id
);

• 대소 비교할 컬럼을 메인쿼리에, 일치 조건을 서브쿼리에 전달

  SELECT EMPNO, ENAME, SAL, DEPTNO
  FROM EMP E1
  WHERE SALARY > (SELECT AVG(SALARY)
                FROM EMP E2
                WHERE E1.DEPTNO = E2.DEPTNO
                GROUP BY DEPTNO);

서브쿼리 주의사항

• 특별한 경우 (TOP-N 분석 등)을 제외하고는 서브 쿼리절에 ORDER BY절을 사용할 수 없다.
• 단일 행 서브쿼리와 다중 행 서브쿼리에 따라 연산자의 선택이 중요하다.

  SELECT *
  FROM EMP
  WHERE SAL IN (SELECT SALARY
              FROM EMP
              WHERE DEPTNUM = 20
              ORDER BY SALARY);

  위와 같이 작성하면 에러가 발생한다.

HashMap의 경우 단점이 하나 있다. 그 단점은 put을 통해 데이터나 객체를 넣을 때 key의 순서가 지켜지지 않는다는 것이다. 코드상으로 순차적으로 key, value를 넣어도, 실제 HashMap에서는 해당 순서가 지켜지지 않는다.

HashMap<String, String> = new HashMap<>();

map.put("강아지", "참새");
map.put("고양이", "토끼");
map.put("호랑이", "사자");

이렇게 key와 value를 해시맵에 넣는다고 가정하면, 다음과 같이 저장된다는 것이다

그래서 입력된 key의 순서가 보장되어야 한다면 LinkedHashMap 을 사용하면 된다.

LinkedHashMap 은 put을 통해 입력된 순서대로 key가 보장되므로 해당 문제를 해결할 수 있다. 사용법은 다음과 같다.

LinkedHashMap<String, String> = new LinkedHashMap<>();

map.put("강아지", "참새");
map.put("고양이", "토끼");
map.put("호랑이", "사자");

그러면 HashMap이랑 비교했을 때 LinkedHashMap이 어떤 특성을 가지고 있는지 알아보자.

공통점

• 데이터를 key-value 쌍으로 저장한다.
• 비동기로 처리된다.

Key

• 중복을 허용하지 않는다.
• 하나의 null값을 저장할 수 있다.

Value

• 중복을 허용한다.
• 여러 개의 null값을 저장할 수 있다.

차이점

HashMap

• 데이터의 삽입 순서를 보장하지 않는다.
• AbstractMap 클래스를 상속하고, Map 인터페이스를 구현한다.

LinkedHashMap

• 데이터의 삽입 순서를 보장한다.
• HashMap 클래스를 상속하고, Map 인터페이스를 구현한다.

성능

Create

• HashMap < LinkedHashMap (오래 걸림)

Iterate

• (오래 걸림) HashMap > LinkedHashMap

Access

• (오래 걸림) HashMap > LinkedHashMap

결론

• HashMap보다 LinkedHashMap의 성능이 약간 더 우세하지만, 전체적인 성능에는 큰 차이가 없다.
• HashMap은 순서를 보장하지 않아도 될 때, LinkedHashMap은 순서를 보장해야 될 떄 사용한다.

참고

https://fruitdev.tistory.com/141 https://docs.oracle.com/javase/8/docs/api/java/util/LinkedHashMap.html https://da-nyee.github.io/posts/java-hashmap-vs-likedhashmap/

그러면 나는 지난 6개월동안 뭘 했나?

*1. 백준 (물)골드 1 달성 * 교육 수료하고 그동안 미뤄왔던 예비군에 다녀오고, 다른 기업 필기 시험 보느라 코테를 대충 공부하고 이후 4월 30일부터 본격적으로 코테를 파기 시작했다. 5개월 남짓한 기간동안 대략 230여 문제 좀 푼 것 같다. 매일 꾸준히 1문제씩 풀고 있고, 현재 4달 넘게 지속 중이다.

*2. 프로그래머스 400여 문제 해결 *프로그래머스도 백준과 같이 병행해 풀었다. 코딩 입문, 기초, SQL 고득점 kit만 다 풀어도 300문제가 넘어서, 양치기를 정말 많이 하긴 했다.

*3. 토익 취득 *2년 전에 취득했던 오픽의 성적이 만료되서 토익을 취득했다. 사실 토익을 취득한 이유는 일부 금공 같은 경우는 토익만 받는 곳이 있어서 딴건데 나름 잘 한 것 같다. 2주 정도 준비해서 급하게 따긴 했지만, 뭐 기준 점수는 넘겼다.

*4. 오픽 재취득 *오픽은 본격적인 취준 전에 3번 정도 응시했었다. 3번 다 모두 IH가 나와서 나름 공부 안한거치고는 잘 나왔기에 나 정도면 영어 잘한다고 생각했었다. 하지만, 그동안 영어 말하기 공부를 안하기도 했고, 외운 티가 좀 났는지 다시 응시한 2번의 시험 모두 IM2가 나왔다. 솔직히 돈도 좀 많이 날리고, 실망스럽긴 하지만 뭐 시간 날 때 취미로 다시 연습해야겠다.

*5. 프로젝트 리팩토링 *부트캠프 때 했던 프로젝트 중에 약간 구현의 아쉬움이 있던 프로젝트를 가지고 혼자 성능개선이랑 부하테스트를 진행했었다. 비동기 처리도 해보고, 인덱싱 처리, Redis 캐싱 처리를 해서 약 11배 정도 성능 개선을 할 수 있었다. JMeter로 부하테스트를 실시하니 100명은 거뜬하게 쓸 수 있는 시스템을 구축한 것 같다. 물론, 더 많은 유저가 들어올 수 있도록 성능개선을 해야 되지만, 처음 해보는 성능개선이라 미숙한 점이 많았다.

6. 운동 & 러닝 작년 1월 친구한테 배운 헬스를 1주일에 4번 정도 꾸준히 하고 있다. 작년에 비하면 몸이 확실히 좋아지긴 했고, 한 개도 못했던 턱걸이를 이제는 컨디션 좋으면 7-8개까지 당길 수 있는 수준으로 올라왔다. 살크업하던 시기 6분대가 나왔던 달리기도 이제는 5분 후반대가 나오기 시작했다. 원래는 마라톤에 나갈려고 가끔 뛰었지만 날씨도 좋은데 꼭 마라톤에 나가보고 싶다!

그러면 하반기동안 나는 뭘 해야 할까?

당연히 취업이다! 솔직히 나는 전공자임에도 학교 다니는 기간에 "방황"이라는 이유로 전공 공부를 등한시했다. 사실, 모든 공부는 다 힘들고 누구나 다 힘들다. 그럼에도 불구하고 누구는 성공하고, 누구는 실패한다. 요즘 솔직히 개발자 취업 시장이 정말 쉽지는 않다. 대기업에 재직 중인 친한 형도 2-3년 전까지는 이 정도는 아니었다고 한다. 솔직히 하반기 열리면서 불안해서 잠도 못 잔적 있도 있고, 자신감도 취준 처음 할 당시에 비하면 많이 떨어져있는 상태이다. 나이는 먹고 그러니 당연히 그럴만하다. 매일 별에별 생각이 다 들어서 공부 방해 될때가 많다. 그래서 몇 가지 목표를 세울려고 한다.

미친 듯이 운동하기

몸이 건강해야 정신도 건강하다. 운동을 꾸준히 하긴 했지만, 익숙해져서 관습적으로 운동한 것 같다. 운동 시간을 조금 더 늘리거나 무게를 늘리는 등 미친 듯이 운동해서 정신을 맑게 해야겠다.

코딩테스트 복습

사실 코딩테스트 문제 푸는거에만 초점을 맞춰서 복습을 제대로 안했다. 그러니 다시 풀었던 개념 또 보고 하느라 시간이 배로 들고 있다는 것을 느꼈다. 그래서 1,2주 전부터 문제 푼 후에 다시 풀어보고 하루 뒤에 1주일 뒤에 이런 식으로 반복적으로 풀어보고 있다. 효과는 괜찮은 것 같다.

코딩테스트 유형 디깅

몇 번의 코딩테스트를 본 결과, 요새 코테 트렌드가 바뀐 것 같다. 과거에는 BFS/DFS, 구현, DP 등의 문제가 많이 나왔다면, 요새는 다들 잘해서 그런지 이분탐색 / DP 심화 / 다익스트라 쪽으로 꽤 나오는 것 같다. 특히, 이분탐색이랑 골드 1-2 수준의 DP가 꽤 자주 나왔다. SQL 출제하는 기업 같은 경우도 몇몇 문제는 프로그래머스 고득점 Kit로 대비할 수 없는 수준이었다. 그래서 일단은 매일 꾸준히 구현 1문제와 다른 유형의 문제들(이분탐색, 투포인터, DP, 다익스트라, 유니온 파인드 등) 2-3문제씩 매일 풀고 복습할려고 한다. 코딩테스트 제발 합격하자!

포트폴리오 정리

사실 내가 여태껏 진행한 프로젝트가 기술의 깊이가 얕다고 판단해 새로운 개인 프로젝트를 팔까 5월부터 고민했었다. 하지만, 계속 미루다보니 아직 아무것도 한게 없다. 코테만 하다보니 백엔드 API 짜는 방법도 가물가물해서 사이드 프로젝트를 심심풀이로 하나 만들려고 한다. 언제 완성할지는 모르겠지만 일단 해보자

CS 지식 정리

사실 이거는 학교 다닐 때 열심히 공부 했으면 금방 한다. 하지만, 나는 학교 다닐 때 많이 방황했던지라 이에 대한 추가 공부도 필요한 상태다. 필기 시험 준비할 겸 옛날에 봤던 책, PPT, 깃허브 등을 참고해서 공부하자

자소서 & 면접

공고 뜨는대로 최대한 많이 써보자. 이전에도 많이 써봤지만 마스터 자소서 하나 만들어서 최대한 많이 써보자.

결론

사실 이렇게 아무생각 없이 글을 쓰다보니 학교 다닐 때 정말 성실하게 공부하고 조금만 더 빨리 졸업하고 그랬으면 이미 진작 어디든 일하고 있지 않았을까 라는 생각이 든다. 지금 취준하는 타이밍이 나쁜 것도 있지만 그렇다고 아예 아무것도 안하기에 내가 너무 젊다. 취업이 정말 힘들긴 하다. 나도 모르게 계속 남과 비교하고 있고, 한창 꽃다운 나이에 주말에도 제대로 쉬지 못하고 지친 몸과 마음을 이끌고 계속 공부를 해야되니 말이다. 솔직히 이 개발자 말고 다른 걸 해볼까라는 생각도 많이 든다.(지금도 들고 있다.) 쉬운거 하나 없지만 일단 "끝까지 결과를 만들어보자"라는 마인드로 하고 있다. 취준의 끝을 봐야 할 것 같다. 정말 두서 없이 의식의 흐름대로 쓴 글이지만 내가 원하는대로 최대한 되도록 더 노력해야겠다!

나 같은 경우는 원래 C++로 코테를 공부했을 때는, 입력은 cin을 출력은 그냥 cout이나 printf로 사용했기에 별 문제가 없었다. 하지만 Java로 코테 언어를 바꾸게 되면서 백준을 풀다가 입출력 부분이 계속 헷갈려 이번 기회에 블로그에 한꺼번에 정리할려고 한다.

1. Scanner

아마 자바에서 키보드로 데이터를 입력 받아 변수에 저장하는 가장 쉬운 방법은 Scanner를 사용하는 것이다. 사용 방법은 다음과 같다.

Scanner scanner = new Scanner(System.in); 

왼쪽 Scanner scanner는 Scanner 변수를 선언하는 부분이고, 오른쪽 new Scanner(System.in)은 Scanner 객체를 생성하는 부분이다. 이렇게 생성된 Scanner를 왼쪽 scanner 변수에 대입한다. 보통 백준에서는 Scanner를 다음과 같이 많이 쓴다. 먼저, Scanner를 사용하기 위해서는 다음과 같이 java.util.Scanner 클래스를 반드시 import 해야 한다. 아니면 import java.util.*을 사용해서 util 클래스 전체를 import 해도 된다.

import java.util.Scanner;

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

        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt(); // 3을 입력 받았다고 가정
        int b = sc.nextInt(); // 5를 입력 받았다고 가정 

        System.out.println(a + b); // 8
   }
}

참 쉽다. 나는 그래서 주로 간단한 브론즈 문제나, 입력이 간단할 경우 Scanner를 주로 쓴다. 위에 nextInt()는 Scanner에서 자주 사용되는 메서드 중 하나이다. Scanner에서 자주 쓰는 메서드의 종류는 다음과 같다.

하지만 문제의 입출력이 많아지고 느려질 수록 이러한 Scanner 방식을 사용하면 입력 받을 때 시간초과가 발생할 수 있다. 또한, 문제마다 1, 2초 등의 시간 제한이 있기 때문에 각 테스트 케이스의 개수가 늘어날 수록 System.out.println()의 호출 횟수 또한 증가하게 된다. 그러므로 Scanner와 System.out.println 대신 BufferedReader와 BufferedWriter를 사용할 수 있다.

2. BufferedReader / BufferedWriter

BufferedReader

우선 BufferedReader와 BufferedWriter를 설명하기 전에 간단하게 스트림(Stream)이라는 개념을 설명하고자 한다.

먼저, 데이터는 키보드를 통해 입력될 수도 있고, 파일 또는 프로그램으로부터 입력될 수도 있다. 반대로, 데이터는 모니터로 출력될 수도 있고, 파일에 저장되거나 다른 프로그램으로 전송될 수도 있다. 이것을 다 합쳐 데이터 입출력이라고 부른다.

자바는 입력 스트림과 출력 스트림을 통해 데이터를 입출력한다. 스트림은 단방향으로 데이터가 흐르는 것을 말하는데 아래 그림과 같이 데이터는 출발지에서 나와 도착지로 흘러들어간다.

BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); // 선언
String str = br.readLine(); // 한줄 읽음 
int i = Integer.parseInt(br.readLine()); 

readLine() 메서드를 통해 한 줄 전체를 입력 받는다. 다만, 해당 메서드는 String으로 리턴 값이 고정되어 있기 때문에, 다른 타입으로 입력을 받고자 한다면 반드시 형변환이 필요하다. 그리고, 예외처리를 반드시 필요로 한다. 보통 main문에 throws IOException를 통한 예외처리를 많이 사용하는 편이다. (그리고 자바의 입출력과 관련한 java.io.* 클래스를 import 해야 한다.) 즉, BufferedReader는 Scanner와 달리 개행문자를 받아들이고 입력 받은 데이터가 String으로 고정되어 있다. 그러므로 따로 데이터를 가공해야 되는 경우가 많지만 Scanner보다 속도가 빠르다는 장점이 있다. 아래 사진을 보면 BufferedReader가 Scanner보다 빠른 것을 알 수 있다.

BufferedReader 클래스의 메서드 종류는 다음과 같다.

StringTokenizer

BufferedReader를 통해 읽은 데이터는 개행문자 단위 (즉, Line 단위)로 나누어진다. 만약 이를 공백 단위로 데이터를 가공하고 싶으면 따로 작업을 해야 한다. 이럴 때 사용하는 것이 StringTokenizer나 String.split() 함수이다. StringTokenizer 클래스를 사용하기 위해서는 import java.util.StringTokenizer;를 import 해야 한다.

BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); // 선언 
StringTokenizer st = new StringTokenizer(br.readLine());
int N = Integer.parseInt(st.nextToken()); // 문자열 -> 정수 변환
int M = Integer.parseInt(st.nextToken());

// String.split() 메서드
String[] arr = str.split(" ");

StringTokenizer의 nextToken() 함수를 사용하면 readLine()을 통해 입력 받은 토큰 값을 공백 단위로 구분하여 순서대로 호출한다. String.split() 함수를 사용하면, 배열에 공백단위로 끊어 데이터를 저장하여 사용할 수 있다.

BufferedWriter

일반적으로 출력을 할 때 System.out.println(""); 을 사용하는 경우가 많다. 하지만 출력해야 하는 양이 많은 문제를 접하게 된 경우에 System.out.println("");을 사용하게 되면 성능상에 문제가 발생할 수 있다. 그래서 출력해야 될 양이 많은 경우에는, 입력과 동일하게 버퍼를 사용하는 것이 좋다.

BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out)); // 선언
String str = "ABC";
bw.write(str); // 출력
bw.newLine(); // 줄바꿈
bw.flush(); // 버퍼에 남아있는 데이터 모두 출력
bw.close();  // 스트림 (연결된 자원) 닫음. 자원 해제 

BufferedWriter는 System.out.println("");처럼 출력과 개행을 동시해 할 수 없기 때문에, 개행을 위해서는 따로 newLine(); 또는 bw.write("\n");을 사용해야 한다. 그리고 BufferedWriter의 경우 버퍼를 점유하고 있기 때문에 반드시 사용 후, flush()를 통해 버퍼에 남아있는 데이터를 모두 출력하고, close()를 통해 버퍼를 해제해야 한다. close()를 사용하게 되면, 출력 스트림을 아예 닫아버리기 때문에 한번 출력 후, 다른 것도 출력하고자 한다면 flush()를 사용하면 된다.

3. String, StringBuffer, StringBuilder

또, 자바로 알고리즘 문제를 풀다보면 StringBuilder를 사용하는 경우가 많다. 그러므로, String과 StrigBuffer, StringBuilder와의 차이점을 중심으로 이를 설명하고자 한다.

먼저, String 클래스 관련 메서드를 보여주고자 한다. 종류는 다음과 같다.

String str = "apple";

// 길이 반환
str.length(); // 5

// 빈 문자열 체크
str.isEmpty(); // false

// 문자 찾기
str.charAt(0); // 'a'
str.indexOf("a"); // 0
str.lastIndexOf("p"); // 2

// 문자 자르기
str.substring(1, 3); // "pp"
str.substring(3); // "le"

// 문자 치환 (바꾸기)
// replace([기존문자], [바꿀문자])
str.replace('p', 'e'); // "aeele"

// replaceAll([정규식], [바꿀문자])
str.replaceAll(".", "/"); // "/////"

// replaceFirst([기존문자], [바꿀문자])
str.replaceFirst("p", "e"); // "aeple"

// 문자 동일 여부 판단
str.equals("apple"); // true

// 문자 비교
// str과 "applp"가 다를 때 compareTo 결과
str.compareTo("applp"); // -1

// 문자 포함 여부 판단
str.contains("app"); // true

// 문자열 분리
str.split(" "); // {"apple"} (공백 없으므로 전체 문자열 반환)
str.split(""); // {"a", "p", "p", "l", "e"}

// 문자 앞뒤 공백 제거
str.trim(); // "apple" (앞뒤 공백 없으므로 그대로)

// 문자 <-> 숫자 변환
Integer.parseInt("100"); // 100
Integer.toString(100);  // "100"

자바에서 문자열이란 문자들을 배열의 형태로 구성한 이뮤터블(immutable) 객체이다. 이뮤터블 객체는 값을 변경할 수 없는 객체로 시간 복잡도 관점에서 주의해야 할 필요가 있다.

String string = "He";
string += "llo";
System.out.println(string); // "Hello"

1. 문자열을 "He"로 초기화. 변수 string이 문자열 "He"를 참조
2. 이어서 string이 참조하는 "He"와 "llo"를 합쳐 새로운 문자열을 만들고 string은 새로운 문자열인 "Hello"를 참조한다.

즉, 자바에서 String 객체는 값을 변경할 수 없으므로 문자열을 변경할 때마다 기존 문자열을 끊고 새 문자열을 참조해야 한다(새로운 값을 할당). 그러므로 시간 복잡도 관점에서 연산의 비용이 클 수 밖에 없다.

그러므로 이러한 문제를 해결하기 위해 나온 것이 StringBuffer 클래스와 StringBuilder 클래스이다. 이 두 클래스는 뮤터블하므로 값을 변경할 때 시간 복잡도 관점에서 더 효율적이다.

String의 값을 변경하는 연산이 많을 때 StringBuffer와 StringBuilder 클래스를 사용할 수 있고, 두 클래스의 차이는 멀티 스레드 환경에서 Thread-Safe 여부로 나뉜다. Thread-Safe가 없는 StringBuilder 클래스가 속도 측면에서 미세하지만 더 빠르므로 StringBuilder를 사용하면 된다.

즉, 코딩테스트에서 문자열의 값을 변경하는 연산이 많을 때 시간 초과가 발생하지 않도록 StringBuilder를 사용하면 좋다. StringBuilder 관련 메서드는 아래와 같다.

StringBuilder sb = new StringBuilder(); // StringBuilder 객체 생성

// 문자열 추가
sb.append("apple");

// 특정 인덱스에 문자 삽입
sb.insert(2, "oo");

// 문자열 삭제
sb.delete(0, 2); // "oople"

// 특정 인덱스의 문자 삭제
sb.deleteCharAt(2); // "oole"

// 특정 인덱스의 문자를 변경
sb.setCharAt(1, 'p');

// 문자열 뒤집기
sb.reverse();

// 문자열 절대길이 줄이기 
sb.setLength(2);

// 문자열 절대길이 늘이기
sb.setLength(4);

이렇게 백준에서 많이 쓰이는 자바 입출력 형식과 문자열 등을 알아봤다. 사실 대부분의 기업 코딩 테스트는 프로그래머스로 응시해서 입출력 같은 경우는 몰라도 된다. 하지만 백준과 같이 입출력이 많은 경우에는 반드시 이를 필수적으로 알아야 한다. 이전에는 정말 헷갈렸지만 이렇게 한번 제대로 정리하니깐 복습하기가 더 수월해진 것 같다!

참고

• https://rlawo32.tistory.com/entry/%EB%B0%B1%EC%A4%80-JAVA-%EC%9E%85%EC%B6%9C%EB%A0%A5-%EC%A0%95%EB%A6%AC
• https://ittrue.tistory.com/108
• https://rlakuku-program.tistory.com/33
• https://mebadong.tistory.com/12
• 코딩 테스트 합격자 되기: 자바편
• 이것이 자바다

1. Java Collection Framework란?

먼저, Java Collection Framework란 자바에서 널리 알려져 있는 자료 구조(Data Structure)들을 바탕으로 객체들을 효율적으로 추가, 삭제, 검색할 수 있도록 관련된 인터페이스와 클래스들을 java.util 패키지에 포함시켜 놓은 것을 말한다.

즉, 자료 구조의 형태들을 자바 클래스로 구현한 모음집이라고 보면 된다. 더 쉽게 생각하면 자바에서 C++의 STL 역할을 한다고 생각하면 쉬울 것이다. 이 컬렉션 프레임워크를 통해 자바 개발자들은 직접 자료구조를 직접 구현할 필요없이 이들을 인스턴스화시켜서 사용만 하면 된다.

1-1. 컬렉션 프레임워크의 이점

컬렉션 프레임워크는 다음과 같은 이점을 가진다.

• List, Queue, Set, Map 등의 인터페이스를 제공하고, 이를 구현하는 클래스를 제공하여 일관된 API를 사용할 수 있다.
• 가변적인 저장 공간을 제공한다. 이는 고정적인 저장 공간을 제공하는 배열과 대비되는 특징이라고 볼 수 있다.
• 개발자 스스로 자료구조, 알고리즘 등을 구현할 필요 없이, 이미 구현된 컬렉션 클래스를 목적에 맞게 선택해서 사용하면 된다.
• 제공되는 API의 코드는 검증되었으며, 고도로 최적화되어 있다.

1-2. 구성요소

컬렉션 프레임워크는 다음과 같이 크게 3가지 요소로 구성되어 있다.

1. 인터페이스(Interfaces) : 각 컬렉션을 나타내는 추상 데이터에 대한 인터페이스(List, Set, Map, Queue 등). 클래스는 이 인터페이스를 구현하는 방식으로 작성되어 있기 때문에 상세 동작은 달라도 일관된 조작법으로 사용할 수 있다.

2. 클래스(Classes) : 컬렉션 별 인터페이스의 구현(Implementation). 같은 List 컬렉션이더라도 개발자의 목적에 따라 ArrayList, LinkedList 등으로 상세 구현이 달라질 수 있다.

3. 알고리즘(Algorithms) : 컬렉션이 제공하는 연산, 검색, 정렬, 셔플(Shuffle) 등에 대한 메서드.

이러한 특성을 가진 자바 컬렉션 프레임워크의 계층도는 아래와 같다.

사실 컬렉션 프레임워크를 구성하는 인터페이스와 클래스의 종류는 정말 많다. 그래서 나는 코딩테스트에 주로 나오는 것들로 정리하고자 한다. 크게 List, Queue, Set, Map 인터페이스로 구성되어 있다고 생각하면 쉽다.

2. 배열, ArrayList

배열 (Array)

배열은 처음 선언할 때 크기가 결정된다. 즉, 크기가 정적이다. 만약 문제에서 데이터의 개수를 정확히 알 수 있다면 코드가 더 간결하고 속도가 더 빠른 배열을 사용하면 된다.

int[] arr1 = {1, 2, 4, 5, 3}; // 1차원 배열 선언 + 생성 + 초기화
int[] arr2 = new int[5]; // new 연산자를 사용해 배열 선언 후 생성

int[][] arr3 = {{1, 2, 3}, {4, 5, 6}}; // 2차원 배열 생성 (2행 3열)
System.out.println(arr[1][2]); // 6
// arr[1][2]에 저장된 값을 7로 변경
arr[1][2] = 7;
// 변경된 값을 출력
System.out.println(arr[1][2]); // 7

System.out.println(arr1.length); // arr1 배열의 전체 데이터 개수를 리턴 : 5
Arrays.sort(arr1); // arr1 배열의 모든 데이터 정렬하는 Arrays 클래스의 sort() 메서드 : [1, 2, 3, 4, 5]
System.out.println(Arrays.toString(arr1)); 
// 배열의 모든 데이터를 String으로 변환하는 Arrays 클래스의 toString() 메서드: [1, 2, 3, 4, 5]

ArrayList

자바에서 크기가 동적으로 변경되는 배열이 필요할 때는 ArrayList를 활용하면 된다. 실제로 코딩테스트 문제를 풀다보면 많이 활용된다.

List<String> list = new ArrayList<>();
List<String> list2 = new ArrayList<>();


// 요소 삽입
list.add("one");

// 특정 인덱스에 요소 삽입
list.add(0, "zero");

// 리스트 병합 (추가되는 리스트가 뒤로 온다)
list.addAll(list2);

// 특정 요소의 첫번째 인덱스 반환
list.indexOf("zero");

// 특정 요소의 마지막 인덱스 반환
list.lastIndexOf("zero");

// 특정 인덱스의 값 삭제
list.remove(0);

// 첫 번째 값 삭제
list.remove("one");

// 리스트 차집합
list.removeAll(list2);

// 리스트 교집합
list.retainAll(list2);

// 리스트 비우기
list.clear();

// 리스트 비어있는지 체크
list.isEmpty();

// 리스트 길이
list.size();

// 리스트 특정 요소 포함여부 체크
list.contains("one");

// 리스트에 다른 리스트 요소가 전부 포함되어 있는지 여부 체크
list.containsALL(list2); 

// 람다식 사용하여 요소를 제거
list.removeIf(x -> x % 2 == 0) // list 에서 짝수인 수를 모두 제거 

Array to List / List to Array / 배열 ↔ 리스트

프로그래머스 문제를 풀 때 많이 사용하는 패턴이다. 프로그래머스는 백준과 달리 리턴 값의 형태가 중요하기 때문에 이에 주의해 알고리즘을 구현해야 한다.

// 문자열 타입 배열을 List로 변환
String[] temp = {"apple", "banana", "lemon"};
List<String> list = new ArrayList<>(Arrays.asList(temp));

// List를 문자열 배열로 변환
List<String> list = new ArrayList<>();
String[] temp = list.toArray(new String[list.size()]);

// 정수 배열을 List로 변환
int[] temp = {1, 2, 3, 4};
List<Integer> list = new ArrayList<>(Arrays.asList(temp));

// List를 정수 배열로 변환
List<Integer> list = new ArrayList<>();
int[] temp = list.stream().mapToInt(x -> x).toArray();

Collections 관련 메서드

int[] temp = {1, 2, 3, 10, 20};
List<Integer> list = new ArrayList<>(Arrays.asList(arr));

// 정수형 List 원소 중 최대, 최소값
Collections.max(list);
Collections.min(list);

// List 정렬
Collections.sort(list); // 오름차순 (ASC)
Collections.sort(list, Collections.reverseOrder()); // 내림차순 (DESC)

// List 뒤집기
Collections.reverse(list);

// List 내 원소의 개수 반환
Collections.frequency(list, 3);

// List 내 원소를 이진탐색을 이용해 찾기
Collections.binarySearch(list, 10); // 3

3. 스택 (Stack)

스택은 제일 나중에 넣은 데이터를 먼저 꺼낼 수 있는 자료구조이다. 즉, LIFO(Last In First Out)의 특성을 가진다.

Stack<Integer> stack = new Stack<>();

// 요소 추가
stack.push(1);

// 요소 제거 (꺼내기)
stack.pop();

// 스택 비우기
stack.clear();

// 스택 크기 체크
stack.size();

// 스택이 비어있는지 유무 확인
stack.empty();

// 스택에 요소가 존재하는지 확인
stack.contains(1);

// 스택 최상단 요소 확인. pop()과 다름
stack.peek();

4. Queue (큐)

큐(Queue)는 먼저 들어간 데이터가 먼저 나오는 자료구조이다. 즉, 선입선출 또는 FIFO(First In First Out)의 특징을 가진다.

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

// 큐에 요소 추가 (enqueue)
queue.add(1); // 문제 상황에서 예외 발생 
queue.offer(2); // 문제 상황에서 false 리턴

// 큐에서 요소 제거 (dequeue)
queue.remove(); // 문제 상황에서 예외 발생
queue.pool(); // 문제 상황에서 null 리턴 

// 큐 비우기
queue.clear(); 

// 큐의 최전방 요소 확인
queue.element();  // 문제 상황에서 예외 발생
queue.peek(); // 문제 상황에서 null 리턴 

ArrayDeque

자바에서 제공하는 양방항 큐 (Double-ended queue) 구현체를 ArrayDeque라고 한다. Deque 인터페이스를 상속 받는다. 스택이나 큐로 사용하기에 적합하며, 동적 배열을 기반으로 하여 효율적인 성능을 제공한다.

1. 양방향 큐 : 앞쪽과 뒤쪽 모두에서 삽입과 삭제가 가능하다.
2. 빠른 성능 : ArrayDeque는 연결 리스트 기반의 LinkedList 보다 더 빠른 성능을 제공하는 경우가 많다.
3. 크기 제한 없음 : 내부 배열은 필요에 따라 자동으로 크기 조정
4. 단일 스레드 환경에서 사용해야 한다.

   ArrayDeque<Integer> deque = new ArrayDeque<>();
   

// 삽입 메서드 deque.addFirst(10); // [10] deque.addLast(20); // [10, 20] deque.offerFirst(5); // [5, 10, 20] deque.offerLast(25); // [5, 10, 20, 25]

// 삭제 메서드 deque.removeFirst(); // 제거: 5 → [10, 20, 25] deque.removeLast(); // 제거: 25 → [10, 20] deque.pollFirst(); // 제거: 10 → [20] deque.pollLast(); // 제거: 20 → []

// 조회 메서드 deque.addLast(30); // [30] deque.addLast(40); // [30, 40] deque.getFirst(); // 반환: 30 deque.getLast(); // 반환: 40 deque.peekFirst(); // 반환: 30 deque.peekLast(); // 반환: 40

// 기타 메서드 deque.size(); // 반환: 2 deque.contains(30); // 반환: true deque.isEmpty(); // 반환: false deque.clear(); // [ ] deque.isEmpty(); // 반환: true deque.addLast(50); // [50] deque.addLast(60); // [50, 60] Object[] array = deque.toArray(); // [50, 60]

- 여기서 `peek()`은 **맨 앞(혹은 맨 뒤) 요소를 반환만 하고 제거하지 않는다**.
- 반대로, `poll()`은 **맨 앞 (혹은 맨 뒤) 요소를 반환 후 제거**한다. 
```java
ArrayDeque<Integer> deque = new ArrayDeque<>();
deque.addLast(10);
deque.addLast(20);

// peekFirst(): 앞 요소 반환 (제거x)
System.out.println(deque.peekFirst()); // 10
System.out.println(deque); // 10 20

// pollFirst(): 앞 요소 반환 후 제거
System.out.println(deque.pollFirst()); // 10
System.out.println(deque); // 20 

LinkedList (연결 리스트)

LinkedList는 List 인터페이스와 Deque 인터페이스를 모두 구현하는 클래스이다. 즉, List 인터페이스와 Deque 인터페이스의 메서드를 모두 지원한다. 순차 저장과 삽입/삭제가 빠른 특징이 있다. - 앞/뒤 추가/삭제는 O(1) **- 중간 접근/삭제/검색은 O(n)

// LinkedList 선언
LinkedList<Integer> list = new LinkedList<>();

// 요소 추가 (List 메서드)
list.add(10);              // [10]
list.add(1, 20);           // [10, 20]
list.add(30);              // [10, 20, 30]

// 요소 접근 및 수정
list.get(1);               // 반환: 20
list.set(1, 25);           // [10, 25, 30]

// 요소 삭제
list.remove(1);            // 제거: 25 → [10, 30]
list.removeFirst();        // 제거: 10 → [30]
list.removeLast();         // 제거: 30 → []

// 앞/뒤 삽입 (Deque 메서드)
list.addFirst(5);          // [5]
list.addLast(15);          // [5, 15]
list.offerFirst(1);        // [1, 5, 15]
list.offerLast(20);        // [1, 5, 15, 20]

// 앞/뒤 요소 확인
list.getFirst();           // 반환: 1
list.getLast();            // 반환: 20
list.peekFirst();          // 반환: 1
list.peekLast();           // 반환: 20

// 앞/뒤 요소 제거
list.pollFirst();          // 제거 및 반환: 1 → [5, 15, 20]
list.pollLast();           // 제거 및 반환: 20 → [5, 15]

// 기타 메서드
list.size();               // 반환: 2
list.contains(15);         // 반환: true
list.isEmpty();            // 반환: false
list.toArray();            // 배열로 변환: [5, 15]
list.clear();              // 모두 제거
list.isEmpty();            // 반환: true

PriorityQueue (우선순위 큐)

우선순위 큐(PriorityQueue)는 Queue 인터페이스의 구현체 중 하나이다. 요소를 저장할 때 자동으로 우선순위를 부여하고, 요소를 꺼낼 때 우선순위가 가장 높은 요소부터 반환한다.

• 내부적으로 Heap(이진 트리) 구조를 사용해 효율적인 삽입/삭제 (O(log n))를 지원한다.
• 기본적으로 Comparable에 따라 우선순위를 매기며, Comparator를 지정하면 사용자 정의 하에 우선순위로 동작이 가능하다.

// 선언 (기본: 오름차순 정렬)
PriorityQueue<Integer> pq = new PriorityQueue<>();

// 요소 추가
pq.add(30);          // [30]
pq.offer(10);        // [10, 30]
pq.add(20);          // [10, 30, 20]

// 우선순위 가장 높은 요소 조회 (제거X)
pq.peek();           // 반환: 10

// 우선순위 가장 높은 요소 제거 (제거O)
pq.poll();           // 제거: 10 → [20, 30]

// 가장 높은 요소 제거 (예외 발생 가능)
pq.remove();         // 제거: 20 → [30]

// 특정 요소 포함 여부 확인
pq.contains(30);     // 반환: true

// 크기 확인
pq.size();           // 반환: 1

// 비어있는지 확인
pq.isEmpty();        // 반환: false

// 배열로 변환
Object[] arr = pq.toArray(); // [30]

// 모든 요소 제거
pq.clear();          // []

// Comparator를 사용한 내림차순 우선순위 큐
PriorityQueue<Integer> pqDesc = new PriorityQueue<>(Comparator.reverseOrder());
pqDesc.add(3);       // [3]
pqDesc.add(1);       // [3, 1]
pqDesc.add(2);       // [3, 1, 2]
pqDesc.peek();       // 반환: 3

5. HashMap(해시맵), HashSet(해시셋)

HashMap

Map 인터페이스의 구현체이다(Map<K, V>). <key, value> 쌍의 특징을 가지고, value만 중복을 허용한다. 또한, null 허용과 관련해 key는 1개, value는 여러 개 가능하다. 또한, 순서를 보장하지 않는다. 해시 테이블을 기반으로 하여 평균 O(1)에 가까운 접근 시간을 제공해 주로 검색에 많이 쓰인다.

HashMap<Integer, String> hashMap = new HashMap<>();

// 요소 추가
hashMap.put(1, "딸기");
hashMap.put(2, "바나나");
hashMap.put(1, "사과"); // (1. "딸기")의 value가 "사과"로 대체됨 

// 키에 해당하는 값 조회
hashMap.get(1);
hashMap.get(2);
// 키에 해당하는 값이 없으면 null을 반환한다. 
hashMap.get(3); 

// null 대신 기본 값을 반환할 수 있는 getOrDefault() 메서드 
System.out.println(map.getOrDefault(1, "default value1")); // 1
System.out.println(map.getOrDefault(2, "defalut value2")); // 2
System.out.println(map.getOrDefault(3, "default value3")); // default value3

// 요소 삭제 
hashMap.remove(1); // key가 1인 요소 삭제

// 전체 삭제
hashMap.clear(); 

// key 포함 여부 확인
hashMap.containsKey(1); 

// value 포함 여부 확인
hashMap.containsValue("사과");

// key - value 출력
for (Integer key : hashMap.keySet()) {
                System.out.prinlnt(key + " " + hashMap.get(key));
}

for (Entry<Integer, String> temp : hashMap.entrySet()) {
                System.out.println(temp.getKey() + " " + temp.getValue());
}

HashSet

Set 인터페이스의 구현체이다(Set<E>). HashSet은 Key값만 저장하지만 HashMap과 달리 중복을 허용하지 않는다. 1개의 null 값을 허용하고, HashMap과 마찬가지로 순서를 보장하지 않는다. 내부적으로 HashMap을 사용하고, value는 dummy object이다. HashMap과 같이 평균적으로 O(1)에 가까운 검색 성능을 보장한다.

HashSet<Integer> hashSet = new HashSet<>();
HashSet<Integer> hashSet2 = new HashSet<>();

// 요소 추가
hashSet.add(1);

// 요소 삭제
hashSet.remove(1); // 값이 1인 요소 삭제

// 차집합 
hashSet.removeAll(hashSet2); 

// 교집합
hashSet.retainAll(hashSet2);

// 데이터 초기화
hashSet.clear();

// hashSet 사이즈 확인
hashSet.size();

// 특정 요소 포함 여부 확인
hashSet.contains(1);

// 요소 전체 출력 
// Iterator 사용
Iterator tempIterator = hashSet.iterator();
while (tempIterator.hasNext()) {
                System.out.println(tempIterator.next());
}

// for-each문 사용
for (String item : hashSet) {
                System.out.println(item);
}

이렇게 정리를 끝마쳤다. 사실, 컬렉션 프레임워크 종류가 워낙 방대하고, 내가 못 다룬 부분도 분명 있을 테지만 대부분 여기에 다룬 것 같다. 정리한다고 여러 블로그, 책, GPT를 참고해서 노션에 정리했지만 사실 귀찮아서(?) 미루고 또 미뤘지만 결국 정리에 성공했다....(정리하느라 너무 힘들긴 했다...ㅋㅋㅋ) 분명 틀린 부분도 있을텐데 계속 보면서 수정해야 할 것 같다. 자바 코딩테스트 공부에 도움이 되면 좋겠다!

참고

• https://velog.io/@kkyes1210/JAVA-%EB%AC%B8%EB%B2%95-%EC%A0%95%EB%A6%AC-for-%EC%BD%94%EB%94%A9%ED%85%8C%EC%8A%A4%ED%8A%B8
• https://hudi.blog/java-collection-framework-1/
• 코딩 테스트 합격자 되기: 자바 편
• 이것이 자바다

프로그래머스 고득점 Kit에서 날짜 함수 관련 문제를 풀다 모르거나 헷갈리는 문법이 많았다. 그래서 한번 정리를 해봤다. 주요 함수는 아래와 같다.

1. SYSDATE: 현재 날짜와 시간

SELECT SYSDATE AS NOW
FROM DUAL;

2. CURRENT_DATE : 세션 기준 현재 날짜

SELECT CURRENT_DATE AS SESSION_NOW
FROM DUAL;

3. 날짜 → 문자열 변환 (TO_CHAR())

SELECT FIRST_NAME, LAST_NAME, TO_CHAR(HIRE_DATE, 'YYYY-MM-DD') AS HIRED
FROM EMPLOYEES
WHERE HIRE_DATE BETWEEN DATE '2016-01-01' AND DATE '2016-12-31'
ORDER BY FIRST_NAME, LAST_NAME;

• YYYY – 연도 (4자리)
• MM – 월 (2자리)
• DD – 일 (2자리)
• HH24 – 24시간 포맷
• MI – 분
• SS – 초
• DY – 요일 (약어 표시 ex. SUN, MON…)
• MONTH – 전체 달 이름

4. 연, 월, 일 추출 (EXTRACT )

대여 시작일에서 연도/월/일 추출

SELECT HISTORY_ID, CAR_ID,
             EXTRACT(YEAR FROM START_DATE) AS START_YEAR,
             EXTRACT(MONTH FROM START_DATE) AS START_MONTH,
             EXTRACT(DAY FROM START_DATE) AS START_DAY
FROM CAR_RENTAL_COMPANY_RENTAL_HISTORY;

5. 문자열 → 날짜 변환 (TO_DATE())

SELECT 
    USER_ID,
    FIRST_NAME,
    LAST_NAME,
    JOINED_DATE
FROM 
    USERS
WHERE 
    JOINED_DATE = TO_DATE('2025-03-20', 'YYYY-MM-DD');


### 5. 날짜 간 차이 (`END_DATE - START_DATE` 또는 `TRUNC` , `MONTH_BETWEEN` )

### 대여 기간 (일 수 계산)

```sql
SELECT HISTORY_ID, CAR_ID,
             START_DATE,
             END_DATE,
             END_DATE - START_DATE AS RENTAL_DAYS
FROM CAR_RENTAL_COMPANY_RENTAL_HISTORY;

6. MONTH_BETWEEN : 개월 단위 차이

SELECT HISTORY_ID, CAR_ID,
             MONTHS_BETWEEN(END_DATE, START_DATE) AS RENTAL_MONTH_DIFF
FROM CAR_RENTAL_COMPANY_RENTAL_HISTORY;

7. 월 말일 구하기 (LAST_DAY )

SELECT HISTORY_ID, CAR_ID,
             START_DATE, 
             LAST_DAY(START_DATE) AS START_MONTH_END
FROM CAR_RENTAL_COMPANY_RENTAL_HISTORY; 

8. 다음 특정 요일 구하기 (NEXT_DAY)

SELECT HISTORY_ID, CAR_ID,
             START_DATE,
             NEXT_DAY(START_DATE, 'MONDAY') AS NEXT_MONDAY
FROM CAR_RENTAL_COMPANY_RENTAL_HISTORY;

9. 몇 개월 뒤 날짜 (ADD_MONTHS)

• ** 대여 시작일 기준 3개월 뒤 날짜**

SELECT HISTORY_ID, CAR_ID,
             START_DATE,
             ADD_MONTHS(START_DATE, 3) AS AFTER_3_MONTHS
FROM CAR_RENTAL_COMPANY_RENTAL_HISTORY;

10. 특정 조건으로 날짜 비교 (WHERE + TO_DATE )

• **2022년 10월 이후에 시작한 대여
• *

  SELECT *
  FROM CAR_RENTAL_COMPANY_RENTAL_HISTORY
  WHERE START_DATE >= TO_DATE('2022-10-01', 'YYYY-MM-DD');

11. 날짜 시간 제거 (TRUNC)

SELECT HISTORY_ID, CAR_ID,
             TRUNC(START_DATE) AS START_DATE_TRUNC,
             TRUNC(END_DATE) AS END_DATE_TRUNC
FROM CAR_RENTAL_COMPANY_RENTAL_HISTORY;

막상 정리하고 나니깐 TO_CHAR(), TO_DATE(), EXTRACT(), MONTH_BETWEEN() 이외에는 별로 안 쓰이는 것 같다 ㅎㅎ 그래도 이번 기회에 정리하니깐 이제 더 이상 까먹을 일은 없을 것 같아 다행이다.

참고

Oracle Date Functions 프로그래머스 String, Date

RIGHT JOIN 도 이전에 배운 INNER JOIN 과 LEFT JOIN 과 마찬가지로 SELECT 문의 optional 절이다.

단지 LEFT JOIN 과 차이가 있다면, RIGHT JOIN 은 오른쪽 테이블에 있는 모든 행들을 리턴하고, 왼쪽 테이블에 있는 매칭되는 행들을 리턴 한다는 점이다.

문법은 다음과 같다.

SELECT COLUMN_LIST
FROM X RIGHT JOIN Y ON X.ID = Y.ID;

RIGHT JOIN 말고도 RIGHT OUTER JOIN으로 표현해도 된다. 여기서는 표기의 편리함을 위해 RIGHT JOIN으로 표시하고자 한다.

SELECT COLUMN_LIST
FROM X RIGHT OUTER JOIN Y ON X.ID = Y.ID;

RIGHT JOIN절 동작 원리

두 테이블 X 와 Y 가 있다고 하자. 그리고 RIGHT JOIN 을 이용해서 두 테이블에 있는 행들을 하나로 병합할려고 한다.

위와 같이 X 테이블에는 2개의 컬럼인 id (키)와 x 가 있다고 하자. 그리고 Y 테이블에는 id (키)와 y 가 있다고 하자.

RIGHT JOIN을 통해서 오른쪽 테이블인 Y 테이블에 있는 모든 행들과 왼쪽 테이블 Y 에서 매칭되는 행들을 반환한다. 만약, 오른쪽 테이블의 행이 왼쪽 테이블 X 에 있는 행과 매칭되는게 없다면, 왼쪽 테이블 X 의 컬럼들에 대해 NULL 값을 사용한다.

정말 말 그대로 LEFT JOIN의 반대라고 생각하면 된다. 그리고 이를 벤 다이어그램으로 표현하면 테이블 Y 전체를 표현하는 것과 같다. 모습은 아래와 같다.

RIGHT JOIN 쿼리 예시

지난 번과 마찬가지로 ORDER 테이블과 EMPLOYEES 테이블을 사용할 것이다. 각 테이블들의 연관관계는 다음과 같다.

판매 사원이 최소 1개에서 많게는 여러 개의 판매 주문을 담당할 수 있다는 것을 가정해보자. 하지만, 몇몇 주문들은 판매 사원의 담당이 아닐 수가 있다.

이를 쿼리로 표현하면 다음과 같다.

SELECT FIRST_NAME, LAST_NAME, ORDER_ID, STATUS 
FROM ORDERS RIGHT JOIN EMPLOYEES ON EMPLOYEE_ID = SALESMAN_ID
WHERE JOB_TITLE = 'Sales Representative'
ORDER BY FIRST_NAME, LAST_NAME;

해당 쿼리를 실행하면 결과는 다음과 같이 나온다.

여기서 주목해야 될 점은, 단 하나의 판매 주문을 담당하지 않는 판매 사원에 대해서는 ORDER_ID 와 STATUS 컬럼들에 대해 NULL 값을 채운다는 것이다.

USING 절을 이용한 RIGHT OUTER JOIN 표현

USING 절을 이용해서 INNER JOIN, LEFT JOIN을 배웠을 때와 마찬가지로 RIGHT OUTER JOIN을 표현할 수 있다. 문법은 다음과 같고 아래 쿼리를 실행하면 다음과 같다.

SELECT COLUMN_LIST
FROM X RIGHT JOIN Y USING(ID);

고객이 판매 주문 정보를 가지지 않는다면, ORDER_ID 와 STATUS 칼럼이 NULL 값으로 채워져 있는 것을 알 수 있다.

즉, RIGHT JOIN 을 사용해서 오른쪽 테이블에 있는 모든 행들과 왼쪽 테이블에 이와 매칭되는 행들을 포함시킬 수 있다.

참고

Oracle RIGHT OUTER JOIN Clause

• SELECT 문의 옵션절
• 두 테이블로부터 열들 합치도록 함
• 첫 번째 테이블이 LEFT TABLE, 두 번째 테이블이 RIGHT TABLE

LEFT JOIN 은 왼쪽 테이블에 있는 모든 행(rows)을 리턴하고, 오른쪽 테이블에 있는 매칭되는 행들(rows)을 리턴한다.

문법은 다음과 같다.

SELECT 
    column_list
FROM
    X
LEFT JOIN Y ON X.id = Y.id;

여기서 LEFT JOIN 은 왼쪽 테이블인 X 의 id 칼럼의 값들을 오른쪽 테이블인 Y 의 칼럼의 값들과 매치한다.

여기서 값들이 같다면, 양쪽 테이블에서 두 개의 열들을 합친다. 만약 왼쪽 테이블에 있는 열이 오른쪽 테이블에 있는 열과 매칭되는게 없다면, LEFT JOIN 은 왼쪽 테이블에 있는 행을 오른쪽 테이블에 있는 행과 합친다. 오른쪽 테이블에 있는 열들을 NULL 값으로 채운다.

• 테이블은 2개의 컬럼인 id (키)와 x
• Y 테이블은 2개의 컬럼인 id (키)와 y

left join은 왼쪽 테이블인 X 의 모든 행들과 오른쪽 테이블인 Y 에 있는 매칭되는 값들을 포함한다.

이를 벤 다이어그램으로 표현하면, 테이블 X 전체를 다 표현하는 것과 같다.

LEFT JOIN절 예시

관계형 데이터베이스는 각 테이블들의 관계를 표현하는 데이터베이스이다. 여기서 주문 정보를 나타내는 ORDERS 테이블과 판매 직원의 정보를 나타내는 EMPLOYEES 테이블이 있다고 하자.

여기서 ORDERS 테이블의 SALESMAN_ID 컬럼은 EMPLOYEES 테이블의 Primary Key인 EMPLOYEE_ID 를 참조한다. 즉, SALESMAN_ID 는 외래키이다.

SELECT ORDER_ID, STATUS, FIRST_NAME, LAST_NAME
FROM ORDERS
LEFT JOIN EMPLOYEES 
ON EMPLOYEES ON EMPLOYEE_ID = SALESMAN_ID
ORDER BY ORDER_DATE DESC;

해당 쿼리를 작성하면 쿼리 결과는 다음과 같이 나오는 것을 알 수 있다.

즉, LEFT JOIN 을 사용하면 왼쪽 테이블인 ORDERS 테이블에 있는 모든 행들을 리턴하고, EMPLOYEES 테이블과 매칭되는 행을 가지지 않는 행들에 대해서는 FIRST_NAME, LAST_NAME과 같은 컬럼에 대해서 NULL 값을 채운다.

LEFT JOIN 절 사용해서 3개의 테이블 합치기

테이블 3개를 LEFT JOIN 절을 사용해서 합칠 때도 위와 별반 다를게 없다. 다음 쿼리를 실행한 결과는 아래와 같다.

SELECT ORDER_ID, NAME AS CUSTOMER_NAME, STATUS, FIRST_NAME, LAST_NAME
FROM ORDERS
         LEFT JOIN EMPLOYEES ON EMPLOYEE_ID = SALESMAN_ID
         LEFT JOIN CUSTOMERS ON CUSTOMERS.CUSTOMER_ID = ORDERS.CUSTOMER_ID
ORDER BY 
         ORDER_DATE DESC;

매칭되지 않는 행들에 대해서는 null 값으로 채워진 것을 알 수 있다.

USING 절을 사용한 LEFT JOIN 표현

USING 절을 사용해서 테이블을 합치는 것을 표현할 수 있음을 배웠다. 그러면 LEFT JOIN 을 사용할 때도 이를 똑같이 적용할 수 있다.

SELECT 
    COLUMN_LIST
FROM 
    X
    LEFT JOIN Y USING (id);

여기서 LEFT JOIN 은 X 테이블의 id 컬럼의 값들이 Y 테이블의 id 컬럼의 값들과 같은지 체크한다.

USING 절을 이용한 표현은 다음과 같다.

USING (id)
ON X.id = Y.id

USING 절을 이용한 쿼리 예시

SELECT 
    NAME, 
    ORDER_ID,
    STATUS,
    ORDER_dATE
FROM 
    CUSTOMERS
LEFT JOIN ORDERS 
USING (CUSTOMER_ID)
ORDER BY NAME; 

해당 쿼리를 실행하면 다음과 같이 결과가 나오는 것을 알 수 있다.

고객이 어떠한 주문을 하지 않았다면, LEFT JOIN 을 통해 ORDERS 테이블의 컬럼(열)들을 NULL 값으로 채운 것을 알 수 있다.

즉, LEFT JOIN 절을 통해 왼쪽 테이블에 있는 모든 행들을 리턴하고 오른쪽 테이블에는 매칭되는 행들을 리턴한다. 매칭되는 행이 다면 NULL 값으로 채운다는 것을 알 수 있다.

그리고 LEFT JOIN 을 LEFT OUTER JOIN 으로 표현할 수 있다. 둘은 다른 의미가 아니고 단지 표현 방식이 다를 뿐이다. LEFT OUTER JOIN 을 써서 테이블을 합치고자 한다면 다음과 같이 쿼리를 작성하면 된다.

SELECT ORDER_ID, STATUS, FIRST_NAME, LAST_NAME
FROM ORDERS
LEFT OUTER JOIN EMPLOYEES 
ON EMPLOYEES ON EMPLOYEE_ID = SALESMAN_ID
ORDER BY ORDER_DATE DESC;

참고

Oracle LEFT JOIN Clause

다른 테이블과 매칭되는 열들이 있는 테이블로부터 열을 추출하고 싶을 때 INNER JOIN 을 사용할 수 있다. 즉, JOIN은 여러 테이블의 관련 있는 데이터를 하나로 결합해 조회하는 SQL 구문이다.

SELECT 
    column_list
FROM
    X
    INNER JOIN Y ON X.id = Y.id;

• ON 키워드 뒤에 join 조건을 정의한다. 여기서 join 조건이란 두 테이블을 결합하는데 필요한 조건들을 말한다.
• Oracle은 그러면 먼저 FROM 절을 평가하고, 그리고 INNER JOIN, 마지막으로 SELECT 절을 평가한다.

INNER JOIN 동작과정

1. INNER JOIN 이 X와 Y 테이블 모두에 존재하는 id 컬럼의 값을 비교한다.
2. 그리고 id 컬럼의 값들이 같다면 두 테이블로부터 매칭되는 열들의 값을 합친다.
3. 최종적으로 SELECT 절이 명시된 값(column_list)을 반환한다.

자 그러면 어떻게 Oracle에서 INNER JOIN이 성립되는지 알아보자.

여기 두 개의 테이블 X 와 Y 가 있다. INNER JOIN 을 사용해서 두 테이블에 있는 row들을 합칠려고 한다.

• X 테이블은 2개의 컬럼 : id (키), x 를 가진다.
• Y 테이블도 2개의 컬럼 : id (키), y 를 가진다.

INNER JOIN을 통해 id 컬럼에서 매칭되는 값들을 가지는 두 개의 테이블로부터 rows(행들)을 포함할 수 있다. 다만, 매칭되지 않는 열들은 결과에 포함시키지 않는다.

이렇게 INNER JOIN을 벤 다이어그램으로 표현하면 마치 두 집합의 교집합을 찾는 것과 같다.

SELECT *
FROM orders INNER JOIN order_items 
ON order_items.order_id = orders.order_id
ORDER BY order_date DESC;

USING 절을 이용한 INNER JOIN 표현

SELECT 
    *
FROM
    X
INNER JOIN Y USING (c1, c2, ...);

위에서 본 ON 절과 마찬가지로, 테이블을 합칠 때 어떤 칼럼이 같은 지를 표시하기 위해 USING 절을 활용할 수 있다.

SELECT 
    *
FROM 
    orders
INNER JOIN order_items USING( order_id )
ORDER BY 
    order_date DESC;

참고

Oracle INNER JOIN Clause

아쉽게도 수료 이후 인턴에는 합격하지 못했지만, 그래도 프디아를 하면서 많은 것을 배웠던 것 같다.

• 프론트를 아예 하지도 못한 내가 UI를 만들고, 백엔드 API와 연결할 수 있게 되었다.
• 그리고 AWS에 대해 어느 정도 익숙해져 아키텍처도 이제 능숙하게 그릴 줄 알고 서비스에 맞게 이를 구축할 수 있게 되었다.
• 오픈 API를 활용한 프로젝트를 2번 수행하며 금융 데이터가 어떻게 처리되고 이를 API로 구현해 어떻게 배포할 수 있게 되었는지 배웠다.

*- 그리고 무엇보다 단기간에 압축적으로 성장한게 가장 큰 것 같다. *

작년 이맘때쯤에 나는 전공자임에도 불구하고 그간 코딩을 등한시해 프로젝트 경험도 얼마 없던 채로 졸업 프로젝트를 진행하고 있었다. 하지만 졸업 이후, 프디아 교육과정을 수료하며 미니 프로젝트, 프론트, 파이널 프로젝트까지 진행하며 프로젝트 경험을 많이 쌓을 수 있었다. 또한, 능력있는 팀원들을 만나 너무 많은 도움을 받을 수 있었다.

사실 회고록을 수료하고 저번 달에 써야 되는게 맞지만, 이제라도 안 쓰면 아무것도 안 할 것 같아서 쓰게 되었다.

사실 프디아를 하면서 아쉬웠던 점은 다음과 같다.

• 시간에 쫓겨 코드를 짜는데 깊게 생각하지 못한 것 같다.

• Docker와 Linux에 대한 이해 없이 Jenkins CI/CD를 무리하게 진행한 점이 아쉬웠다.

• AWS Solutions Architect Associate 시험을 한 문제 차이로 떨어진 점도 아쉬웠다.

• 교육과 프로젝트, 그리고 취업준비를 한다고 코딩테스트를 더 열심히 하지 못한 점이 아쉬웠다.

• 포트폴리오를 대충 만들기는 했지만 개선하지 안한 점이 아쉬웠다.

• 뭔가 나 스스로 끝까지 진행한 프로젝트가 없어서 아쉬웠다.

사실 떠오르면 더 있을테지만 대충 이 정도인 것 같다.

그러면 나는 이제 무엇을 해야될까?

당연히 취직을 해야된다!

벌써 1달이란 소중한 시간이 지났다. 취직을 할려면 알다시피 코딩테스트라는 벽을 통과해야 된다. 코딩테스트를 통과해야 면접의 기회가 주어진다. 그래서 당분간은 코딩테스트를 중점적으로 공부할려고 한다.

그리고 자소서를 꾸준하게 작성해서 지원할려고 한다. 사실 수료하고나서도 자소서는 꾸준하게 작성했지만 여러 기업들을 더 지원할려고 한다. 그리고 남는 시간에 CS나 지난 프로젝트 등을 리팩토링 할 계획이다.

앞으로 나의 목표이다.

1. 코딩테스트 통과할 실력 만들기 (백준, 프로그래머스 최대한 많이 풀고 노션이나 블로그에 정리하기) -> 제일 중요하다

2. 토익 시험 응시하기 (금융권 IT는 토익을 더 우대하는 것 같아 응시할려고 한다.)

3. 투자자산운용사 공부하고 합격하기

4. 프로젝트 리팩토링하기 (이전에 했던 프로젝트들을 정리해서 관련 있는 내용을 블로그에 정리할려고 한다. 그리고 포트폴리오에 정리할려고 한다.)

5. 자소서 많이 쓰면서 바로 면접 준비하기 (자소서와 면접은 하나다)

6. 반드시 올해 안에 취업하기

뭐 이 정도인 것 같다. 눈에 띄는 가시적인 성과를 많이 쌓아야 더 자극이 되면서 부지런히 사는 것 같다. 그동안 너무 게으르게 산 것 같다. 다시 열심히 부지런히 움직일 때가 된 것 같다.

아마 개발을 하시다 보면 개인적으로 좋아하는 언어가 생길 것이라고 생각합니다. 다들 좋아하시는 언어가 있으신가요? 저 같은 경우는 학부 시절 수업에서 C++을 주로 많이 사용해서 가장 편하고 익숙한 언어였던 것 같습니다 (처음 포인터 배웠을 때는 엄청 싫어했습니다 ㅎㅎ)

이후에는 주로 웹 백엔드 프로젝트를 수행하면서 JAVA라는 언어가 편해지면서 좋아하게 된 것 같습니다. 아무래도 JAVA가 C++과 비슷한 객체지향 프로그래밍의 성격을 공유하면서도 (클래스, 상속, 다형성 등) 웹과 엔터프라이즈 스케일의 애플리케이션을 주로 개발하는데 사용되기 때문에 그런 것 같다고 생각이 듭니다.

그러면 제가 생각했을 때 중요하다고 생각한 JAVA의 대표적인 특징들을 살펴보고자 합니다. 책이나 블로그, 유튜브에서도 많이 나오는 내용들이지만 제 나름대로 한번 정리하겠습니다. C++을 주로 사용했기에 C++ 기준으로 신기하거나 중요하다고 느꼈던 JAVA의 특징들을 나열하겠습니다.

1. 객체지향 프로그래밍 언어

맞습니다. JAVA는 _"객체지향 프로그래밍(OOP, Object Oriented Programming) 언어"_입니다. 그러면 객체지향 프로그래밍이란 무엇일까요? 대부분의 컴퓨터 공학도분들이 단순히 객체를 추상적으로 이해하는 경향이 있을 것이라고 생각합니다. 왜냐하면 학부 입학 시 1학년부터 파이썬이나 C++ 같은 객체지향 언어를 먼저 배우면서 객체지향 패러다임을 당연시 여기기 때문입니다.

그러면 객체(Object)란 무엇일까요? 먼저 객체를 본격적으로 설명하기 전에 클래스(Class)에 대해 설명하고자 합니다. 먼저, JAVA나 SPRING을 공부할 때 많이 참고하는 사이트인 Baeldung의 설명을 인용해서 설명하도록 하겠습니다. 본문에는 아래와 같이 클래스에 대해 설명하고 있습니다.

In OOP, classes are blueprints or templates for objects. 
We use them to describe types of entities.

Simply put, a class represent a definition or a type of object. 
In Java, classes can contain fields, constructors, and methods.

객체에 대한 템플릿_이니, _객체의 정의 또는 타입을 표현 등등 이래도 이해하기가 힘드실 것이라고 생각합니다. 저 또한 이 클래스라는 개념을 이해하는데 상당한 시간이 걸렸던 것 같습니다. 하지만 학부 JAVA 수업에서 교수님이 클래스란 _"사용자가 정의한 타입"_이라는 설명을 듣고 정말 명쾌하게 이해가 된 경험이 있습니다.

맞습니다. C++이나 JAVA는 꽤나 타입에 엄격한 언어입니다. 이유를 생각하자면 그 당시 80, 90년대 하드웨어 용량과 성능이 지금보다 상당히 제약되어 있었기에 이러한 타입마다 바이트 수를 달리해 성능을 최대한 끌어올리는 것이 그 당시 최선이었다는게 저의 합리적인 추측이라고 생각합니다. 아무튼 JAVA는 정수, 실수, 문자열 등의 다양한 타입이 존재합니다. 그래서 _객체의 속성(state = 필드(field))과 행동(behavior = 메서드(method))_을 포함하는 클래스는 타입으로 표현할 수 있습니다. 예시는 다음과 같습니다.

public class Cat {
    // 필드 선언
    String name;
    int age;

    // 매개변수 name과 age를 가지는 생성자 선언 
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

       // 메서드 선언 
    public void walk() {
        System.out.println("사뿐사뿐");
    }
}

이렇게 선언한 Cat 클래스를 main문에서 new 명령어를 이용해 Cat 타입의 객체를 생성할 수 있습니다.

public Class Main {
    public static void main(String[] args) {
        // Cat 타입의 객체 생성
        Cat cat1 = new Cat("깜이", 4);
        Cat cat2 = new Cat("냥이", 5);

        // 객체의 메서드 호출
        cat1.walk();
        cat2.walk();
    }
}

앞서 설명한 부분을 이어 객체(Object)란 클래스, 즉 내가 정의한 타입으로 만들어낸 실체라고 볼 수 있습니다. 위 코드에서 보이듯이 Cat 클래스를 선언함으로써 Cat 타입의 객체인 cat1, cat2를 생성한 것을 확인할 수 있습니다. 학부 수업 때 교수님이 객체를 설명하시기로는 _"클래스를 가지고 실제로 메모리에서 만들어진 것"_이라고 하셨는데 해당 설명이 더 잘 와닿는 것 같습니다. 실제로 Baeldung에서도 객체를 다음과 같이 설명하고 있습니다.

While classes are translated during compile time, 
objects are created from classes at runtime.

Objects of a class are called instances, 
and we create and initialize them with constructors:

여기서 객체랑 인스턴스를 헷갈릴 수 있는데 사실상 동의어라고 생각하시면 됩니다.

네, 이렇게 JAVA가 가진 객체지향 프로그래밍의 특징을 간단하게 살펴보았습니다. C++을 주로 코딩 테스트 문제 풀 때 사용했기에 객체지향적인 느낌을 많이 못 느꼈지만 JAVA로 백엔드 개발을 하면서 클래스와 객체에 대해 더욱 자세히 이해할 수 있던 것 같습니다. 인터페이스와 다형성에 대한 글을 이 포스트에 한꺼번에 작성할려고 했는데 분량조절 실패로 다음 포스트에 올리도록 하겠습니다. 그러면 긴 글 읽어주셔서 감사합니다 :)