• subquery란 SELECT, INSERT, UPDATE, DELETE에 포함된 query를 말한다.

• outer query : subquery를 포함하는 query를 말한다.

• subquery는 ()안에 기술된다.

| id가 14인 임직원보다 생일이 빠른 임직원의 id,이름,생일을 출력하라

mysql> SELECT birth_date FROM employee WHERE id = 14;
+------------+
| birth_date |
+------------+
| 1992-08-04 |
+------------+
1 row in set (0.04 sec)

mysql> SELECT id, name, birth_date FROM employee WHERE birth_date < '1992-08-04';
+----+--------+------------+
| id | name   | birth_date |
+----+--------+------------+
|  1 | MESSI  | 1987-02-01 |
|  5 | DINGYO | 1990-11-05 |
|  6 | JULIA  | 1986-12-11 |
|  9 | HENRY  | 1982-05-20 |
| 10 | NICOLE | 1991-03-26 |
| 13 | JISUNG | 1989-07-07 |
+----+--------+------------+

• 위의 두 쿼리를 한 문장으로 합치면 다음과 같다. ```sql mysql> SELECT id, name, birth_date FROM employee -> WHERE birth_date < (SELECT birth_date FROM employee WHERE id = 14);
• ----+--------+------------+ | id | name | birth_date |
• ----+--------+------------+ | 1 | MESSI | 1987-02-01 | | 5 | DINGYO | 1990-11-05 | | 6 | JULIA | 1986-12-11 | | 9 | HENRY | 1982-05-20 | | 10 | NICOLE | 1991-03-26 | | 13 | JISUNG | 1989-07-07 |
• ----+--------+------------+

| id가 1인 임직원과 같은 부서, 같은 성별인 임직원들의 id,이름,직군을 출력하라

mysql> SELECT id, name, position FROM employee
    -> WHERE (dept_id, sex) = (
    -> SELECT dept_id, sex
    -> FROM employee
    -> WHERE id = 1
    -> );
+----+-------+-----------+
| id | name  | position  |
+----+-------+-----------+
|  1 | MESSI | DEV_BACK  |
| 14 | SAM   | DEV_INFRA |
+----+-------+-----------+

IN

• v IN (v1, v2, v3 ...) : v가 (v1, v2, v3 ...) 중 하나라도 값이 같다면 true를 리턴한다.

• (v1, v2, v3 ...) 안에 subquery의 결과가 들어갈 수 있다.

• v NOT IN (v1, v2, v3 ...) : v가 (v1, v2, v3 ...) 의 모든 값과 일치하지 않을 때 true를 리턴한다.

id가 5인 임직원과 같은 프로젝트에 참여한 임직원들의 id를 출력하라

mysql> SELECT DISTINCT empl_id FROM works_on
    -> WHERE empl_id <> 5 AND proj_id IN (
    -> SELECT proj_id FROM works_on WHERE empl_id = 5);
+---------+
| empl_id |
+---------+
|       1 |
|       3 |
|      10 |
|      13 |
|      14 |
+---------+

| id가 5인 임직원과 같은 프로젝트에 참여한 임직원들의 id, 이름을 출력하라 이름은 works_on 테이블만으로는 알 수 없다. employee 테이블에서 위에서 구한 id와 대응하는 이름들을 조회해야한다.

mysql> SELECT id, name
    -> FROM employee WHERE id IN (
    -> SELECT DISTINCT empl_id FROM works_on
    -> WHERE empl_id <> 5 AND proj_id IN (
    -> SELECT proj_id FROM works_on WHERE empl_id = 5));
+----+--------+
| id | name   |
+----+--------+
|  1 | MESSI  |
|  3 | JENNY  |
| 10 | NICOLE |
| 13 | JISUNG |
| 14 | SAM    |
+----+--------+

같은 조건을 반환하지만 subquery를 FROM 절에서도 쓸 수 있다.

mysql> SELECT id, name
    -> FROM employee, (
    -> SELECT DISTINCT empl_id FROM works_on
    -> WHERE empl_id <> 5 AND proj_id IN (
    -> SELECT proj_id FROM works_on WHERE empl_id = 5))
    -> AS E
    -> WHERE id = E.empl_id;
+----+--------+
| id | name   |
+----+--------+
|  1 | MESSI  |
|  3 | JENNY  |
| 10 | NICOLE |
| 13 | JISUNG |
| 14 | SAM    |
+----+--------+

• subquery를 FROM에 적어서 가상의 테이블로 만들고 가상의 테이블의 별칭을 E라고 정해준다. 그 후 WHERE 절에서 E.empl_id와 employ테이블의 id를 통해 join condition을 만들어준다.

EXISTS

• EXISTS : subquery의 결과가 최소 하나의 row라도 있다면 true 반환

• NOT EXISTS : subquery의 결과가 단 하나의 row도 없다면 true 반환

| id가 7 혹은 12인 임직원이 참여한 프로젝트의 id, 이름을 출력하라

mysql> SELECT P.id, P.name
    -> FROM project P
    -> WHERE EXISTS (
    -> SELECT *
    -> FROM works_on W
    -> WHERE W.proj_id = P.id AND W.empl_id IN (7, 12)
    -> );
+------+------------------+
| id   | name             |
+------+------------------+
| 2003 | 홈페이지 UI 개선   |
+------+------------------+

• EXISTS와 IN은 서로 바꿔가면서 쓸 수 있다. 위의 쿼리문을 IN으로 바꾸면 다음과 같다. ```sql mysql> SELECT P.id, P.name -> FROM project P -> WHERE P.id IN ( -> SELECT W.proj_id -> FROM works_on W -> WHERE W.empl_id IN (7, 12) -> );
• ------+------------------+ | id | name |
• ------+------------------+ | 2003 | 홈페이지 UI 개선 |
• ------+------------------+

| 2000년대생이 없는 부서의 id와 이름을 출력하라 NOT EXISTS를 사용하면 다음과 같다.

mysql> SELECT D.id, D.name
    -> FROM department D
    -> WHERE NOT EXISTS (
    -> SELECT *
    -> FROM employee E
    -> WHERE E.dept_id = D.id AND E.birth_date >= '2000-01-01');
+------+-------------+
| id   | name        |
+------+-------------+
| 1003 | development |
| 1001 | headquater  |
| 1002 | hr          |
| 1005 | product     |
+------+-------------+

• NOT EXISTS 또한 NOT IN으로 바꿔줄 수 있다. ```sql mysql> SELECT D.id, D.name -> FROM department D -> WHERE D.id NOT IN ( -> SELECT E.dept_id -> FROM employee E -> WHERE E.birth_date >= '2000-01-01');
• ------+-------------+ | id | name |
• ------+-------------+ | 1003 | development | | 1001 | headquater | | 1002 | hr | | 1005 | product |
• ------+-------------+

ANY

• v 비교연산자 ANY (subquery) : subquery가 반환하는 결과들 중에서 단 하나라도 v와 비교 연산한 값이 true라면 true를 반환한다.

• SOME도 ANY와 같은 역할을 한다.

| 리더보다 높은 연봉을 받는 부서원을 가진 리더의 id,이름,연봉을 출력하라

mysql> SELECT E.id, E.name, E.salary
    -> FROM department D, employee E
    -> WHERE D.leader_id = E.id AND E.salary < ANY (
    -> SELECT salary
    -> FROM employee
    -> WHERE id <> D.leader_id AND dept_id = E.dept_id);
+----+--------+----------+
| id | name   | salary   |
+----+--------+----------+
|  3 | JENNY  | 50000000 |
| 13 | JISUNG | 90000000 |
+----+--------+----------+

• ANY 다음에 오는 subquery의 결과와 E.salary를 비교한다. 비교연산자에 만족하는 결과값이 하나라도 있다면 true를 반환한다.

• 위의 결과는 JENNY, JISUNG이 이끄는 부서에서 JENNY, JISUNG보다 연봉이 높은 부서원이 있다는 뜻이 된다. 그렇다면 그 부서원의 연봉이 얼마인지도 출력하려면 다음과 같다. ```sql mysql> SELECT E.id, E.name, E.salary, ( -> SELECT max(salary) -> FROM employee -> WHERE dept_id = E.dept_id -> ) AS dept_max_salary -> FROM department D, employee E -> WHERE D.leader_id = E.id AND E.salary < ANY ( -> SELECT salary -> FROM employee -> WHERE id <> D.leader_id AND dept_id = E.dept_id);

• ------+--------+----------+-----------------+ | id | name | salary | dept_max_salary |

• ------+--------+----------+-----------------+ | 3 | JENNY | 50000000 | 180000000 | | 13 | JISUNG | 90000000 | 170000000 |

• ------+--------+----------+-----------------+ ```

• select 절에도 subquery를 쓸 수 있다.

ALL

• v 비교연산자 ALL (subquery) : subquery의 결과들과 v를 비교해서 모두 참이라면 true를 반환한다.

| id가 13인 임직원과 한번도 같은 프로젝트에 참여하지 못한 임직원들의 id,이름,직군을 출력하라

mysql> SELECT DISTINCT E.id, E.name, E.position
    -> FROM employee E, works_on W
    -> WHERE E.id = W.empl_id AND W.proj_id <> ALL (
    -> SELECT proj_id
    -> FROM works_on
    -> WHERE empl_id = 13);
+----+---------+----------+
| id | name    | position |
+----+---------+----------+
|  1 | MESSI   | DEV_BACK |
|  2 | JANE    | DSGN     |
|  3 | JENNY   | DEV_BACK |
|  6 | JULIA   | CFO      |
|  7 | MINA    | DSGN     |
|  9 | HENRY   | HR       |
| 11 | SUZANNE | PO       |
| 12 | CURRY   | PLN      |
+----+---------+----------+

컴퓨터는 0, 1밖에 이해할 수 없다. 그렇다면 3+4를 컴퓨터는 어떻게 이해할까 ? 이에 대해 알아보고자 한다.

정보단위

비트(bit)

: 0과 1을 표현하는 가장 작은 정보 단위 2비트로 총 4가지의 정보를 표현할 수 있다.

00
01
10
11

• n비트로 $$2^n$$가지의 정보를 표현할 수 있다.

• 프로그램은 수많은 비트로 이루어져 있다. 다만, 표현할 때는 비트보다 더 큰 단위를 사용한다.

• 1024개씩 묶은 단위는 kiB, MiB ... 로 따로 있다. 과거에는 1024개씩 묶는 단위와 1000개씩 묶는 단위를 혼용해서 사용했지만 점차 다루는 데이터의 크기가 커지면서 24개씩의 오차가 점차 스노우볼이 굴러서 큰 오차가 되면서 문제를 발생시키게 된다. 따라서 현재에는 두 개의 단위를 혼용해서 사용하지 않는다.

워드(word)

: CPU가 한번에 처리할 수 있는 정보의 크기 단위

• 하프 워드(half word) : 워드의 절반 크기

• 풀 워드(full word) : 워드 크기

• 더블 워드(double word) : 워드의 두 배 크기

이진법

0과 1로 숫자를 표현하는 방법

이진수 표기법

0과 1로 음수 표현

2의 보수법 이용

1. 모든 0과 1을 뒤집는다.
2. 1을 더한다.

   1101
   0010
   0011 -> 2의 보수

   1101의 음수를 표현한 0011과 십진수 3을 표현한 0011을 어떻게 구분할까 ?

-> 컴퓨터는 cpu 내부의 플래그 레지스터 라는 것으로 둘을 구분한다.

16진법

• 이진법으로는 숫자의 길이가 너무 길어지기 때문에 16진법도 많이 사용한다.

• 16진법이 헷갈릴때 사용해보면 좋다.

16진수 표기법

이진수 <-> 16진수

두 진수를 변환하는 방법이 십진수로 변환하는 방법보다 훨씬 간단하다.

방법 : 이진수를 4자리씩 끊어서 16진수로 변환

0001101000101011
0001 / 1010 / 0010 / 1011
-> 1 / A / 2 / B
->1A2B

반대로 16진수는 1개씩 끊어서 2진수로 변환시키면 된다.

5D
5 -> 0101
D -> 1101
->01011101

📌0, 1로 문자를 표현하는 방법

SELECT attributes
FROM tables
WHERE conditions;

id가 9인 직원의 이름과 직군을 출력하라

mysql> SELECT name, position FROM employee WHERE id = 9;
+-------+----------+
| name  | position |
+-------+----------+
| HENRY | HR       |
+-------+----------+

• 조건 id = 9 를 selection condition 이라고 한다.

• name, position을 projection attributes 라고 한다. 조건에 맞는 tuples의 값들 중에서 projection attributes에 의해 지정된 attribute에 대응하는 값만 출력한다.

project 2002를 리딩하는 임직원의 id와 이름과 직군을 출력하라

• 2개의 테이블을 참고해서 sql 문을 만들어야 한다. ```sql mysql> SELECT employee.id, employee.name, employee.position -> FROM employee, project -> WHERE project.id = 2002 AND project.leader_id = employee.id;

• ----+--------+----------+ | id | name | position |

• ----+--------+----------+ | 13 | JISUNG | PO |

• ----+--------+----------+

• project.leader_id = employee.id를 join condition이라고 한다.

• project.id = 2002 인 튜플과 join condition으로 인해 이에 대응하느 employee 테이블의 튜플도 선택이 된다.

• 마지막으로 employee.id, employee.name, employee.position 라는 projection attributes를 통해 튜플 중 projection attributes와 대응하는 값만 출력되는 것이다.

주의사항

SELECT로 조회할 때 조건들을 포함해서 조회를 한다면 이 조건들과 관련된 attributes에 index가 걸려있어야 한다. 그렇지 않으면 데이터가 많아질수록 조회 속도가 느려지게 된다.

📌AS

테이블이름을 별칭으로 바꿀 수 있다.

mysql> SELECT E.id, E.name, E.position
    -> FROM employee AS E, project AS P
    -> WHERE P.id = 2002 AND P.leader_id = E.id;
+----+--------+----------+
| id | name   | position |
+----+--------+----------+
| 13 | JISUNG | PO       |
+----+--------+----------+

출력되는 attribute 이름을 바꿀 수 있다.

mysql> SELECT E.id AS leader_id, E.name AS leader_name, E.position
    -> FROM employee AS E, project AS P
    -> WHERE P.id = 2002 AND P.leader_id = E.id;
+-----------+-------------+----------+
| leader_id | leader_name | position |
+-----------+-------------+----------+
|        13 | JISUNG      | PO       |
+-----------+-------------+----------+

AS는 생략이 가능하다.

mysql> SELECT E.id leader_id, E.name leader_name, E.position
    -> FROM employee E, project P
    -> WHERE P.id = 2002 AND P.leader_id = E.id;
+-----------+-------------+----------+
| leader_id | leader_name | position |
+-----------+-------------+----------+
|        13 | JISUNG      | PO       |
+-----------+-------------+----------+

📌DISTINCT

직군이 디자이너인 임직원들이 참여하고 있는 프로젝트들의 id와 이름을 출력하라

• 3개의 테이블을 참고해야한다.

• employee 테이블과 project 테이블을 연결시키기 위해 works_on 테이블이 필요하다.

mysql> SELECT P.id, P.name
    -> FROM employee E, works_on W, project P
    -> WHERE E.position = 'DSGN'
    -> AND E.id = W.empl_id AND P.id = W.proj_id;
+------+------------------+
| id   | name             |
+------+------------------+
| 2003 | 홈페이지 UI 개선   |
| 2003 | 홈페이지 UI 개선   |
+------+------------------+

• SELECT 결과에서 중복되는 tuples을 제외하고 싶을때 DISTINCT를 사용한다.

mysql> SELECT DISTINCT P.id, P.name
    -> FROM employee E, works_on W, project P
    -> WHERE E.position = 'DSGN'
    -> AND E.id = W.empl_id AND P.id = W.proj_id;
+------+------------------+
| id   | name             |
+------+------------------+
| 2003 | 홈페이지 UI 개선   |
+------+------------------+

📌LIKE

이름이 N으로 시작하거나 N으로 끝나는 직원의 이름을 출력하라

mysql> SELECT name
    -> FROM employee
    -> WHERE name LIKE 'N%' OR name LIKE '%N';
+--------+
| name   |
+--------+
| BROWN  |
| NICOLE |
+--------+

• name LIKE 'N%' : 이름이 N으로 시작

• name LIKE '%N' : 이름이 N으로 끝남

이름에 NG가 포함되어있는 직원의 이름을 출력하라

mysql> SELECT name
    -> FROM employee
    -> WHERE name LIKE '%NG%';
+--------+
| name   |
+--------+
| DINGYO |
| JISUNG |
+--------+

• name LIKE '%NG%' : 이름에 NG가 포함되어 있음

이름이 J로 시작하고 4글자인 직원의 이름을 출력하라

mysql> SELECT name
    -> FROM employee
    -> WHERE name LIKE 'J___';
+------+
| name |
+------+
| JANE |
+------+

• name LIKE 'J___' : 이름이 J로 시작하고 4글자

%나 _를 문자 그대로의 의미로 사용하고 싶을땐 \%, \_ 로 앞에 \를 붙이면 된다.

mysql> SELECT name
    -> FROM project
    -> WHERE name LIKE '\%%';

• name LIKE '\%%' : %로 시작하는 project 이름

• name LIKE '%\_' : _로 끝나는 project 이름

INSERT INTO 테이블이름 VALUES (all values);

INSERT INTO 테이블이름 (attributes list) VALUES (attributes list 순서에 맞는 values);

INSERT INTO 테이블이름 VALUES (...), (...), (...);

• 맨 마지막 null 부분은 외래키에 해당하는 값이다. 아직 해당 값을 참조하는 테이블에 데이터를 추가하지 않았기 때문에 null을 추가한 것이다.

• 'employee_chk_2' 라는 제약사항을 위반했다면서 데이터가 추가되지 않았다.

• 저 제약사항이 뭔지 확인하고 싶을때 SHOW CREATE TABLE 테이블이름; 을 사용하면 된다.

  • salary가 5천만 이상이어야 하는 제약사항을 위반함

• VALUES의 마지막 값은 department 테이블의 pk인 id를 참조한 외래키이다. 그런데 department 테이블에 데이터를 아직 추가하지 않았기 때문에 111이라는 값은 존재하지 않는다. 따라서 데이터가 추가되지 않고 에러가 발생한다.

• 값을 넣을 attribute를 적고 이에 해당하는 값만 추가해줄 수 있다. attribute의 순서를 꼭 테이블 만들때 생성했던 순서로 하지 않아도 된다.

• salary의 default 값을 5천만으로 정해줬기 때문에 추가할 때 값을 넣어주지 않으면 5천만으로 자동설정된다.

• dept_id 또한 따로 추가해주지 않았기 때문에 NULL값으로 자동설정 되었다.

• 이렇게 tuple들을 한꺼번에 추가해줄수도 있다.

데이터를 추가해준 테이블들은 다음과 같다

1. department 테이블

2. employee 테이블

3. project 테이블

4. works_on 테이블

📌UPDATE(수정)

UPDATE 테이블이름
SET 수정할 값
WHERE 조건

• employee 테이블에 값을 추가해줄 당시에는 dept_id 값을 전부 null로 해줬기 때문에 update를 해줘야 한다.

• 정상적으로 dept_id가 수정이 된 것을 확인할 수 있다.

개발팀의 연봉을 2배로 늘리시오(개발팀의 dept_id는 1003)

프로젝트 ID가 2003인 프로젝트에 참여한 임직원의 연봉을 2배로 늘리시오

📌DELETE(삭제)

DELETE FROM 테이블이름
WHERE 조건

JOHN이라는 직원이 퇴사하였으니 employee 테이블에서 삭제하시오

id = 8 인 JOHN을 employee 테이블에서 삭제하려고 한다. 근데 JOHN은 프로젝트 id가 2001인 프로젝트에 참여중이다. 그러나 works_on 테이블에서 따로 삭제해줄 필요가 없다. 이유는 works_on 테이블을 생성할 때

이러한 제약사항을 설정해줬기 때문이다. on delete CASCADE는 참조한 키가 삭제되었을 때 그 키와 대응하는 empl_id도 삭제하라는 제약사항이다.

DINGYO(id = 5)는 2001, 2002, 2003 프로젝트에 참여중이다. 2001 프로젝트에만 참여하도록 하기 위해 나머지 프로젝트를 삭제하시오

• <> 는 != 이 표시와 같다. 2001을 제외한 proj_id를 모두 삭제하기 위해서 사용되었다.

컴퓨터가 이해하는 정보

데이터

• 숫자, 문자, 이미지, 동영상과 같으 정적인 정보

• 컴퓨터와 주고받은 정보 혹은 컴퓨터 내부에 저장된 정보를 데이터라고 부른다.

• 0과 1로 숫자와 문자를 표현하는 방법

명령어

컴퓨터란 명령어를 처리하는 기계

• 명령어

  • 컴퓨터를 실질적으로 움직이는 정보
  • 데이터는 명령어를 위한 일종의 재료

• 명령어의 생김새와 동작 방식

명령어란 쉽게 말해 이런 것이다.

• 1과 2를 더해라
• "안녕하세요"를 출력해라 등

컴퓨터의 4가지 핵심 부품

• 메인보드 : 4가지 핵심부품을 부착하는 곳

• 시스템 버스 : 부품들끼리 서로 정보를 주고받는 통로를 버스라고 한다. 그 중에서 사람의 척추와 같이 중요한 버스를 시스템 버스라고 한다.

  CPU

• 컴퓨터의 두뇌라고 할 수 있으며, 메모리에 저장된 명렁어를 읽어들이고, 해석하고, 실행하는 부품* CPU는 크게 ALU, 제어장치, 레지스터로 구성되어 있다.

• ALU(산술논리연산장치) : 계산기

• 레지스터 : CPU 내부의 임시 저장 장치

• 제어장치 : 제어 신호를 발생시키고, 명령어를 해석하는 장치

  • 제어 신호란 컴퓨터 부품들을 관리하고 작동시키기 위한 전기 신호이다. 대표적으로 CPU가 메모리에 저장된 값을 읽고 싶을 때 메모리에 "메모리 읽기"라는 제어 신호를, 메모리에 값을 저장할고 싶을 때 메모리에 "메모리 쓰기"라는 제어 신호를 보낸다.

    메모리(주기억장치, RAM)

• 현재 실행되는 프로그램(프로세스)의 명령어와 데이터를 저장하는 부품* 메모리에는 주소라는 개념이 있다. 이 주소를 통해서 내가 원하는 명령어 혹은 데이터가 메모리의 어디에 위치해있는지 알 수 있다.

• 프로그램이 실행되기 위해서는 메모리에 저장되어 있어야 한다.

• 메모리는 실행되는 프로그램의 명령어와 데이터를 저장한다.

• 메모리에 저장된 값의 위치는 주소를 통해 알 수 있다.

  보조기억장치

• 전원이 꺼져도 보관될 프로그램을 저장하는 부품* 메모리는 전원이 꺼지면 저장된 내용을 다 잃어버리는 휘발성 저장 장치이다. 그래서 등장한 것이 전원이 공급안되도 정보를 저장하는 보조기억장치이다. SSD, HDD 등이 있다.

-> 메모리는 실행할 정보를 저장하고 보조기억장치는 보관할 정보를 저장한다.

입출력장치

컴퓨터 외부와 연결되어 컴퓨터 내부와 정보를 교환할 수 있는 부품

메인보드와 시스템 버스

• 메인보드에 연결된 부품을 버스를 통해 정보를 주고 받는다.

• 버스는 컴퓨터의 부품끼리 정보를 주고 받는 일종의 통로이다.

• 다양한 종류의 버스가 있는데 컴퓨터의 핵심 부품을 연결하는 중요한 버스를 시스템 버스라고 한다.

시스템 버스

시스템 버스 내부 구성

주소 버스

주소를 주고받는 통로

데이터 버스

명령어와 데이터를 주고받는 통로

제어 버스

제어 신호를 주고받는 통로

메모리 값 읽기

메모리 값 쓰기

SQL

• Structured Query Language

• 현업에서 쓰이는 relational DBMS의 표준 언어

• 종합적인 database 언어 : DDL + DML + VDL

SQL 주요 용어

SQL에서 relation

• multiset of tuples. 즉, 중복된 tuple을 허용한다.

SQL & RDBMS

SQL은 RDBMS의 표준 언어이지만 실제 구현에 강제가 없기 때문에 RDMBS마다 제공하는 SQL의 스펙이 조금씩 다르다. 예를 들면, MySQL과 ORACLE에서 사용하는 SQL의 문법이 조금씩 다르다.

📌SQL로 DB 정의

MySQL을 통해 IT 회사 관련 DB를 만들면서 실습을 진행하겠다.

DATABASE vs SCHEMA

• MySQL에서는 DATABASE와 SCHEMA가 같은 뜻을 의미한다.

• CREATE DATABASE company = CREATE SCHEMA company

• 다른 RDBMS에서는 의미가 다르게 쓰인다.

DB 만들기

- CREATE DATABASE company; : database 만들기

• SHOW DATABASES; : 내 mysql에 존재하는 database 목록을 보여준다.
• DROP DATABASE company; : database 삭제
• USE company; : 사용할 database 선택
• SELECT database(); : 어떤 database가 활성화되어 있는지 알려준다.

attribute data type

숫자

문자열

날짜와 시간

그 외

table 만들기

company DB 스키마

• 위의 스키마를 참고하여 테이블을 생성할 수 있다.

• 컬럼에 밑줄이 그어진건 primary key라는 뜻이다.

  테이블 생성 SQL문

  department table

  

  employee table

  

  project table

  

  works_on table

  

key constraints

PRIMARY KEY

• table의 tuple을 식별하기 위해 사용. 하나 이상의 attribute로 구성
• 중복된 값은 가질 수 없으며, NULL 값도 가질 수 없다.
• 선언 방법

UNIQUE

• UNIQUE로 지정된 attribute는 중복된 값을 가질 수 없다.
• 단, NULL은 중복을 허용할 수 있다.(RDBMS마다 다른데 MySQL은 가능)
• 선언 방법

NOT NULL

• attribute가 NOT NULL로 지정되면 해당 attribute는 NULL 값을 가질 수 없다.
• 선언 방법
• 보통 NOT NULL과 UNIQUE를 같이 많이 쓴다.

attribute DEFAULT

• attribute의 default 값을 정의할 때 사용한다.
• 새로운 tuple을 저장할 때 해당 attribute에 대한 값이 없다면 default 값으로 저장된다.
• 선언 방법

CHECK

• attribute의 값을 제한하고 싶을 때 사용

• 선언 방법

• MySQL 에서는 RESTRICT와 NO ACTION은 동일한 기능을 수행한다.(참조값 삭제/변경 금지)

• MySQL 에서는 SET DEFAULT를 제대로 지원하지 않는다.

FOREIGN KEY

• attribute가 다른 table의 primary key나 unique key를 참조할 때 사용
• 선언 방법

constraint 이름 명시하기

• 이름을 붙이면 어떤 constraint를 위반했는지 쉽게 파악할 수 있다.
• constraint를 삭제하고 싶을 때 해당 이름으로 삭제할 수 있다.
• 선언 방법

department에 외래키 추가

• 처음 departmet 테이블을 만들 때는 leader_id를 참조할 employee 테이블이 생성되지 않았기 때문에 나중에 외래키를 추가해주었다.

ALTER TABLE

• table의 schema를 변경하고 싶을 때 사용한다.

• 사용 방법

• 이미 서비스 중인 table의 schema를 변경하는 것은 위험부담이 크다. 따라서, 변경 작업 때문에 서비스의 백엔드에 어떤 영향을 줄지 충분히 검토한 후에 변경해야한다.

DROP TABLE

• table을 삭제할 때 사용
• DROP TABLE 테이블이름;

db 구조 정의시 중요한 점

만들려는 서비스의 스펙과 데이터 일관성, 편의성, 확장성 등을 종합적을 고려하여 DB 스키마를 적절하게 정의하는 것이 중요하다.

• 위의 표 전체를 relation 혹은 table이라고 한다.

• 추상적인 의미에서의 relation이 아니라 실제 데이터인 tuple들만의 집합을 relation(or relation state)이라고도 부른다.

주요 개념

NULL의 의미 1.값이 존재하지 않는다.
2. 값이 존재하나 아직 그 값이 무엇인지 알지 못한다.
3. 해당 사항과 관련이 없다.

• 봉준호의 toeic_score가 NULL인 이유는 1. 아직 토익을 안봐서 값이 존재하지 않을 수 있고 2. 토익을 봤지만 아직 테이블에 수정이 안되서 그 값을 알지 못할 수 있다.

• 홍상수와 박찬욱의 before_uni 값이 NULL인 이유는 해당 attribute는 편입하기 전의 대학교에 관련된 값인데 두 사람 모두 편입한게 아니기 때문에 해당 attribute와 관련이 없기 때문이다.

relation schema

• relation의 구조를 나타낸다.

• relation의 이름과 attributes 리스트로 표기된다.

  • ex) STUDENT(id, name, grade, major, phone_num, emer_phone_num)

• attributes와 관련된 constraints(제약사항)도 포함한다.

degree of a relation

• relation schema에서 attributes의 수를 말한다.

• ex) STUDENT(id, name, grade, major, phone_num, emer_phone_num)

• degree(차수)는 6이다.

relational database

• relational data model에 기반하여 구조화된 database

• relational database는 여러 개의 relations로 구성된다.

relational database schema

• relation schemas set + integrity constraints set

📌relation의 특징들

relation은 중복된 tuple을 가질 수 없다.

relation의 tuple을 식별하기 위해 attribute의 부분 집합을 key로 설정한다.

relation에서 tuple의 순서는 중요하지 않다.

• tuple의 순서가 바뀌어도 테이블의 의미나 데이터에 변화가 생기지 않는다.

하나의 relation에서 attribute의 이름은 중복되면 안된다.

하나의 tuple에서 attribute의 순서는 중요하지 않다.

attribute는 atomic(더 이상 나누어질 수 없는) 해야 한다.

📌keys

super key

: relation에서 tuples를 unique하게 식별할 수 있는 attributes set

PLAYER(id, name, team_id, back_number, birth_date)의 super key는

1. {id, name, team_id, back_number, birth_date}
2. {id, name}
3. {name, team_id, back_number} 등이 있다.

candidate key

: 어느 한 attribute라도 제거하면 unique하게 tuples를 식별할 수 없는 super key. minimal super key라고도 한다.

PLAYER(id, name, team_id, back_number, birth_date)의 candidate key는

1. {id}
2. {team_id, back_number}

-> {team_id, back_number} 에서 team_id를 제거하면 back_number(등번호)는 다른 팀의 선수와 중복이 될 수 있다.

primary key

: relation에서 tuples를 unique하게 식별하기 위해 **선택된 candidate key**

PLAYER(id, name, team_id, back_number, birth_date)의 primary key는

1. {id}
2. {team_id, back_number}

-> 보통 primary key를 고를땐 attribute가 가장 적은 candidate key를 선택한다.

unique key(alternate key)

: primary key가 아닌 candidate keys. alternate key라고도 한다.

PLAYER(id(PK), name, team_id, back_number, birth_date)의 unique key는 {team_id, back_number} 이다.

foreign key

: 다른 relation의 PK를 참조하는 attributes set

PLAYER(id(PK), name, team_id, back_number, birth_date) TEAM(id(PK), name, manager) 가 있을 때 foreign key는 PLAYER의 {team_id} 이다.

📌contraints

: relational database의 relation들이 언제나 항상 지켜줘야 하는 제약 사항

implicit constraints

: relational data model 자체가 가지는 constraints

• "relation은 중복되는 tuple을 가질 수 없다."
• "relation 내에서는 같은 이름의 attribute를 가질수 없다." 등이 있다.

explicit constraints

: 주로 DDL을 통해 schema에 직접 명시할 수 있는 constraints

• schema-based constraints라고도 한다.

여러 종류의 explicit constraints가 있다.

domain constraints

: attribute의 value는 해당 attribute의 domain에 속한 value여야 한다.

• 학년을 의미하는 grade에는 1~4까지의 숫자만 올 수 있고 100이라는 숫자는 올 수 없다.

key constraints

: 서로 다른 tuples는 같은 value의 key를 가질 수 없다.

• 같은 value의 PK를 가질 수 없다.

NULL value constraints

: attribute가 NOT NULL로 명시됐다면 NULL 값을 가질 수 없다.

entity integrity constraints

: primary key는 value에 NULL을 가질 수 없다.

• PK는 tuples를 unique하게 식별하는 key이기 때문에 NULL 값이 들어가게 된다면 식별할 수 없게 된다. 따라서 PK에는 NULL 값을 가질 수 없다.

referential integrity constraints

: FK와 참조하는 테이블의 PK는 도메인이 같아야하고 PK에 없는 values를 FK가 가질 수 없다.

• TEAM 테이블의 id(PK)를 참조한 PLAYER 테이블의 team_id(FK)가 있다고 했을 때 team_id에는 TEAM.id에 없는 값을 가질 수 없다.

• 단, NULL 값은 가질 수 있는데 김민재 선수가 현재 소속팀이 없는 경우가 있을 수 있기 때문이다.

DB(database)

: 전자적으로 저장되고 사용되는 관련있는 데이터들의 조직화된 집합

• 같은 목적이나 같은 출처를 가진 데이터, 같은 서비스 아래에 있는 데이터들을 관련있는 데이터라고 한다.
• 조직화된 집합이란 데이터들을 체계적으로 정리하여 검색 및 조회를 빠르게 하고 데이터의 중복 또는 불일치를 막을 수 있음을 의미한다.

DBMS

: database management systmes의 약자. 사용자에게 DB를 정의하고 만들고 관리하는 기능을 제공하는 소프트웨어 시스템

• MySQL, ORACLE, SQL Server 등이 대표적인 프로그램이다.

metadata : DB를 정의하기 위한 부가적인 데이터

• metadata는 database를 정의하거나 기술하는 data로써 catalog 라고도 부른다.

• catalog는 metadata가 저장되어 있는 장소로 불리기도 한다.

• metadata로는 데이터 유형, 구조, 제약 조건, 보안, 인덱스, 사용자 그룹 등이 있다.

• metadata 또한 DBMS를 통해 저장/관리 된다.

DB System

: database + DBMS + 연관된 applications 줄여서 database라고도 부르기 때문에 문맥에 따라 순수한 데이터의 집합으로써의 database를 의미하는 것인지 아니면 DB System을 의미하는 것인지 잘 파악해야한다.

-간단한 DB System 동작 구조

📌data models

: DB의 구조(structure)를 기술하는데 사용되는 개념들이 모인 집합

• DB 구조를 추상화해서 표현할 수 있는 수단을 제공한다.
  • DB 구조 : 데이터 유형, 데이터 관계(relationship), 제약 사항(constraints) 등
• data model은 여러 종류가 있으며 추상화 수준과 DB 구조화 방식이 조금씩 다르다.
• DB에서 읽고 쓰기 위한 기본적인 동작(operations)들도 포함한다.

data models 분류

conceptual(high-level) data models

• 일반 사용자들이 쉽게 이해할 수 있는 개념들로 이루어진 모델

• 추상화 수준이 가장 높음

• 비즈니스 요구 사항을 추상화하여 기술할 때 사용

• ERD(entitiy-relationship diagram)가 대표적인 예이다.

  logical(representational) data models

• 이해하기 어렵지 않으면서도 디테일하게 DB를 구조화할 수 있는 개념들을 제공

• 데이터가 컴퓨터에 저장될 때의 구조와 크게 다르지 않게 DB 구조화를 가능하게 함

• 특정 DBMS나 storage에 종속되지 않는 수준에서 DB를 구조화할 수 있는 모델

• relational data model에 대표적인 예이고 백엔드 개발자들이 가장 많이 사용하는 모델이다.

physical(low-level) data models

• 컴퓨터에 데이터가 어떻게 파일 형태로 저장되느지를 기술할 수 있는 수단을 제공

• data format, data orderings, access path 등

  • access path : 데이터 검색을 빠르게 하기 위한 구조체(ex) index)

📌schema & state

schema(스키마)

• data model을 바탕으로 database의 구조를 기술한 것

• schema는 database를 설계할 때 정해지며 한번 정해진 후에는 자주 바뀌지 않는다.

• database schema의 예시

• student, book 데이터와 그 속성 등을 기술한 것으로 이를 통해 database의 구조를 알 수 있다.

state

• database에 있는 실제 데이터는 꽤 자주 바뀔 수 있다.

• database에 있는 현재 instances의 집합이라고도 한다.

• 시간이 지나면서 데이터가 삭제, 수정 등의 변화가 일어난다. 이때 특정 시점의 데이터를 database state 혹은 snapshot이라고 한다.

three-schema architecture

• database system을 구축하는 architecture 중 하나

• user application으로부터 물리적인 database를 분리시키는 목적

  • 물리적인 database는 조금씩 변경될 수 있다. 이럴때에도 database를 직접 사용하는 user application은 변경에 영향을 주지 않기 위함이다.

• 세 가지 level이 존재하며 각각의 level마다 schema가 정의되어 있다.

internal schema at internal level

• database와 가장 가까이 있는 스키마

• 물리적으로 데이터가 어떻게 저장되는지 physical data model을 통해 표현된다.

• datga storage, data structure, access path 등 실체가 있는 내용을 기술한다.

  external(or user views) schema at external(or view) level

• 실제 사용자가 바라보는 스키마기 때문에 user views 라고도 불린다.

• 특정 유저들이 필요로 하는 데이터만 표현하고 그 외 알려줄 필요가 없는 데이터는 숨긴다.

• logical data model을 통해 표현된다.

  conceptual schema at conceptual level

• 처음 database 설계 시에는 위의 2개 스키마밖에 없었다. 이에 따라 유저마다 다른 요구를 하게 되면 internal schema에 중복되는 데이터가 쌓이게 되고 관리가 힘들어지게 되었다. 이를 해결하기 위해 나온 것이 conceptual schema 이다.

• internal schema를 한번 추상화시킨 스키마라고 할 수 있으며 따라서 물리적인 저장 구조에 관한 내용은 숨긴다.

• 대신 논리적으로 전체 database에 대한 구조를 기술한다. entities, data types, relationships, constraints(제약사항) 등에 집중해서 논리적으로 표현한 것이 conceptual schema 이다.

• logical data model을 통해 표현된다.

결론

• 각 레벨을 독립시켜서 어느 레벨에서의 변화가 상위 레벨에 영향을 주지 않기 위함이다.

• 가령 internal schema의 내용이 변경되어도 conceptual schema를 수정할 필요가 없고 이 둘 사이의 매핑만 변경해주면 된다.

• 다만, 대부분의 DBMS가 three level을 완벽하게 혹은 명시적으로 나누지는 않는다.

• 각각의 스키마는 database의 구조를 표현하는 것이고 실제 데이터가 존재하는 곳은 internal level이다.

📌database language

아래의 명령어들을 통합한 relational database language를 SQL이라고 한다.

DDL, SDL, VDL

DDL : Data Definition Language. conceptual schema를 정의하기 위해 사용되는 명령어

• 테이블과 같은 데이터 구조를 정의하는데 사용되는 명령어들로 (생성, 변경, 삭제, 이름변경) 데이터 구조와 관련된 명령어들을 말한다.

SDL : Storage Definition Language. internal schema를 정의하는 위해 사용되는 명령어

• 하지만 요즘 relational DBMS에서는 SDL은 거의 사용하지 않고 파라미터 등의 설정으로 대체되었다.

VDL : View Definition Language. external schema를 정의하기 위해 사용되는 명령어

• 하지만 대부분의 DBMS에서는 DDL이 VDL의 역할까지 수행한다.

결국 definition language는 대부분 DDL로만 작성한다.

DML

: Data Manipulation Language. database에 있는 실제 data를 활용하기 위한 명령어

• data 추가, 삭제, 수정, 검색 등의 기능을 제공한다.

DCL

: Data Control Language. database에 접근하고 객체들을 사용하도록 권한을 주고 회수하는 명령어

TCL

Transaction Control Language. 논리적인 작업의 단위를 묶어서 DML에 의해 조작된 결과를 작업단위(트랜잭션) 별로 제어하는 명령어

입력 받은 숫자 int[] 배열로 저장

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

int[] input = Arrays.stream(br.readLine().split(" "))
                    .mapToInt(Integer::parseInt)
                    .toArray();

• 1 2 입력받았을 때 input[0] = 1, input[1] = 2 저장

ArrayList<Integer> -> int[]

ArrayList<Integer> list = new ArrayList<>();

int[] arr = list.stream()
                .mapToInt(d -> d)
                .toArray();
또는
int[] arr = list.stream()
                .mapToInt(Integer::intValue)
                .toArray();

T 타입 객체의 래퍼 클래스

public final class Optional<T> {
    // T타입 참조변수 -> 모든 종류의 객체 저장 가능(null 까지)
    private final T value; 
    ...
}

• T value : T 타입의 참조변수로써 null 포함 모든 종류의 객체를 저장할 수 있다.

• null을 간접적으로 다루기 위해 사용한다.

  • null을 직접 다루게 되면 NullPointerException이 발생할 위험이 있는데 이를 방지할 수 있다.
  • null 체크를 위한 if문 작성으로 지저분해질 수 있는 코드를 간결하게 할 수 있다.

Optional<T> 객체 생성하기

Optional<T> 객체를 생성하는 방법

String str = "abc";
Optional<String> optStr = Optional.of(str);
Optional<String> optStr = Optional.of("abc");
Optional<String> optStr = Optional.ofNullable(null); // null을 저장할 때 사용

null 대신 빈 Optional<T> 객체를 사용

Optional<String> optVal = null; // 가능은 하나 바람직하지 않음
Optional<String> optStrVal = Optional.empty();

Optional<T> 객체의 값 가져오기

Optional<String> optVal = Optional.of("abc");

// optVal에 저장된 값을 반환. null이면 예외 발생 -> 잘 쓰지 않음
String str1 = optVal.get();

// optVal에 저장된 값을 반환. null이면 "" 반환
String str2 = optVal.orElse("");

// optVal에 저장된 값을 반환. null이면 new String 객체 반환 
String str3 = optVal.orElseGet(String::new);
// 람다식으로도 가능
String str3 = optVal.orElseGet(() -> new String());

// optVal에 저장된 값을 반환. null이면 예외 발생
String str4 = optVal.orElseThrow(NullPointerException::new);

isPresent(), ifPresent()

boolean isPresent() Optional 객체의 값이 null이면 false, 아니면 true 반환

String str = "abc";
if(Optional.ofNullable(str).isPresent()) {
    System.out.println(str);
}

abc

• Optional 객체의 값이 null이 아닐 때 작업 수행

void ifPresnet(Consumer<T> action) Optional 객체의 값이 null이 아닐 때 ifPresent() 괄호 안의 람다식 수행

String str = "abc";
Optional.ofNullable(str).ifPresent(System.out::println);

abc

OptionalInt, OptionalLong, OptionalDouble

기본형 값을 감싸는 래퍼 클래스

public final class OptionalInt {
    private final boolean isPresent;
    private final int value;
    ...
}    

• isPresent : 값이 저장되어 있으면 true 반환
• value : int 타입의 변수

OptionalInt의 값 가져오기

빈 OptionalInt 객체와 비교

OptionalInt optInt1 = OptionalInt.of(0); // 0을 저장
OptionalInt optInt2 = OptionalInt.empty(); // 빈 객체 생성

System.out.println(optInt1.isPresent()); // true
System.out.println(optInt2.isPresent()); // false

System.out.println(optInt1.getAsInt()); // 0
System.out.println(optInt2.getAsInt()); // 에러

System.out.println(optInt1.equals(optInt2)); // false

• 0을 저장한 OptionalInt와 빈 객체를 생성해서 초기값이 0으로 저장된 OptionalInt를 구분하기 위해 isPresent()를 사용한다.

📌최종 연산

: 연산 결과가 스트림이 아닌 연산. 스트림의 요소를 소모하기 때문에 단 한번만 수행 가능

최종 연산 메서드

forEach()

스트림의 모든 요소에 지정된 작업을 수행

void forEach(Consumer<? super T> action)
void forEachOrdered(Consumer<? super T> action)

• forEachOrdered() 병렬 스트림일 경우에도 순서가 보장된다.

  // 직렬 스트림, forEach() -> 순서 보장 O
  IntStream.rangeClosed(1,10).forEach(System.out::print);
  System.out.println();
  // 병렬 스트림, forEach() -> 순서 보장 X
  IntStream.rangeClosed(1,10).parallel().forEach(System.out::print);
  System.out.println();
  // 병렬 스트림, forEachOrdered() -> 순서 보장 O
  IntStream.rangeClosed(1,10).parallel().forEachOrdered(System.out::print);

  12345678910 76395128104 12345678910

allMatch(), anyMatch(), noneMatch()

스트리의 요소를 조건 검사해서 boolean 타입 반환

boolean allMatch(Predicate<? super T> Predicate)
boolean anyMatch(Predicate<? super T> Predicate)
boolean noneMatch(Predicate<? super T> Predicate) // allMatch와 반대

• allMatch() : 모든 요소가 조건을 만족하면 true
• anyMatch() : 한 요소라도 조건을 만족하면 true
• noneMatch() : 모든 요소가 조건을 만족하지 않으면 true

findFirst(), findAny()

조건에 일치하는 요소 반환. 보통 중간 연산인 filter()와 같이 사용

Optional<T> findFirst()
Optional<T> findAny()

Optional<Student> result = stuStream.filter( s -> s.getTotalScore() <= 100).findFirst();
Optional<Student> result = stuStream.parallel().filter( s -> s.getTotalScore() <= 100).findAny();

• 결과가 null일수도 있기 때문에 반환타입이 Optional<T> 이다.

• findFirst() : 직렬 스트림에서 사용. filter()의 조건을 만족하는 요소 중 첫 번째 요소를 반환

• findAny() : 병렬 스트림에서 사용. filter()의 조건을 만족하는 요소 중 아무거나 하나를 반환

reduce()

스트림의 요소를 하나씩 줄여가면서 누적 연산(accumulator) 수행

Optional<T> reduce(BinaryOperator<T> accumulator)
T reduce(T identity, BinaryOperator<T> accumulator)
U reduce(U identity, BiFunction<U,T,U> accumulator, BinaryOperator<U> combiner)
// identity : 초기값
// accumulator : 이전 연산 결과와 스트림의 요소에 수행할 연산
// combiner : 병렬 처리된 결과를 합치는데 사용할 연산(병렬 스트림)

Optional<T> reduce()와 T reduce() 이 두 메서드는 초기값의 유무가 차이날 뿐 같은 기능을 한다. 그런데 만약, 비어있는 스트림의 경우 T reduce()은 초기값을 반환한다. 그래서 초기값의 반환타입과 reduce()의 반환타입이 T로 같은 것이다. 그러나 Optional<T> reduce()는 초기값이 없어 반환값이 null이 되기 때문에 반환타입이 Optional<T>인 것이다.

최종 연산인 count(), sum(), max(), min() 등을 reduce를 활용해 구현할 수 있다.

IntStream intStream = IntStream.of(1, 4, 2, 11, 3);
int count = intStream.reduce(0, (a, b) -> a + 1);

intStream = IntStream.of(1, 4, 2, 11, 3);
int sum = intStream.reduce(0, (a, b) -> a + b);

intStream = IntStream.of(1, 4, 2, 11, 3);
int max = intStream.reduce(Integer.MIN_VALUE, (a, b) -> a > b ? a : b);

intStream = IntStream.of(1, 4, 2, 11, 3);
int min = intStream.reduce(Integer.MAX_VALUE, (a, b) -> a > b ? b : a);

System.out.printf("%d, %d, %d, %d", count, sum1, max, min);

5, 21, 11, 1

실습예제

import java.util.*;
import java.util.stream.*;

class Ex14_9 {
    public static void main(String[] args) {
        String[] strArr = {
                "Inheritance", "Java", "Lambda", "stream",
                "OptionalDouble", "IntStream", "count", "sum"
        };
        // 빈 문자열을 하나도 가지고 있지 않다면 true 반환
        boolean noEmptyStr = Stream.of(strArr).noneMatch(s -> s.length() == 0);
        // s로 시작하는 문자열 중 첫 번째 요소를 반환
        Optional<String> sWord = Stream.of(strArr)
                .filter(s -> s.charAt(0) == 's').findFirst();

        System.out.println("noEmptyStr = " + noEmptyStr);
        // s로 시작하는 문자열이 없다면 문구 출력
        System.out.println("sWord = " + sWord.orElse("s로 시작하는 단어가 없습니다."));

        // Stream<String[]>을 IntStream으로 변환
        Stream.of(strArr).mapToInt(String::length).forEach(s -> System.out.print(s + " "));
        System.out.println();

        IntStream intStream1 = Stream.of(strArr).mapToInt(String::length);
        int count = intStream1.reduce(0, (a, b) -> a + 1);

        IntStream intStream2 = Stream.of(strArr).mapToInt(String::length);
        int sum = intStream2.reduce(0, Integer::sum);
//        int sum = intStream2.reduce(0, (a, b) -> a + b); // 람다식

        // 초기값을 설정안하면 반환타입은 OptionalInt로 설정해줘야 한다.
        IntStream intStream3 = Stream.of(strArr).mapToInt(String::length);
        OptionalInt max = intStream3.reduce(Integer::max);
//        OptionalInt max = intStream3.reduce((a,b)-> a > b ? a : b); // 람다식

        IntStream intStream4 = Stream.of(strArr).mapToInt(String::length);
        OptionalInt min = intStream4.reduce(Integer::min);
//        OptionalInt min = intStream4.reduce((a,b)-> a > b ? b : a); // 람다식

        System.out.println("count = " + count);
        System.out.println("sum = " + sum);
        System.out.println("max = " + max.orElse(0));
        System.out.println("min = " + min.orElse(0));
    }
}

noEmptyStr = true sWord = stream 11 4 6 6 14 9 5 3 count = 8 sum = 58 max = 14 min = 3

• IntStream intStream1 = Stream.of(strArr).mapToInt(String::length); : String[] 배열의 각 요소의 길이를 IntStream으로 변환할 때 mapToInt 사용

• OptionalInt max = intStream3.reduce(Integer::max); : 초기값을 설정안하면 반환타입은 Optional 타입으로 해줘야 한다.

• reduce((a,b)-> a > b ? a : b) 이 람다식을 reduce(Integer::max) 변경 가능

collect()와 Collectors

collect()는 Collector를 매개변수로 하는 스트림의 최종 연산

R collect(Collector<T,A,R> collector) // Collector를 구현한 클래스의 객체를 매개변수로 지정
R collect(Supplier<R> supplier, BiConsumer<R,T> accumulator, BiConsumer<R,R> combiner) // 잘 안쓰임

Collector는 수집(collect)에 필요한 메서드를 정의해 놓은 인터페이스

// T(요소)를 A에 누적한 다음, 결과를 R로 변환해서 반환
public interface Collector<T, A, R> {
    // 누적할 곳 
    Supplier<A> supplier(); // StringBuilder::new
    // 누적 방법 
    BiConsumer<A, T> accumulator(); // (sb, s) -> sb.append(s)
    // 결합 방법(병렬) 
    BinaryOperator<A> combiner(); // (sb1, sb2) -> sb1.append(sb2)
    // 최종 변환 (R타입으로) 
    Function<A, R> finisher(); // sb -> sb.toString()

    // 컬렉터 특성의 담긴 Set 반환
    Set<Characteristics> characteristics() ; 
    ...
}

Collectors 클래스는 다양한 기능의 컬렉터(Collector를 구현한 클래스)를 제공

toList(), toSet(), toMap(), toCollection()

: 스트림을 컬렉션으로 변환

Stream<Student> studentStream = Stream.of(
        new Student("이빛나", 3, 300),
        new Student("김자바", 1, 200),
        new Student("안정호", 2, 100),
        new Student("박코딩", 2, 150),
        new Student("최자연", 1, 200),
        new Student("연보라", 3, 290),
        new Student("정나라", 3, 180)
);

List<String> list = studentStream
        .map(Student::getName)
        .collect(Collectors.toList());
System.out.println(list);

[이빛나, 김자바, 안정호, 박코딩, 최자연, 연보라, 정나라]

• studentStream의 이름을 List로 변환

ArrayList<Integer> arrayList = studentStream
        .map(Student::getTotalScore)
        .sorted()
        .collect(Collectors.toCollection(ArrayList::new));
System.out.println(arrayList);

[100, 150, 180, 200, 200, 290, 300]

• ArrayList로 변환하고 싶을 때 .collect(Collectors.toCollection(ArrayList::new)); 사용

Map<String, Student> map = studentStream
        .collect(Collectors.toMap(Student::getName, p -> p));
System.out.println(map);

{박코딩=[박코딩, 2, 150], 김자바=[김자바, 1, 200], 이빛나=[이빛나, 3, 300], 안정호=[안정호, 2, 100], 연보라=[연보라, 3, 290], 최자연=[최자연, 1, 200], 정나라=[정나라, 3, 180]}

• 이름을 key로 하고 Student 객체를 value로 하는 map으로 변환
• p -> p는 항등함수로 입력한 변수가 그대로 출력된다.

toArray()

스트림을 배열로 변환

Student[] students = studentStream.toArray(Student[]::new);
System.out.println(Arrays.toString(students));

[[이빛나, 3, 300], [김자바, 1, 200], [안정호, 2, 100], [박코딩, 2, 150], [최자연, 1, 200], [연보라, 3, 290], [정나라, 3, 180]]

counting(), summingInt(), maxBy(), minBy()

스트림의 통계 정보를 제공

long count = studentStream.count();
long count = studentStream.collect(Collectors.counting());

• 똑같이 studentStream의 요소 개수를 반환한다. 그러나 count()는 전체 요소만 카운팅할 수 있지만 collect(Collectors.counting())은 그룹별로 나눠서 카운팅할 수 있다.

long totalScore = studentStream.mapToInt(Student::getTotalScore).sum();
long totalScore = studentStream.collect(Collectors.summingInt(Student::getTotalScore));

Optional<Student> topStudent = studentStream
        .max(Comparator.comparingInt(Student::getTotalScore));
Optional<Student> topStudent = studentStream
        .collect(Collectors.maxBy(Comparator.comparingInt(Student::getTotalScore)));

• summingInt(), maxBy(), minBy() 모두 기능은 기존 sum(), max(), min()과 동일하지만 그룹별로 나눠서 작업을 수행할 수 있다.

reducing()

reduce()는 전체만 리듀싱할 수 있지만 reducing()은 그룹별로 나눠서 리듀싱 할 수 있다.

IntStream intStream = Arrays.stream(new int[]{1, 2, 3, 4, 5});

long sum = intStream.reduce(0, (a, b) -> a + b);
long sum = intStream.boxed().collect(Collectors.reducing(0, (a, b) -> a + b));

joining()

문자열 스트림의 요소를 모두 연결

String strName = studentStream
        .map(Student::getName)
        .collect(Collectors.joining(","));
System.out.println(strName);

이빛나,김자바,안정호,박코딩,최자연,연보라,정나라

• map()으로 이름을 뽑아내고 joining(",")을 통해 , 구분자로 해서 이름을 나열하는 String 문자열을 생성

String strName = studentStream
        .map(Student::getName)
        .collect(Collectors.joining(",", "[", "]"));
System.out.println(strName);

[이빛나,김자바,안정호,박코딩,최자연,연보라,정나라]

• joining(",", "[", "]") : ,를 구분자로 하고 문자열의 처음과 끝에 [, ] 추가

그룹화 & 분할

partitioningBy() : 스트림을 2분할 한다.

Collector partitioningBy(Predicate predicate)
Collector partitioningBy(Predicate predicate, Collector downstream)

• 괄호 안에 조건식을 넣어서 Map의 key를 true/false로 하고 조건식을 만족하는 값을 true의 value 값으로 저장한다.

  실습예제

  import java.util.*;
  import java.util.stream.*;
  

import static java.util.stream.Collectors.; import static java.util.Comparator.;

- `Collectors.partitioningBy` -> `partitioningBy` 으로 축약
- `Comparator.comparing` -> `comparing` 으로 축약

```java
class Student2 {
    String name;
    boolean isMale;
    int hak;
    int ban;
    int score;

    Student2(String name, boolean isMale, int hak, int ban, int score) {
        this.name = name;
        this.isMale = isMale;
        this.hak = hak;
        this.ban = ban;
        this.score = score;
    }

    String getName() { return name; }
    boolean isMale() { return isMale; }
    int getHak() { return hak; }
    int getBan() { return ban; }
    int getScore() { return score; }

    public String toString() {
        return String.format("[%s, %s, %d학년 %d반, %3d점]",
                name, isMale ? "남" : "여", hak, ban, score);
    }
}

• Student2 변수, 생성자, getter 정의
• toString() 오버라이딩

class Ex14_10 {
    public static void main(String[] args) {
        Student2[] stuArr = {
                new Student2("김코딩", true, 1, 1, 300),
                new Student2("정수민", false, 1, 1, 250),
                new Student2("오정호", true, 1, 1, 200),
                new Student2("김선미", false, 1, 2, 150),
                new Student2("정주일", true, 1, 2, 100),
                new Student2("이효리", false, 1, 2, 50),
                new Student2("이정현", false, 1, 3, 100),
                new Student2("유정선", false, 1, 3, 150),
                new Student2("강호동", true, 1, 3, 200),
                new Student2("이수근", true, 2, 1, 300),
                new Student2("김미희", false, 2, 1, 250),
                new Student2("최시원", true, 2, 1, 200),
                new Student2("박지원", false, 2, 2, 150),
                new Student2("안세훈", true, 2, 2, 100),
                new Student2("오채원", false, 2, 2, 50),
                new Student2("임희민", false, 2, 3, 100),
                new Student2("홍은채", false, 2, 3, 150),
                new Student2("신정우", true, 2, 3, 200)
        };

• Student2 객체들을 정의하고 Student2[] 배열로 저장

        System.out.printf("1. 단순분할(성별로 분할)%n");
        Map<Boolean, List<Student2>> stuBySex = Stream.of(stuArr)
                .collect(partitioningBy(Student2::isMale));

        List<Student2> maleStudent = stuBySex.get(true);
        List<Student2> femaleStudent = stuBySex.get(false);

        for (Student2 s : maleStudent) System.out.println(s);
        for (Student2 s : femaleStudent) System.out.println(s);

1. 단순분할(성별로 분할) [김코딩, 남, 1학년 1반, 300점]ㅤ [오정호, 남, 1학년 1반, 200점]ㅤ [정주일, 남, 1학년 2반, 100점]ㅤ [강호동, 남, 1학년 3반, 200점]ㅤ [이수근, 남, 2학년 1반, 300점]ㅤ [최시원, 남, 2학년 1반, 200점]ㅤ [안세훈, 남, 2학년 2반, 100점]ㅤ [신정우, 남, 2학년 3반, 200점]ㅤ [정수민, 여, 1학년 1반, 250점]ㅤ [김선미, 여, 1학년 2반, 150점]ㅤ [이효리, 여, 1학년 2반, 50점]ㅤ [이정현, 여, 1학년 3반, 100점]ㅤ [유정선, 여, 1학년 3반, 150점]ㅤ [김미희, 여, 2학년 1반, 250점]ㅤ [박지원, 여, 2학년 2반, 150점]ㅤ [오채원, 여, 2학년 2반, 50점]ㅤ [임희민, 여, 2학년 3반, 100점]ㅤ [홍은채, 여, 2학년 3반, 150점]ㅤ

• partitioningBy(Student2::isMale)를 통해 성별로 2분할해서 Map의 key에 남자면 true, 여자면 false 저장, value에는 key에 해당하는 Student2 객체를 List 타입으로 저장

        System.out.printf("%n2. 단순분할 + 통계(성별 학생 수)%n");
        Map<Boolean, Long> stuNumBySex = Stream.of(stuArr)
                .collect(partitioningBy(Student2::isMale, counting()));
  
        System.out.println("남학생 수 :" + stuNumBySex.get(true));
        System.out.println("여학생 수 :" + stuNumBySex.get(false));

  2. 단순분할 + 통계(성별 학생 수) 남학생 수 :8 여학생 수 :10

• partitioningBy(Student2::isMale, counting()) : 성별로 2분할(true, false)하고 각각의 요소의 개수르 카운팅

        System.out.printf("%n3. 단순분할 + 통계(성별 1등)%n");
        Map<Boolean, Optional<Student2>> topScoreBySex = Stream.of(stuArr)
                .collect(partitioningBy(Student2::isMale,
                        maxBy(comparingInt(Student2::getScore))));
  
        System.out.println("남학생 1등 :" + topScoreBySex.get(true));
        System.out.println("여학생 1등 :" + topScoreBySex.get(false));
  
        // Optional 객체의 값을 꺼내서 저장
        Map<Boolean, Student2> topScoreBySex2 = Stream.of(stuArr)
                .collect(partitioningBy(Student2::isMale,
                        collectingAndThen(
                                maxBy(comparingInt(Student2::getScore)),
                                Optional::get)));
  
        System.out.println("남학생 1등 :" + topScoreBySex2.get(true));
        System.out.println("여학생 1등 :" + topScoreBySex2.get(false));

  3. 단순분할 + 통계(성별 1등) 남학생 1등 :Optional[[김코딩, 남, 1학년 1반, 300점]] 여학생 1등 :Optional[[정수민, 여, 1학년 1반, 250점]] 남학생 1등 :[김코딩, 남, 1학년 1반, 300점] 여학생 1등 :[정수민, 여, 1학년 1반, 250점]

• 성별로 2분할 후 maxBy(comparingInt(Student2::getScore)를 이용하여 각 성별의 점수가 최대값이 Studeent2 객체 추출

• maxBy()의 반환타입은 Optional이기 때문에 Map의 value 반환타입을 Optional<Student2>으로 지정

• collectingAndThen()을 이용해서 Optional 객체의 값을 꺼내서 Map의 value에 저장 가능

        System.out.printf("%n4. 다중분할(성별 불합격자, 100점 이하)%n");

        Map<Boolean, Map<Boolean, List<Student2>>> failedStuBySex =
                Stream.of(stuArr).collect(partitioningBy(Student2::isMale,
                        partitioningBy(s -> s.getScore() <= 100))
                );
        List<Student2> failedMaleStu = failedStuBySex.get(true).get(true);
        List<Student2> failedFemaleStu = failedStuBySex.get(false).get(true);

        for (Student2 s : failedMaleStu) System.out.println(s);
        for (Student2 s : failedFemaleStu) System.out.println(s);
    }
}

4. 다중분할(성별 불합격자, 100점 이하) [정주일, 남, 1학년 2반, 100점]ㅤ [안세훈, 남, 2학년 2반, 100점]ㅤ [이효리, 여, 1학년 2반, 50점]ㅤ [이정현, 여, 1학년 3반, 100점]ㅤ [오채원, 여, 2학년 2반, 50점]ㅤ [임희민, 여, 2학년 3반, 100점]ㅤ

• 성별로 2분할 후, value 값을 다시 점수가 100점 이하면 key를 true로 하고 value를 Student2 객체로 저장 -> 다중분할

groupingBy() : 스트림을 n분할 한다.

Collector groupingBy(Function classifier)
Collector groupingBy(Function classifier, Collector downstream)
Collector groupingBy(Function classifier, Supplier mapFactory, Collector downstream)

• 괄호 안에 스트림을 나눌 기준을 정해주고 그 값을 Map의 key에 저장하고 각 key에 해당하는 값을 value에 저장한다.

실습예제

import java.util.*;
import java.util.stream.*;

import static java.util.stream.Collectors.*;
import static java.util.Comparator.*;

class Student3 {
    String name;
    boolean isMale;
    int hak;
    int ban;
    int score;

    Student3(String name, boolean isMale, int hak, int ban, int score) {
        this.name = name;
        this.isMale = isMale;
        this.hak = hak;
        this.ban = ban;
        this.score = score;
    }

    String getName() { return name; }
    boolean isMale() { return isMale; }
    int getHak() { return hak; }
    int getBan() { return ban; }
    int getScore() { return score; }

    public String toString() {
        return String.format("[%s, %s, %d학년 %d반, %3d점]",
                name, isMale ? "남" : "여", hak, ban, score);
    }

    enum Level {HIGH, MID, LOW}
}

• 위 예제와 동일하나 enum Level {HIGH, MID, LOW} 스트림을 그룹화할 enum 클래스 1개 추가

  class Ex14_11 {
    public static void main(String[] args) {
        Student3[] stuArr = {
                new Student3("김코딩", true, 1, 1, 300),
                new Student3("정수민", false, 1, 1, 250),
                new Student3("오정호", true, 1, 1, 200),
                new Student3("김선미", false, 1, 2, 150),
                new Student3("정주일", true, 1, 2, 100),
                new Student3("이효리", false, 1, 2, 50),
                new Student3("이정현", false, 1, 3, 100),
                new Student3("유정선", false, 1, 3, 150),
                new Student3("강호동", true, 1, 3, 200),
                new Student3("이수근", true, 2, 1, 300),
                new Student3("김미희", false, 2, 1, 250),
                new Student3("최시원", true, 2, 1, 200),
                new Student3("박지원", false, 2, 2, 150),
                new Student3("안세훈", true, 2, 2, 100),
                new Student3("오채원", false, 2, 2, 50),
                new Student3("임희민", false, 2, 3, 100),
                new Student3("홍은채", false, 2, 3, 150),
                new Student3("신정우", true, 2, 3, 200)
        };

• 객체 데이터는 위 예제와 동일

        System.out.printf("1. 단순그룹화(반별로 그룹화)%n");
        Map<Integer, List<Student3>> stuByBan = Stream.of(stuArr)
                .collect(groupingBy(Student3::getBan));
  
        for (List<Student3> ban : stuByBan.values()) {
            for (Student3 s : ban) {
                System.out.println(s);
            }
        }

  1. 단순그룹화(반별로 그룹화) [김코딩, 남, 1학년 1반, 300점]ㅤ [정수민, 여, 1학년 1반, 250점]ㅤ [오정호, 남, 1학년 1반, 200점]ㅤ [이수근, 남, 2학년 1반, 300점]ㅤ [김미희, 여, 2학년 1반, 250점]ㅤ [최시원, 남, 2학년 1반, 200점]ㅤ [김선미, 여, 1학년 2반, 150점]ㅤ [정주일, 남, 1학년 2반, 100점]ㅤ [이효리, 여, 1학년 2반, 50점]ㅤ [박지원, 여, 2학년 2반, 150점]ㅤ [안세훈, 남, 2학년 2반, 100점]ㅤ [오채원, 여, 2학년 2반, 50점]ㅤ [이정현, 여, 1학년 3반, 100점]ㅤ [유정선, 여, 1학년 3반, 150점]ㅤ [강호동, 남, 1학년 3반, 200점]ㅤ [임희민, 여, 2학년 3반, 100점]ㅤ [홍은채, 여, 2학년 3반, 150점]ㅤ [신정우, 남, 2학년 3반, 200점]ㅤ

• groupingBy(Student3::getBan) 을 통해 반별로 그룹화 후 출력

        System.out.printf("%n2. 단순그룹화(성적별로 그룹화)%n");
        Map<Student3.Level, List<Student3>> stuByLevel = Stream.of(stuArr)
                .collect(groupingBy(s -> {
                    if (s.getScore() >= 200) return Student3.Level.HIGH;
                    else if (s.getScore() >= 100) return Student3.Level.MID;
                    else return Student3.Level.LOW;
                }));

        for (Student3.Level key : Student3.Level.values()) {
            System.out.println("[" + key + "]");

            for (Student3 s : stuByLevel.get(key))
                System.out.println(s);
            System.out.println();
        }

2. 단순그룹화(성적별로 그룹화) [HIGH]ㅤ [김코딩, 남, 1학년 1반, 300점]ㅤ [정수민, 여, 1학년 1반, 250점]ㅤ [오정호, 남, 1학년 1반, 200점]ㅤ [강호동, 남, 1학년 3반, 200점]ㅤ [이수근, 남, 2학년 1반, 300점]ㅤ [김미희, 여, 2학년 1반, 250점]ㅤ [최시원, 남, 2학년 1반, 200점]ㅤ [신정우, 남, 2학년 3반, 200점]ㅤ
   [MID]ㅤ [김선미, 여, 1학년 2반, 150점]ㅤ [정주일, 남, 1학년 2반, 100점]ㅤ [이정현, 여, 1학년 3반, 100점]ㅤ [유정선, 여, 1학년 3반, 150점]ㅤ [박지원, 여, 2학년 2반, 150점]ㅤ [안세훈, 남, 2학년 2반, 100점]ㅤ [임희민, 여, 2학년 3반, 100점]ㅤ [홍은채, 여, 2학년 3반, 150점]ㅤ
   [LOW]ㅤ [이효리, 여, 1학년 2반, 50점]ㅤ [오채원, 여, 2학년 2반, 50점]ㅤ

• Map의 key로 enum 클래스 Level을 지정하고 groupingBy()로 점수별로 그룹화

        System.out.printf("%n3. 단순그룹화 + 통계(성적별 학생수)%n");
        Map<Student3.Level, Long> stuCntByLevel = Stream.of(stuArr)
                .collect(groupingBy(s -> {
                    if (s.getScore() >= 200) return Student3.Level.HIGH;
                    else if (s.getScore() >= 100) return Student3.Level.MID;
                    else return Student3.Level.LOW;
                }, counting()));
  
        for (Student3.Level key : Student3.Level.values())
            System.out.printf("[%s] - %d명%n", key, stuCntByLevel.get(key));
        System.out.println();

  3. 단순그룹화 + 통계(성적별 학생수) [HIGH] - 8명 [MID] - 8명 [LOW] - 2명

• 2번과 같이 점수별로 enum 클래스의 3개 값으로 그룹화하고 counting()을 통해 각 그룹별 학생 수 카운팅

        System.out.printf("%n4. 다중그룹화(학년별, 반별)");
        Map<Integer, Map<Integer, List<Student3>>> stuByHakAndBan =
                Stream.of(stuArr)
                        .collect(groupingBy(Student3::getHak,
                                groupingBy(Student3::getBan)
                        ));
  
        for (Map<Integer, List<Student3>> hak : stuByHakAndBan.values()) {
            for (List<Student3> ban : hak.values()) {
                System.out.println();
                for (Student3 s : ban)
                    System.out.println(s);
            }
        }

  4. 다중그룹화(학년별, 반별) [김코딩, 남, 1학년 1반, 300점]ㅤ [정수민, 여, 1학년 1반, 250점]ㅤ [오정호, 남, 1학년 1반, 200점]ㅤ
     [김선미, 여, 1학년 2반, 150점]ㅤ [정주일, 남, 1학년 2반, 100점]ㅤ [이효리, 여, 1학년 2반, 50점]ㅤ
     [이정현, 여, 1학년 3반, 100점]ㅤ [유정선, 여, 1학년 3반, 150점]ㅤ [강호동, 남, 1학년 3반, 200점]ㅤ
     [이수근, 남, 2학년 1반, 300점]ㅤ [김미희, 여, 2학년 1반, 250점]ㅤ [최시원, 남, 2학년 1반, 200점]ㅤ
     [박지원, 여, 2학년 2반, 150점]ㅤ [안세훈, 남, 2학년 2반, 100점]ㅤ [오채원, 여, 2학년 2반, 50점]ㅤ
     [임희민, 여, 2학년 3반, 100점]ㅤ [홍은채, 여, 2학년 3반, 150점]ㅤ [신정우, 남, 2학년 3반, 200점]ㅤ

• 학년을 key로 해서 그룹화하고 이 value 값을 다시 반을 key로 해서 그룹화한 다중그룹화

        System.out.printf("%n5. 다중그룹화 + 통계(학년별, 반별 1등)%n");
        Map<Integer, Map<Integer, Student3>> topStuByHakAndBan =
                Stream.of(stuArr)
                        .collect(groupingBy(Student3::getHak,
                                groupingBy(Student3::getBan,
                                        collectingAndThen(
                                                maxBy(comparingInt(Student3::getScore))
                                                , Optional::get
                                        )
                                )
                        ));

        for (Map<Integer, Student3> ban : topStuByHakAndBan.values())
            for (Student3 s : ban.values())
                System.out.println(s);

5. 다중그룹화 + 통계(학년별, 반별 1등) [김코딩, 남, 1학년 1반, 300점]ㅤ [김선미, 여, 1학년 2반, 150점]ㅤ [강호동, 남, 1학년 3반, 200점]ㅤ [이수근, 남, 2학년 1반, 300점]ㅤ [박지원, 여, 2학년 2반, 150점]ㅤ [신정우, 남, 2학년 3반, 200점]ㅤ

• 학년별로 나누고 다시 반별로 나눈 후 그 중 점수가 가장 높은 학생을 maxBy()를 통해 추출

        System.out.printf("%n6. 다중그룹화 + 통계(학년별, 반별 성적그룹)%n");
        Map<String, Set<Student3.Level>> stuByScoreGroup = Stream.of(stuArr)
                .collect(groupingBy(s -> s.getHak() + "-" + s.getBan(),
                        mapping(s -> {
                            if (s.getScore() >= 200) return Student3.Level.HIGH;
                            else if (s.getScore() >= 100) return Student3.Level.MID;
                            else return Student3.Level.LOW;
                        }, toSet())
                ));

        Set<String> keySet = stuByScoreGroup.keySet();

        for (String key : keySet) {
            System.out.println("[" + key + "]" + stuByScoreGroup.get(key));
        }
    }
}

6. 다중그룹화 + 통계(학년별, 반별 성적그룹) [1-1][HIGH]ㅤ [2-1][HIGH]ㅤ [1-2][MID, LOW]ㅤ [2-2][MID, LOW]ㅤ [1-3][MID, HIGH]ㅤ [2-3][MID, HIGH]ㅤ

• 학년별로 그룹화 후 다시 반별로 그룹화하는게 아니라 s -> s.getHak() + "-" + s.getBan() 하나의 문자열을 만들어서 이를 key 값으로 그룹화하고 각 그룹별 학생들의 점수에 대해 enum 클래스의 3개 값(HIGH, MID, LOW)으로 나눈 값을 value로 저장

: 다양한 데이터 소스(컬렉션, 배열, 파일 등)를 표준화된 방법으로 다루기 위한 것

List<Integer> list = Arrays.asList(1,2,3,4,5); // 컬렉션
Stream<Integer> intStream = list.stream(); // 컬렉션 -> 스트림


Stream<String> strStream = Stream.of(new String[]{"a", "b", "c"}); // 배열 -> 스트림
String[] strArr = new String[] {"a", "b", "c", "d"}; // 배열
Stream<String> strStream = Arrays.stream(strArr); // 배열 -> 스트림

Stream<Integer> evenStream = Stream.iterate(0, n->n+2); // 람다식 -> 스트림 
Stream<Double> randomStream = Stream.generate(Math::random); // 메서드 참조 -> 스트림

// Int형 최적화 Stream : IntStream
IntStream intStream = new Random().ints(5); // 난수 스트림

스트림으로 작업하는 과정

1. 데이터 소스를 스트림으로 만들기

2. 중간 연산(0 ~ n번 가능) : 연산 결과가 스트림인 연산. 반복적으로 적용 가능

3. 최종 연산(0 ~ 1번만 가능) : 연산 결과가 스트림이 아닌 연산. 스트림의 요소를 소모

   List<Integer> list = Arrays.asList(3, 4, 1, 2, 1, 1, 2, 5, 2);
   Stream<Integer> intStream = list.stream(); // 스트림 만들기
   intStream.distinct() // 중간 연산 - 중복 제거
        .sorted() // 중간 연산 - 정렬
        .forEach(s-> System.out.print(s+" ")); // 최종 연산 - 출력
   

intStream.forEach(System.out::println); // 에러

- 최종 연산을 마친 스트림은 다시 사용할 수 없다.

## 스트림의 특징
**스트림은 데이터 소스로부터 데이터를 읽기만할 뿐 변경하지 않는다.(Read only)**
```java
List<Integer> list = Arrays.asList(3,1,5,4,2);
List<Integer> sortedList = list.stream()
                    .sorted()
                    .collect(Collections.toList()); // 정렬해서 sortedList에 저장

System.out.println(list); // [3,1,5,4,2] 
System.out.println(sortedList) ; // [1,2,3,4,5]

• 원본 데이터인 list는 변경되지 않았다.

스트림은 Iterator처럼 일회용이다. 최종 연산 후 필요하면 다시 스트림을 생성해야한다.

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> intStream = list.stream(); // 스트림 만들기

intStream.forEach(System.out::println); // 최종 연산 - 출력
intStream.forEach(System.out::println); // 에러

• 최종 연산하게 되면 스트림은 소모가 되고 다시 그 스트림으로 작업을 수행 할 수 없다.

스트림은 최종 연산 전까지 중간 연산이 수행되지 않는다. -> 지연된 연산

IntStream intStream = new Random().ints(1, 46); // 1~46 범위의 난수를 생성하는 무한 스트림
intStream.distinct().limit(6).sorted()
    .forEach(i -> System.out.println(i + " ")); // 로또 번호 6개 출력하는 연산

• 1~46 범위의 난수를 무한으로 생성하는 스트림을 중복 제거하고 6개 자르는 연산이 가능한 이유는 중간 연산이 그때그때 수행되지 않고 최종 연산 때 한꺼번에 수행되기 때문이다.(지연된 연산)

스트림은 작업을 내부 반복으로 처리한다.

• 성능은 비효율적이지만 코드가 간결해진다.

스트림의 작업을 병렬로 처리할 수 있다. - 병렬 스트림

Stream<String> strStream = Stream.of("dd", "aaa", "c", "bb");
int sum = strStream.parallel()
        .mapToInt(String::length)
        .sum(); // 병렬 스트림

• 멀티쓰레드로 데이터를 동시에 처리하고 싶을 때 사용한다. 빅데이터를 병렬로 처리해서 작업속도를 높일 수 있다.

• 기본이 직렬 스트림이다.

• 병렬로 스트림을 수행하고 싶을 때 parallel() 추가

• 다시 직렬로 바꾸고 싶을때 sequential() 추가

기본형 스트림 - IntStream, LongStream, DoubleStream

• 오토 박싱&언박싱의 비효율 제거된다. : Stream<T>은 참조형 타입만 올 수 있다. 만약 int[] 배열을 스트림으로 만든다면 int 기본형 타입이 Integer 참조형 타입으로 오토 박싱된다. 따라서 빅데이터를 다룰 때 효율과 성능을 높이기 위해서 기본형 스트림을 사용한다.

• 숫자와 관련된 유용한 메서드를 Stream<T>보다 많이 제공한다 : 기본형 스트림의 요소들은 기본형 타입을 보장하기 때문에 max(), min(), average(), sum() 과 같은 숫자와 관련된 유용한 메서드들을 더 제공한다.

📌스트림 만들기

컬렉션

Collection 인터페이스의 stream()으로 컬렉션을 스트림으로 변환

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> intStream = list.stream(); // 스트림 만들기

배열

객체 배열로부터 스트림 생성

Stream<T> Stream.of(T...values) // 가변 인자
Stream<T> Stream.of(T[])

Stream<T> Arrays.stream(T[])
// 배열의 인덱스 from ~ to(to는 포함x)까지 스트림 생성
Stream<T> Arrays.stream(T[] array, int from, int to) 

Integer[] intArr = {1,2,3,4,5}; //int[] 는 불가능
Stream<Integer> intStream = Arrays.stream(intArr) ; // intArr가 참조형(Integer)이여야 가능

Stream<String> strStream = Stream.of("a", "b", "c")
Stream<String> strStream = Stream.of(new String[]{"a", "b", "c"});
Stream<String> strStream = Arrays.stream(new String[]{"a", "b", "c"});
Stream<String> strStream = Arrays.stream(new String[]{"a", "b", "c"}, 0, 3);

기본형 배열로부터 스트림 생성

IntStream IntStream.of(int...values) // 가변 인자
IntStream IntStream.of(int[])
IntStream Arrays.stream(int[])
// 배열의 인덱스 from ~ to(to는 포함x)까지 스트림 생성
IntStream Arrays.stream(int[] array, int from, int to)

IntStream intStream2 = IntStream.of(1, 2, 3);
IntStream intStream3 = IntStream.of(new int[]{1, 2, 3});
IntStream intStream4 = Arrays.stream(new int[]{1, 2, 3});
IntStream intStream5 = Arrays.stream(new int[]{1, 2, 3, 4, 5}, 1, 4);
intStream5.forEach(s -> System.out.print(s + " "));

intStream5 : 2 3 4

• LongStream, DoubleStream도 위 방법과 똑같이 사용가능하다.

난수

임의의 수를 요소로 갖는 스트림 생성

IntStream intStream = new Random().ints(); // 무한 스트림
intStream.limit(5).forEach(System.out::println); // 무한 스트림에서 5개의 요소만 출력

IntStream intStream = new Random().ints(5); // 유한 스트림

• Random 클래스의 ints(), longs(), doubles() 메서드로 난수 스트림을 만들 수 있다.
• limit()를 통해 무한 스트림에서 n개의 요소만 출력 할 수 있다.
• new Random().ints(5); : 난수 스트림을 만들 때 크기를 지정해줄 수도 있다.

ints(), longs(), doubles()의 기본 범위

• Integer.MIN_VALUE <= ints() <= Integer.MAX_VALUE

• Long.MIN_VALUE <= longs() <= Long.MAX_VALUE

• 0.0 <= doubles < 1.0

지정된 범위의 난수를 요소로 갖는 스트림 생성

// 무한 스트림
IntStream ints(int begin, int end)
LongStream longs(long begin, long end)
DoubleStream doubles(double begin, double end)

// 유한 스트림
IntStream ints(long streamSize, int begin, int end)
LongStream longs(long streamSize, long begin, long end)
DoubleStream doubles(long streamSize, double begin, double end)

• ints(int begin, int end) : begin ~ end 범위(end 포함x)의 난수를 생성하는 스트림
• ints(long streamSize, int begin, int end) : begin ~ end 범위(end 포함x)의 난수를 streamSize만큼 생성하는 스트림

특정 범위의 정수

특정 범위의 정수를 요소로 갖는 스트림 생성

IntStream IntStream.range(int begin, int end)
IntStream IntStream.rangeClosed(int begin, int end)

IntStream intS = IntStream.range(1, 5) ; // 1,2,3,4
IntStream intS = IntStream.rangeClosed(1, 5) ; // 1,2,3,4,5

• 두 메서드의 차이는 end 값 포함 여부 range : end 값 포함 X rangeClosed : end 값 포함 O

람다식

람다식을 소스로 하는 스트림 생성

static <T> Stream<T> iterate(T seed, UnaryOperator<T> f) // 이전 요소에 종속적
static <T> Stream<T> generate(Supplier<T> s) // 이전 요소에 독립적

• 이 두 메서드는 매개변수로 받은 람다식에 의해 계산되는 값들을 요소로 하는 무한 스트림을 생성

• T seed 는 초기값

iterate()

: 이전 요소를 seed로 해서 다음 요소를 계산한다.

Stream<Integer> evenStream = Stream.iterate(0, n -> n +2);
evenStream.limit(10).forEach(s -> System.out.print(s + " "));

0 2 4 6 8 10 12 14 16 18

• 초기값부터 시작해서 람다식을 계산하고 이 결과를 seed로 다시 람다식을 계산한다. 즉, 이전 요소에 영향을 미친다.

generate()

초기값이 없으며 이전 요소에 독립적이다.

Stream<Integer> oneStream = Stream.generate(() -> 1);
oneStream.limit(10).forEach(s -> System.out.print(s + " "));

1 1 1 1 1 1 1 1 1 1

• 이전 요소와 상관없이 람다식이 계산된다.

파일과 빈 스트림

파일

파일을 소스로 하는 스트림 생성 Stream<Path> Files.list(Path dir)

• 지정 디렉토리(dir)에 있는 파일 목록을 소스로 하는 스트림을 생성해 반환한다.

Stream<String> Files.lines(Path path)
Stream<String> Files.lines(Path path, Charset cs)
Stream<String> lines() // BufferedReader 클래스의 메서드

• 한 파일의 한 행(line)을 요소로 하는 스트림을 생성(보통 로그(Log)파일을 읽을 때 사용)

빈 스트림

요소가 하나도 없는 비어있는 스트림

Stream emptyStream = Stream.empty(); // 비어있는 스트림 생성 및 반환

long cnt = emptyStream.count(); // 비어있기 때문에 당연히 0

• 연산 수행 결과가 없을 때, null보단 빈 스트림을 반환하는 것이 낫다.

📌중간 연산

: 연산 결과가 스트림인 연산. 0 ~ n번 사용 가능

중간 연산 메서드

map(), flatMap()

skip(), limit()

Stream<T> skip(long n) : 앞에서부터 n개 건너뛴다.

Stream<T> limit(long maxSize) : maxSize 이후의 요소는 잘라낸다.

IntStream intStream = IntStream.rangeClosed(1, 10); // 12345678910
intStream.skip(3).limit(5).forEach(System.out::print);

45678

• skip(3) : 123 건너뛴다.
• limit(5) : 4부터 5개 요소만 잘라낸다.

filter(), distinct()

Stream<T> filter(Predicate<T> predicate) : 조건에 맞지 않는 요소를 제거한다.

IntStream intStream = IntStream.rangeClosed(1, 10); // 12345678910
intStream.filter(i -> i % 2 == 0).forEach(System.out::print);

246810

IntStream intStream = IntStream.rangeClosed(1, 10); // 12345678910
intStream.filter(i -> i % 2 == 0 && i % 3 == 0).forEach(System.out::print);

6

• intStream.filter(i -> i % 2 == 0).filter(i -> i % 3 == 0).forEach(System.out::print); ); : filter를 2번 써서 && 와 같은 동작을 수행할 수 있다.

Stream<T> distinct() : 중복을 제거한다.

IntStream intStream = IntStream.of(1,1,2,2,3,4,4,5);
intStream.distinct().forEach(System.out::print);

12345

sorted()

Stream<T> sorted() : 스트림 요소의 기본 정렬 기준(Comparable)으로 정렬

Stream<T> sorted(Comparator<T> comparator) : 지정된 Comparator으로 정렬

Stream<String> strStream = Stream.of("dd", "aaa", "CC", "cc", "b");

// 기본 정렬 -> 출력 결과 : CCaaabccdd
strStream.sorted(); // String 클래스의 Comparable
strStream.sorted(Comparator.naturalOrder()); // Comparator 클래스에 구현된 기본 정렬 기준 
strStream.sorted((s1, s2) -> s1.compareTo(s2)); // 람다식
strStream.sorted(String::compareTo); // 메서드 참조

// 역순 정렬 -> 출력 결과 : ddccbaaaCC
strStream.sorted(Comparator.reverseOrder()) // 기본 정렬의 역순
strStream.sorted(Comparator.<String>naturalOrder().reversed()) // 잘안씀

// 기본 정렬(대소문자 구분 X) -> 출력 결과 : aaabCCccdd
strStream.sorted(String.CASE_INSENSITIVE_ORDER)

// 역순 정렬(대소문자 구분 X) -> 출력 결과 : ddCCccbaa 오타 아님(대문자가 앞에 온다.)
strStream.sorted(String.CASE_INSENSITIVE_ORDER.reversed())

// 별도 기준 정렬 -> 출력 결과 : bddCCccaaa
strStream.sorted(Comparator.comparing(String::length)) // 문자열 길이 순 정렬
strStream.sorted(Comparator.comparingInt(String::length))

// 별도 기준 역순 정렬 -> 출력 결과 : aaaddCCccb
strStream.sorted(Comparator.comparing(String::length).reversed())

comparing(), thenComparing()

Comparator의 comparing()으로 정렬 기준을 제공

Comparator<T> comparing(Function<T, U> keyExtractor)
Comparator<T> comparing(Function<T, U> keyExtractor, Comparator<U> keyComparator)

thenComparing() : 추가 정렬 기준을 제공할 때 사용

Comparator<T> thenComparing(Comparator<T> other)
Comparator<T> thenComparing(Function<T, U> keyExtractor)
Comparator<T> thenComparing(Function<T, U> keyExtractor, Comparator<U> keyComparator)

실습 예제

import java.util.*;
import java.util.stream.*;

class Student implements Comparable<Student> {
    private String name;
    private int ban;
    private int totalScore;

    Student(String name, int ban, int totalScore) {
        this.name = name;
        this.ban = ban;
        this.totalScore = totalScore;
    }

    // toString() 오버라이딩
    public String toString() {
        return String.format("[%s, %d, %d]", name, ban, totalScore);
    }

    public String getName() { return name; }
    public int getBan() { return ban; }
    public int getTotalScore() { return totalScore; }

    // 총점 내림차순으로 기본 정렬
    public int compareTo(Student s) {
        return s.totalScore - this.totalScore;
    }
}

class Ex14_5 {
    public static void main(String[] args) {
        Stream<Student> studentStream = Stream.of(
                new Student("이빛나", 3, 300),
                new Student("김자바", 1, 200),
                new Student("안정호", 2, 100),
                new Student("박코딩", 2, 150),
                new Student("최자연", 1, 200),
                new Student("연보라", 3, 290),
                new Student("정빛나", 3, 180)
        );

        studentStream.sorted(Comparator.comparing(Student::getBan)
                        .thenComparing(Comparator.naturalOrder()))
                .forEach(System.out::println);
    }
}ㅤ

[김자바, 1, 200]ㅤ [최자연, 1, 200] ㅤ [박코딩, 2, 150]ㅤ [안정호, 2, 100]ㅤ [이빛나, 3, 300]ㅤ [연보라, 3, 290]ㅤ [정빛나, 3, 180]

• 반 순서대로 정렬하고 기본 정렬(성적 내림차순)

studentStream.sorted(Comparator.comparing(Student::getBan).reversed()
                .thenComparing(Student::getName))
        .forEach(System.out::println);

[연보라, 3, 290]ㅤ [이빛나, 3, 300]ㅤ [정빛나, 3, 180]ㅤ [박코딩, 2, 150]ㅤ [안정호, 2, 100]ㅤ [김자바, 1, 200]ㅤ [최자연, 1, 200]ㅤ

• 반 역순으로 정렬하고 이름 순서대로 정렬

map()

스트림의 요소 변환

import java.io.*;
import java.util.stream.*;

class Ex14_6 {
    public static void main(String[] args) {
        File[] fileArr = {
                new File("Ex1.java"),
                new File("Ex1.bak"),
                new File("Ex2.java"),
                new File("Ex1"),
                new File("Ex1.txt")
        };

        Stream<File> fileStream = Stream.of(fileArr);

        fileStream.map(File::getName) // Stream<File> -> Stream<String>
                .filter(s -> s.indexOf('.') != -1) // 확장자 없는 파일 삭제
                .map(s -> s.substring(s.indexOf('.') + 1)) // 확장자명만 추출
                .map(String::toUpperCase) // 대문자로 변경
                .distinct() // 중복 제거
                .forEach(System.out::print); // JAVABAKTXT
    }
}

JAVABAKTXT

peek()

스트림의 요소를 소비하지 않고 엿보기

Stream<T> peek(Consumer<T> action)
void forEach(Consumer<T> action)

• peek()은 중간 연산. 스트림의 요소를 소비 X
• forEach()는 최종 연산. 스트림의 요소를 소비 O

fileStream.map(File::getName) // Stream<File> -> Stream<String>
        .filter(s -> s.indexOf('.') != -1) // 확장자 없는 파일 삭제
        .peek(s -> System.out.printf("파일명 : %s%n", s))
        .map(s -> s.substring(s.indexOf('.') + 1)) // 확장자명만 추출
        .peek(s -> System.out.printf("확장자 : %s%n", s))
        .map(String::toUpperCase) // 대문자로 변경
        .distinct() // 중복 제거
        .forEach(System.out::print); // JAVABAKTXT

System.out.println();

파일명 : Ex1.java 확장자 : JAVA JAVA파일명 : Ex1.bak 확장자 : BAK BAK파일명 : Ex2.java 확장자 : JAVA 파일명 : Ex1.txt 확장자 : TXT TXT

• 메서드 중간 중간마다 수행이 잘되고 있는지 확인하는 디버깅 용도로 쓰인다.

flatMap()

스트림의 스트림을 스트림으로 변환

Stream<String[]> strArrStrm = Stream.of(
        new String[]{"abc", "def", "jkl"},
        new String[]{"ABC", "GHI", "JKL"}

Stream<String> strStrm = strArrStrm.flatMap(Arrays::stream);

String[] strings = strStrm.map(String::toLowerCase)
        .distinct()
        .sorted()
        .toArray(String[]::new);
System.out.println(Arrays.toString(strings));

[abc, def, ghi, jkl]

• 문자열 배열을 가지고 있는 스트림을 flatMap을 통해 각 문자열 배열의 요소들을 합쳐서 하나의 스트림으로 만든다.

  String[] lineArr = {
        "Believe or not It is true",
        "Do or do not There is no try",
  };
  

Stream lineStream = Arrays.stream(lineArr); List list = lineStream.flatMap(line -> Stream.of(line.split(" +"))) .map(String::toLowerCase) .distinct() .sorted() .collect(Collectors.toList()); System.out.println(list);

>[believe, do, is, it, no, not, or, there, true, try]

- 문장들을 요소로 하는 String[] 배열을 flatMap을 통해 각 문장의 단어들을 하나로 합친 스트림으로 만든다.

1. 메서드 안에서 또 자신의 메서드를 호출하는 것을 말한다.

2. 모든 재귀함수는 for 문으로 바꿀 수 있다.

3. 반복해서 메서드를 호출하므로 call stack에 메서드가 종료되지 않고 계속 쌓이게 된다. 이 과정이 for 문보다 메모리를 더 사용한다.

4. 메서드를 호출하고 매서드가 종료된 이후에 복귀를 위한 컨텍스트 스위칭 비용이 발생하게 된다.

재귀 사용방법

1. 종료조건을 반드시 작성
2. 문제를 작은 단위로 쪼갠다.

예시 - factorial

public class Factorial {
    public int factorial(int num) {
        int result;

        // base case
        if (num == 1) return result = 1;

        // recursive case
        result = num * factorial(num - 1);
        return result;
    }
}

class Factorial_Test {
    public static void main(String[] args) {
        Factorial f = new Factorial();

        int output = f.factorial(3);
        System.out.println(output);
    }
}

output = 6

• factorial(3) = 3x2x1 이다. factorial(2) = 2x1 즉, factorial(3) = 3 x factorial(2)가 된다.

• main메서드에서 factorial(3)를 호출

  • factorial(3) = 3 x factorial(2)
  • factorial(2) = 2 x factorial(1)
  • factorial(1) = 1

public int factorial(int n) {
    int result;

    // base case
    if (n == 1) return result = 1;

    // recursive case
    result = n * factorial(n - 1);

    return result;
}

• 처음 factorial(3)이 call stack에 쌓이고 메서드가 실행되다가 result = n * factorial(n - 1); 여기서 다시 factorial(2)가 호출된다. 이 때 아직 result의 값은 정해지지 않았다. = 대입 연산자는 가장 마지막에 연산되기 때문에 재귀가 먼저 발생한다.

• factorial(1)이 됐을 때 if (n == 1) return result = 1; 종료조건이 실행되면서 result = 1을 return 하면서 factorial(1) 메서드는 call stack에서 사라지고 factorial(2)로 되돌아간다. 이제 여기서

  result = 2 * factorial(2 - 1); 
  

// result = 2 * factorial(1) = 2 * 1 = 2
return result;

이 두 문장이 실행되는 것이다. 그럼 factorial(2)는 result = 2를 리턴하고 factorial(3)으로 되돌아간다.
```java
result = 3 * factorial(3 - 1);

// result = 3 * factorial(2) = 3 * 2 = 6
return result;

factorial(3)으로 와서 이 두 문장을 실행하고 result = 6 을 main메서드 output에 저장하고 출력한다.

그림으로 표현🔽

예시 - reverseArr

배열을 입력받아 순서가 뒤집힌 배열을 리턴하는 메서드

public class ReverseArr {
    public int[] reverseArr(int[] arr) {
        if (arr.length == 0) return new int[]{};

        int[] head = Arrays.copyOfRange(arr, arr.length - 1, arr.length);
        int[] tail = reverseArr(Arrays.copyOfRange(arr, 0, arr.length - 1));

        List<int[]> list = new ArrayList<>();
        list.add(head);
        list.add(tail);

        return list.stream().flatMapToInt(Arrays::stream).toArray();
    }
}

class ReverseArr_Test {
    public static void main(String[] args) {
        ReverseArr r = new ReverseArr();

        int[] output = r.reverseArr(new int[]{1, 2, 3});
        System.out.println(Arrays.toString(output));
    }
}

output = [3, 2, 1]

int[] tail = reverseArr(Arrays.copyOfRange(arr, 0, arr.length - 1)); : 메서드 중간에 재귀함수가 있다. 종료조건인 if (arr.length == 0) return new int[]{};가 만족되서 return이 될때까지 tail에 저장되지 않고 메서드가 계속 호출된다. 그러다가 종료조건을 통해 return 값이 생기면 이 값을 tail에 저장하고 종료조건 바로 전 메서드로 복귀하고

    List<int[]> list = new ArrayList<>();
    list.add(head);
    list.add(tail);

    return list.stream().flatMapToInt(Arrays::stream).toArray();

위의 재귀함수 이후 나머지 문장들이 수행된다. 이 문장 마지막에 return이 수행되서 메서드가 종료되고 또 이 바로 전 메서드로 복귀하고 위의 문장들을 수행한다. 이 과정을 반복하고 마지막 메서드의 return 문의 결과값을 main 메서드에서 출력하게 되는 것이다.

그림으로 표현🔽

📌DFS / BFS

DFS : BFS :

: 함수(메서드)를 간단한 식(expression)으로 표현하는 방법

람다식은 익명 함수(이름이 없는 함수)

int max(int a, int b) {
    return a > b ? a: b;
}

람다식으로 표현🔽

(int a, int b) -> {
    return a > b ? a : b;
}

• 반환타입과 함수 이름을 생략한다.

함수와 메서드의 차이

• 근본적으로 동일하지만 함수는 일반적인 용어, 메서드는 객체지향개념 용어이다.
• 함수는 클래스에 독립적이지만 메서드는 클래스에 종속적이다.
• 자바는 모든 메서드가 클래스 안에서만 정의될 수 있기 때문에 메서드라고 부른다.

람다식 작성하기

1. 메서드의 이름과 반환타입을 제거하고 "->" 추가

   (int a, int b) -> {
    return a > b ? a : b;
   }

2. 반환값이 있는 경우, 식이나 값만 적고 return 문 생략(;도 생략) (int a, int b) -> a > b ? a : b

3. 매개변수의 타입이 추론 가능하면 생략 가능(대부분 생략 가능) (a, b) -> a > b ? a : b

작성 시 주의사항

1. 매개변수가 하나인 경우 괄호 생략 가능 a -> a * a

2. 블록 안의 문장이 하나 뿐일 때 중괄호 생략 가능(;도 생략) i -> System.out.println(i)

람다식 예시

(int a, int b) -> {
    return a > b ? a : b;
}

람다식🔽 (a, b) -> a > b ? a : b

int square(int x) {
    return x * x;
}

람다식🔽 x -> x * x

int roll() {
    return (int)(Math.random() * 6);
}

람다식🔽 () -> (int)(Math.random() * 6)

• 매개변수 없을 때 괄호만 써준다. 괄호 생략 불가

  람다식은 익명 객체

  람다식은 익명 함수가 아니라 익명 객체이다.

• 람다식은 메서드를 간단하게 표현한 식이다. 그런데 자바는 메서드만 단독으로 쓰일 수 없고 항상 클래스 안에 있어야 하기 때문에 익명 객체로 람다식을 감싼 것이고 따라서 람다식을 익명 개체라고 하는 것이다.

  (a, b) -> a > b ? a : b
  

// 익명 클래스 new Object() { int max(int a, int b) { return a > b ? a : b ; } }

// 참조변수에 대입 Object obj = new Object() { int max(int a, int b) { return a > b ? a : b ; } }; ... int value = obj.max(3,5); // 에러

- 람다식은 익명 객체지만 Object 타입의 참조변수에 대입하면 에러가 난다. Object 타입에는 max() 라는 메서드가 정의되어 있지 않기 때문이다.
그래서 람다식을 다루기 위해 만들어진 참조타입이 **함수형 인터페이스**이다.

***
# 📌함수형 인터페이스
**단 하나의 추상 메서드만 선언된 인터페이스**
```java
@FunctionalInterface
interface MyFunction {
    int max(int a, int b);
}

public class Ex14_0 {
    public static void main(String[] args) {
        MyFunction f = (a, b) -> a > b ? a : b;
        int value = f.max(3, 5);
        System.out.println(value);
    }
}

5

• 람다식을 다루기 위해 참조타입을 함수형 인터페이스로 선언한다.
• @FunctionalInterface : 함수형 인터페이스라는 것을 알리는 애너테이션. 이 애너테이션이 붙은 인터페이스에 2개 이상의 추상 메서드를 작성하면 에러가 난다. -> 하나의 추상 메서드만 작성 가능

익명 객체를 람다식으로 대체

List<String> list = Arrays.asList("abc", "aaa", "bbb", "ddd");
Collections.sort(list, new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        return o2.compareTo(o1);
    }
});

• 내림차순으로 정렬하는 기준을 익명 객체로 구현

람다식으로 대체🔽

Collections.sort(list,(s1, s2) -> s2.compareTo(s1));

• Comparator<T>도 compare(T o1, T o2) 추상 메서드 하나만을 가진 함수형 인터페이스이다.

함수형 인터페이스 타입의 매개변수, 반환타입

매개변수

@FunctionalInterface
interface MyFunction {
    void myMethod() ;
}

...
void aMethod(MyFunction f) {
    f.myMethod();
}
...
Myfunction f = () -> System.out.println("myMethod()");
aMethod(f);

• 함수형 인터페이스 타입의 매개변수는 매개변수로 람다식을 넣는다. 그럼 이 메서드가 람다식을 호출하는 것이다.

• aMethod(() -> System.out.println("myMEthod()")); 한 줄로 줄일 수 있다.

반환타입

MyFunction getMyFunction() {
    return () -> System.out.println("myMethod");
}

• 함수형 인터페이스 타입의 반환타입은 람다식을 반환하는 것이다.

실습 예제

@FunctionalInterface
interface MyFunction {
    void run();  // public abstract void run();
}

public class Ex14_1 {
    static void execute(MyFunction f) {
        f.run();
    }

    static MyFunction getMyFunction() {
        return () -> System.out.println("f3.run()");
    }

    public static void main(String[] args) {
        MyFunction f1 = () -> System.out.println("f1.run()");

        MyFunction f2 = getMyFunction(); // 함수형 인터페이스 타입의 반환타입

        f1.run();
        f2.run();

        execute(f1); // 함수형 인터페이스 타입의 매개변수
        execute(() -> System.out.println("run()"));
    }
}

f1.run() f2.run() f1.run() run()

• execute(f1); : 매개변수가 함수형 인터페이스 타입인 메서드 excute()는 매개변수로 람다식이 들어간다.

📌java.util.function 패키지

: 자주 사용되는 다양한 함수형 인터페이스를 제공하는 패키지이다. -> 람다식을 쓸 때마다 새로운 함수형 인터페이스를 정의하는 것보다 이 패키지 안에 있는 이미 만들어진 함수형 인터페이스를 사용하는 것이 재사용성 / 유지보수 측면에서 좋고 표준화가 된다는 장점이 있다.

Quiz

빈칸에 들어갈 알맞은 함수형 인터페이스는?

( ① ) f = () -> (int)(Math.random()*100) + 1; A. ① : Supplier<Integer>

• 입력값은 없고 난수만 반환하기 때문에

( ② ) f = i -> System.out.print(i + ", "); A. ② : Consumer<Integer>

• 입력값(i)은 있는데 반환값은 없고 그냥 출력만 하기 때문에

( ③ ) f = i -> i % 2 == 0; A. ③ : Predicate<Integer>

• i % 2 == 0 이라는 조건식을 반환하기 때문에

( ④ ) f = i -> i / 10 * 10; A. ④ : Function<Integer, Integer>

• 입력값과 출력값이 모두 있기 때문에

매개변수가 2개인 함수형 인터페이스

• BiSupplier는 없다. 함수는 반환값이 2개가 될 수 없기 때문에

매개변수의 타입과 반환타입이 일치하는 함수형 인터페이스

@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {
    static <T> UnaryOperator<T> identity() {
        return t -> t;
    }
}

• identity() : 항등함수라고 한다. 입력값 t를 입력하면 그대로 t가 반환되는 함수이다.

실습 예제

import java.util.function.*;
import java.util.*;

class Ex14_2 {
    public static void main(String[] args) {
        Supplier<Integer> s = () -> (int) (Math.random() * 100) + 1; // 난수 생성
        Consumer<Integer> c = i -> System.out.print(i + ", "); // 입력값 출력
        Predicate<Integer> p = i -> i % 2 == 0; // 짝수인지 검사
        Function<Integer, Integer> f = i -> i / 10 * 10; // 일의 자리 버림

        List<Integer> list = new ArrayList<>();
        makeRandomList(s, list);
        System.out.println(list);
        printEvenNum(p, c, list);
        List<Integer> newList = doSomething(f, list);
        System.out.println(newList);
    }

    static <T> List<T> doSomething(Function<T, T> f, List<T> list) {
        // list와 크기가 같은 newList를 새로 생성
        List<T> newList = new ArrayList<T>(list.size());
        // Function으로 일의 자리 버림한 수를 newList에 add
        for (T i : list) {
            newList.add(f.apply(i));
        }

        return newList;
    }

    static <T> void printEvenNum(Predicate<T> p, Consumer<T> c, List<T> list) {
        System.out.print("[");
        for (T i : list) {
            // Predicate로 짝수인지 검사하고 맞으면
            if (p.test(i))
                // Consumer로 짝수값 출력
                c.accept(i);
        }
        System.out.println("]");
    }

    static <T> void makeRandomList(Supplier<T> s, List<T> list) {
        // Supplier를 통해 생성된 난수 10개를 list에 저장
        for (int i = 0; i < 10; i++) {
            list.add(s.get());
        }
    }
}

• makeRandomList(s, list); : Supplier를 통해 생성된 난수 10개를 list에 저장

• printEvenNum(p, c, list); : Predicate로 list의 요소들을 짝수인지 검사하고 짝수가 맞으면 Consumer를 통해 출력

• List<Integer> newList = doSomething(f, list); : Function을 통해 list의 값들을 일의 자리 버림한 수들을 newList에 저장

📌Predicate의 결합

and(), or(), negate()로 두 Predicate를 하나로 결합(default 메서드)

Predicate<Integer> p = i -> i < 100;
Predicate<Integer> q = i -> i < 200;
Predicate<Integer> r = i -> i % 2 == 0;

Predicate 결합🔽

Predicate<Integer> notP = p.ngeate();
Predicate<Integer> all = notP.and(q).or(r);
Predicate<Integer> all2 = notP.and(q.or(r));

notP = i >= 100 all = i >= 100 && i < 200 || i % 2 == 0 all2 = i >= 100 && (i < 200 || i % 2 == 0)

System.out.println(all.test(2));
System.out.println(all2.test(2));

true false

all.test(2)

• 2 >= 100 -> false
• 2 < 200 -> true
• 2 % 2 == 0 -> true

• false && true || true = false || true = true

all2.test(2)

• 2 >= 100 -> false
• 2 < 200 -> true
• 2 % 2 == 0 -> true -> false && (true || true) = false && true = false

등가비교를 Predicate 작성 - isEqual() (static 메서드)

boolean result = Predicate.isEqual(str1).test(str2);

• str1과 str2 비교

andThen() - Function 결합

2개 이상의 함수를 하나로 연결할 때 사용

// 입력값 : String / 반환값 : Integer
Function<String, Integer> f = (s) -> Integer.parseInt(s, 16) 
// 입력값 : Integer / 반환값 : String
Function<Integer, String> g = (i) -> Integer.toBinaryString(i) 

Function<String, String> h = f.andThen(g); // 두 함수를 하나의 함수로 결합

System.out.println(h.apply("FF"));

• Function<String, String> h = f.andThen(g)

  • h의 입력타입은 f의 입력타입과 같고 h의 반환타입은 g의 반환타입과 같다.

    • f의 반환타입과 g의 입력타입이 같아야 한다.

• h.apply("FF") -> Integer.parseInt(FF, 16) : "FF"를 16진수로 변환 = 255 -> Integer.toBinaryString(255) : 255를 2진수로 변환 = 11111111 출력

📌컬렉션 프레임워크와 함수형 인터페이스

함수형 인터페이스를 사용하는 컬렉션 프레임워크의 메서드(와일드 카드 생략)

실습 예제

import java.util.*;

class Ex14_4 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++)
            list.add(i);

        // list의 모든 요소 출력
        list.forEach(i -> System.out.print(i + ","));
        System.out.println();

        // list에서 2 또는 3의 배수 제거
        list.removeIf(x -> x % 2 == 0 || x % 3 == 0);
        System.out.println(list);

        // list의 모든 요소에 x10
        list.replaceAll(i -> i * 10);
        System.out.println(list);

        Map<String, String> map = new HashMap<>();
        map.put("1", "1");
        map.put("2", "2");
        map.put("3", "3");
        map.put("4", "4");

        // map의 모든 요소를 {k, v} 형식으로 출력
        map.forEach((k, v) -> System.out.print("{" + k + "," + v + "},"));
        System.out.println();
    }
}

• map.forEach((k, v) -> System.out.print("{" + k + "," + v + "},")); : iterator() 반복자를 써서 컬렉션을 출력하는 대신 forEach() 메서드를 통해 코드를 간결하게 바꿀 수 있다.

📌메서드 참조(method reference)

: 하나의 메서드만 호출하는 람다식은 "메서드 참조"로 더욱 간단히 할 수 있다.

static 메서드 참조

Integer method(string s) {
    return Integer.parseInt(s);
}

람다식🔽 Function<String, Integer> f = s -> Integer.parseInt(s);

메서드 참조🔽 Function<String, Integer> f = Integer::parseInt;

생성자 메서드 참조

매개변수가 없는 생성자

// 생성자 람다식
Supplier<MyClass> s = () -> new MyClass();

• 매개변수가 없는 생성자는 입력값이 없기 때문에 Supplier로 작성

메서드 참조🔽 Supplier<MyClass> s = MyClass::new;

매개변수가 있는 생성자

Function<Integer, MyClass> f = (i) -> new MyClass(i); //람다식
Function<Integer, MyClass> f = MyClass::new; // 메서드 참조

• 매개변수라는 입력값이 있기 때문에 Function을 사용한다.

매개변수가 2개 이상인 생성자

// 매개변수가 2개 이상인 생성자
BiFunction<Integer, String, MyClass> bf = (i, s) -> new MyClass(i, s); // 람다식
BiFunction<Integer, String, MyClass> bf = MyClass::new; // 메서드 참조

• BiFunction 사용

배열 메서드 참조

Function<Integer, int[]> arrF = x -> new int[x]; // 람다식
Function<Integer, int[]> arrF = int[]::new; // 메서드 참조 

// String 배열
Function<Integer, String[]> arrF2 = String[]::new ;

• 배열을 생성할 땐 배열의 크기를 정해줘야 하므로 입력값이 있다. 따라서 Function을 이용한다.

어떤 함수형 인터페이스를 사용할지 모를땐 입력값과 반환값의 유무를 잘 생각해보면 된다.

쓰레드의 실행을 제어할 수 있는 메서드들

• static 메서드인 sleep()과 yield()는 다른 쓰레드에게 적용할 수 없고 쓰레드 자기 자신에게만 호출이 가능하다.

sleep()

: 현재 쓰레드를 지정된 시간동안 멈추게 한다.

예외처리를 해야 한다.(InterruptedException이 발생하면 깨어남)

try{
    Thread.sleep(5000); // 5초동안 멈춤
} catch(InterruptedException e) {}

• InterruptedException는 Exception의 자손이기 때문에 예외처리가 필수이다.

• sleep()을 깨우는 방법은 2가지이다.

  1. time-out : 지정된 시간이 지나서 try-catch문을 정상적으로 빠져나온다.
  2. interrupt() : 이 메서드를 호출하면 InterruptedException 예외가 발생하게 되고 이로 인해 try-catch문을 중간에 빠져나오게 된다. 어떤 문제가 있어서 예외처리를 하는 것이 아니라 잠자는 상태를 중간에 벗어나기 위해 try-catch문을 이용한 것이다. 따라서 catch문 안에 아무것도 쓰지 않는다.

매번 try-catch문을 작성하기 불편하기 때문에 보통 메서드를 따로 만들어서 사용한다.

void delay(long millis) {
    try{
        Thread.sleep(millis);
    } catch(InterruptedException e) {}
}

delay(5000); // 5초동안 멈춤

특정 쓰레드를 지정해서 멈추게 하는 것은 불가능하다.

//main쓰레드에서 실행
try {
    th1.sleep(2000); // 에러는 발생하지 않음
} catch (InterruptedException e) {}

• th1.sleep(2000); : 에러는 발생하지 않지만 main 쓰레드에서 실행했기 때문에 멈춘건 th1 쓰레드가 아니라 main 쓰레드이다.

올바른 작성법🔽

try {
    Thread.sleep(2000);
} catch (InterruptedException e) {}

• Thread.sleep(2000); : 이렇게 작성해야 오해의 여지가 없고 실수도 하지 않게 된다.

interrupt()

: 대기 상태(WAITING)인 쓰레드를 실행 대기 상태(RUNNABLE)로 만든다.

interrupt() 관련 메서드

• static boolean interrupted()은 상태를 반환하고 false로 초기화한다. interrupt() 메서드를 호출하면 interrupted 상태를 true로 변경하는데 false에서 true가 되야 interrupted가 됐다는걸 알 수 있다. false로 초기화하지 않고 또 호출하게 되면 true -> true가 되므로 누가 호출했는지, 제대로 호출됐는지를 알 수 없게 된다.

• boolean isInterrupted() 메서드는 그저 interrupted 상태를 반환한다.

  class DownloadThread extends Thread {
    public void run() {
        ...
        while (downloaded && !isInterrupted()) {
            /*download 작업을 수행*/
            ...
        }
  
        System.out.println("다운로드가 끝났습니다.");
    }
  }

• while (downloaded && !isInterrupted())

  • downloaded 다운로드가 완료되서 while 문을 빠져나갈수도 있고
    !isInterrupted() 다운로드 도중 취소 버튼을 누르면 interrupted 상태가 true가 되고 !isInterrupted() == false가 되면서 while 문을 빠져나갈 수도 있다.

실습 예제

import javax.swing.JOptionPane;

class Ex13_9 {
    public static void main(String[] args) throws Exception {
        ThreadEx9_1 th1 = new ThreadEx9_1();
        th1.start();

        String input = JOptionPane.showInputDialog("아무 값이나 입력하세요.");
        System.out.println("입력하신 값은 " + input + " 입니다.");
        th1.interrupt();  // interrupted 상태를 true로 변경
        System.out.println("isInterrupted():"+ th1.isInterrupted()); // true
        System.out.println("isInterrupted():"+ th1.isInterrupted()); // true
        System.out.println("Interrupted():"+ th1.interrupted());
        System.out.println("Interrupted():"+ th1.interrupted()); 
    }
}

class ThreadEx9_1 extends Thread {
    public void run() {
        int i = 5;

        while(i!=0 && !isInterrupted()) {
            System.out.println(i--);
            for(long x=0;x<2500000000L;x++); // 시간 지연
        }
        System.out.println("카운트가 종료되었습니다.");
    }
}

5 4 3 2 입력하신 값은 apple 입니다. isInterrupted():true isInterrupted():true Interrupted():false Interrupted():false 카운트가 종료되었습니다.

• 카운트다운을 하다가 값을 입력하면 th1.interrupt() 메서드를 호출해서 카운트다운을 종료하는 프로그램이다.

System.out.println("isInterrupted():"+ th1.isInterrupted()); // true
System.out.println("isInterrupted():"+ th1.isInterrupted()); // true

• th1.isInterrupted() 메서드는 그저 interrupted 상태를 반환하기 때문에 몇번을 호출해도 true가 나온다.

System.out.println("Interrupted():"+ th1.interrupted());
System.out.println("Interrupted():"+ th1.interrupted()); 

Interrupted():false Interrupted():false

• th1.interrupted() 메서드는 interrupted 상태를 반환하고 false로 초기화시킨다. 예상한 결과는 true, false가 나와야 하는데 실제 결과는 두 번 모두 false가 나왔다. 왜 그런걸까 ?

• 이유는 interrupted() 는 static 메서드이기 때문에 현재 쓰레드를 반환한다. 즉, th1.interrupted()는 main쓰레드의 상태를 반환하는 것이다. 따라서 ThreadEx9_1 쓰레드 안에서 호출을 해줘야 한다.

수정된 코드🔽

import javax.swing.JOptionPane;

class Ex13_9 {
    public static void main(String[] args) throws Exception {
        ThreadEx9_1 th1 = new ThreadEx9_1();
        th1.start();

        String input = JOptionPane.showInputDialog("아무 값이나 입력하세요.");
        System.out.println("입력하신 값은 " + input + " 입니다.");
        th1.interrupt();  // interrupted 상태를 true로 변경
    }
}

class ThreadEx9_1 extends Thread {
    public void run() {
        int i = 5;

        while(i!=0 && !isInterrupted()) {
            System.out.println(i--);
            for(long x=0;x<2500000000L;x++); // 시간 지연
        }
        System.out.println("isInterrupted():"+ this.isInterrupted()); // true
        System.out.println("isInterrupted():"+ this.isInterrupted()); // true
        System.out.println("Interrupted():"+ Thread.interrupted());
        System.out.println("Interrupted():"+ Thread.interrupted()); 
        System.out.println("카운트가 종료되었습니다.");
    }
}

5 4 입력하신 값은 bbbb 입니다. isInterrupted():true isInterrupted():true Interrupted():true Interrupted():false 카운트가 종료되었습니다.

• this.isInterrupted()는 static 메서드가 아니기 때문에 main 쓰레드에서 th1.isInterrupted() 로 작성해도 문제가 없지만 해당 쓰레드안에서 작성할 때 this(생략가능) 붙여도 된다는걸 보여주기 위해 수정하였다.

• Thread.interrupted() : 이렇게 작성해야 예상했던대로 결과가 올바르게 출력된다.
  첫 번째 Thread.interrupted()는 true를 반환하고 false로 초기화
  두 번째 Thread.interrupted()는 초기화한 false를 반환

suspend(), resume(), stop()

쓰레드의 실행을 일시정지, 재개, 완정정지 시킨다. -> 이 3개의 메서드는 교착상태(dead-lock)에 빠지기 쉬워서 deprecated 되었다.

class Ex13_10 {
    public static void main(String[] args) {
        RunImplEx10 th1 = new RunImplEx10("*");
        RunImplEx10 th2 = new RunImplEx10("**");
        RunImplEx10 th3 = new RunImplEx10("***");
        th1.start();
        th2.start();
        th3.start();

        try {
            Thread.sleep(2000);
            th1.suspend();
            Thread.sleep(2000);
            th2.suspend();
            Thread.sleep(3000);
            th1.resume();
            Thread.sleep(3000);
            th1.stop();
            th2.stop();
            Thread.sleep(2000);
            th3.stop();
        } catch (InterruptedException e) {}
    } // main
}

class RunImplEx10 implements Runnable {
    volatile boolean suspended = false;
    volatile boolean stopped = false;

    Thread thread;

    public RunImplEx10(String name) {
        thread = new Thread(this, name);
    }

    public void start() {
        thread.start();
    }

    public void stop() {
        stopped = true;
    }

    public void suspend() {
        suspended = true;
    }

    public void resume() {
        suspended = false;
    }

    public void run() {
        while (!stopped) {
            if (!suspended) {
               System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                }
            }
        }
    } // run()
}

class RunImplEx10 implements Runnable {
    volatile boolean suspended = false;
    volatile boolean stopped = false;

    Thread thread;

    public RunImplEx10(String name) {
        thread = new Thread(this, name);
    }
    ...

• Runnable을 구현한 클래스 안에 Thread을 선언하고 생성자를 통해서 Thread 객체를 생성할 수 있다. 그럼 main메서드에서는 RunImplEx10 th1 = new RunImplEx10("*"); 이렇게 생성해주면 된다.

• volatile boolean suspended = false; : volatile을 붙이는 이유는 자주 바뀌는 변수이기 때문이다. 멀티 쓰래드 어플리케이션에서 각 쓰래드들은 성능적이 이유로 메인 메모리로 부터 변수를 읽어 CPU 캐시에 복사하고 작업한다. 이때 같은 변수에 대해 복사본을 가지고 각 쓰레드들이 작업을 하게 되면 동기화가 안되는 문제가 발생할 수 있다. 이를 방지하기 위해 volatile 키워드를 붙이게 되면 변수를 CPU 캐시에 복사하는게 아니라 메인 메모리에서 직접 변수를 가져와서 작업을 한다.

• suspended 변수와 stopped 변수를 선언하고 suspended(), start(), resume(), stop() 메서드를 만든 후 run() 메서드 안에 while (!stopped), if (!suspended) 두 조건문을 붙여주면 deprecated 경고가 안뜬다.

join()

: 지정된 시간동안 특정 쓰레드가 작업하는 것을 기다린다. void join() : 작업이 모두 끝날 때까지 기다린다. void join(long millis) : millis 시간동안 기다린다. (단위 천분의 일초) void join(long millis, int nanos) : 천분의 일초 + 나노초 동안 기다린다.

예외처리를 해야한다.(InterruptedException이 발생하면 작업 재개)

• sleep() 메서드와 똑같이 해당 작업을 중간에 빠져나오기 위해 InterruptedException을 이용하는 것이다.

  class Ex13_11 {
  static long startTime = 0;
  
  public static void main(String[] args) {
      ThreadEx11_1 th1 = new ThreadEx11_1();
      ThreadEx11_2 th2 = new ThreadEx11_2();
      th1.start();
      th2.start();
      startTime = System.currentTimeMillis();
  
      try {
          th1.join(); // main쓰레드가 th1의 작업이 종료될 때까지 기다린다.
          th2.join(); // main쓰레드가 th2의 작업이 종료될 때까지 기다린다.
      } catch (InterruptedException e) {
      }
  
      System.out.print("소요시간 : " + (System.currentTimeMillis() - Ex13_11.startTime));
  } // main
  }
  

class ThreadEx11_1 extends Thread { public void run() { for (int i = 0; i < 300; i++) { System.out.print("-"); } } // run() }

class ThreadEx11_2 extends Thread { public void run() { for (int i = 0; i < 300; i++) { System.out.print("|"); } } // run() }

>--|||||----------------------|||||||||------||||||||||||||||||||||||||||||||||||||||||||---------|||||||||||||||||||||||||||||||||||||||||||||||||||---------------|||||||||||||||||||||||||||||||||----------------------------------------|||||||--------------------------------------------------------------------------------------------------|||-----------------------|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||----|||||||||---------------------------------------------------------------------------------소요시간 : 14

- th1과 th2쓰레드가 모두 작업을 마칠 때까지 main쓰레드를 기다리게 한 뒤 소요시간을 출력한다. 

- `join()`을 주석처리하게 되면 main쓰레드는 th1과 th2.start()를 호출하고 소요시간 출력 후 종료되기 때문에 소요시간이 0이 찍힌다.

## yield()
**남은 시간을 다음 쓰레드에게 양보하고, 자신(현재 쓰레드)은 실행대기 상태가 된다.**

**yield()와 interrupt()를 적절히 사용하면, 응답성과 효율을 높일 수 있다.**
```java
public void run() {
    while (!stopped) {
        if (!suspended) {
           System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
        } else {
        Thread.yield();
        }
    }
} // run()
...

public void stop() {
    stopped = true;
    thread.interrupt();
}

public void suspend() {
    suspended = true;
    thread.interrupt();
}

• if (!suspended) -> false 이고 while (!stopped) -> true라면 쓰레드가 종료되지 않고 일시정지된 상태에서 while문만 계속 돌고 있는 상태가 된다. 이런 것을 busy-waint 상태라고 하고 이를 방지하기 위해 else { Thread.yield(); } 추가해줄 수 있다.

• stop(), suspend()에 interrupt()를 추가해 응답성을 높일 수 있다. 보통 쓰레드를 만들 때 특정 쓰레드가 작업을 독점하지 않도록 sleep() 메서드를 넣어준다. 그런데 만약 일시정지를 했을때 sleep() 메서드로 인해 쓰레드가 잠을 자고 있었다면 interrupt() 메서드로 그 즉시 sleep()을 빠져나가게 할 수 있도록 해야 한다. 이를 통해, 응답성을 높일수 있다.

yield() 메서드도 static 메서드이기 때문에 자기 자신한테만 사용할 수 있다.

하지만 yield() 또한 OS 스케쥴러에게 희망사항을 전달하는 것 뿐이다. 반드시 동작한다고 볼 수는 없다. 결국 OS 스케쥴러가 전체 프로그램들의 작업 효율을 따져 시간 배분을 한다.

📌쓰레드의 동기화(synchronization)

: 진행중인 작업이 다른 쓰레드에게 간섭하지 못하게 막는 것을 "동기화"라고 한다.

멀티 쓰레드 프로세스에서는 다른 쓰레드의 작업에 영향을 미칠 수 있다.

동기화하려면 간섭 받지 않아야 하는 문장들을 "임계 영역(critical section)"으로 설정한다.

임계 영역은 락(lock)을 얻은 단 하나의 쓰레드만 출입이 가능하다.(객체 1개마다 락 1개만 보유)

synchronized를 이용한 동기화

synchronized로 임계 영역을 설정하는 2가지 방법

1. 메서드 전체를 임계 영역으로 지정

   public synchronized void withdraw(int money) {
    if (balance >= money) {
        try {
            Thread.sleep(1000);
        } catch (Exception e) {}
   
        balance -= money;
    }
   }

2. 특정한 영역을 임계 영역으로 지정

   public void withdraw(int money) {
    synchronized(this) {
        if (balance >= money) {
            try {
                Thread.sleep(1000);
            } catch (Exception e) {}
   
            balance -= money;
        }
    } // synchronized(this)
   }

• 임계 영역은 개수도 최소화하고 영역도 최소화하는게 좋다. 임계 영역에는 1번에 1개의 쓰레드만 접근할 수 있기 때문에 너무 많이, 넓게 설정한다면 프로그램의 성능이 저하된다.

실습 예제

class Ex13_12 {
    public static void main(String[] args) {
        Runnable r = new RunnableEx12();
        new Thread(r).start();
        new Thread(r).start();
    }
}

class Account {
    private int balance = 500;

    public int getBalance() {
        return balance;
    }

    // 잔고(balance)에서 돈을 출금하는 메서드
    public void withdraw(int money) {
        if (balance >= money) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {}
            balance -= money;
        }
    } // withdraw
}

class RunnableEx12 implements Runnable {
    Account acc = new Account();

    public void run() {
        while (acc.getBalance() > 0) {
            int money = (int) (Math.random() * 3 + 1) * 100; // 100, 200, 300 중 랜덤한 money 생성
            acc.withdraw(money);
            System.out.println("balance:" + acc.getBalance());
        }
    } // run()
}

balance:400 balance:400 balance:300 balance:100 balance:0 balance:-100

withdraw() 메서드를 살펴보면 if (balance >= money) 이런 조건일 때만 메서드가 동작하게 되어있다. 즉, 잔고(balance)가 출금하려는 돈(money)보다 많거나 같을 때만 출금할 수 있는 것이다. 따라서 잔고는 -가 출력이 될 수 없는데 출력을 보면 -100이 출력되었다. 왜 그럴까? -> 이유는 두 쓰레드가 동시에 withdraw() 접근했기 때문이다. 예를 들어, 한 쓰레드가 잔고가 100일 때 withdraw()에 접근했다. 잔고가 남아있기 때문에 if 조건문을 통과하고 잔고에서 돈을 빼는 작업을 수행하려고 할 때 다른 쓰레드가 거의 동시에 withdraw() 접근하게 되면 이 쓰레드 또한 아직 잔고는 100이기 때문에 if 조건문을 통과하게 된다. 여기서 문제가 발생한다. 먼저 접근한 쓰레드가 돈을 빼가서 잔고가 0이 되었음에도 불구하고 나중에 접근한 쓰레드는 if 조건문을 이미 통과했기 때문에 0인 잔고에서 또 돈을 빼가는 상황이 벌어지고 결과적으로 balance:-100이 찍히게 되는 것이다.

이러한 문제를 해결하기 위해 나온것이 "동기화"이다.

동기화를 통해 문제를 해결한 소스 코드🔽

...
class Account {
    private int balance = 500; // private으로 설정해야 동기화가 의미가 있다.

    // 잔고를 확인하는 중간에 출금이 되면 안되니까 여기도 동기화를 설정해줘야 한다.
    public synchronized int getBalance() {
        return balance;
    }

    // 돈을 출금할 때는 한 쓰레드만 접근할 수 있도록 동기화 설정
    public synchronized void withdraw(int money) {
        if (balance >= money) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {}
            balance -= money;
        }
    } // withdraw
}
...

• 잔고(balance)는 private으로 설정해줘야 동기화하는 의미가 있다. 출금하는 메서드를 동기화해줘도 잔고 자체에 다른 쓰레드가 직접 접근을 해서 변경하면 동기화해주는 의미가 없기 떄문이다.

• withdraw()에 동기화를 해주는 것은 물론 getBalance() 또한 동기화를 해주어야 한다. getBalance()를 통해 잔고를 확인하는 동안에 출금하는 메서드가 수행되어 잔고가 바껴서는 안되기 때문이다. 잔고를 읽고 쓰는 메서드에는 모두 동기화해줘야 한다.

📌wait()과 notify()

동기화를 하게 되면 한번에 한 쓰레드만 접근할 수 있기 때문에 프로그램의 효율이 떨어진다. 동기화의 효율을 높이기 위해 wait(), notify()를 사용한다.

실습 예제

import java.util.ArrayList;

class Customer2 implements Runnable {
    private Table2 table;
    private String food;

    Customer2(Table2 table, String food) {
        this.table = table;
        this.food = food;
    }

    public void run() {
        while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
            String name = Thread.currentThread().getName();

            table.remove(food);
            System.out.println(name + " ate a " + food);
        } // while
    }
}

class Cook2 implements Runnable {
    private Table2 table;

    Cook2(Table2 table) {
        this.table = table;
    }

    public void run() {
        while (true) {
            int idx = (int) (Math.random() * table.dishNum());
            table.add(table.dishNames[idx]);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
            }
        } // while
    }
}

class Table2 {
    String[] dishNames = {"donut", "donut", "burger"};
    final int MAX_FOOD = 6;
    private ArrayList<String> dishes = new ArrayList<>();

    public synchronized void add(String dish) {
        // while문 : 테이블에 음식이 가득찼으면 COOK 쓰레드 wait()
        while (dishes.size() >= MAX_FOOD) {
            String name = Thread.currentThread().getName();
            System.out.println(name + " is waiting.");
            try {
                wait();
                Thread.sleep(500);
            } catch (InterruptedException e) {}
        }
        dishes.add(dish);
        // 음식을 추가했으니 waiting pool에서 대기중인 CUST 쓰레드 notify()
        notify();
        System.out.println("Dishes:" + dishes.toString());
    }

    public void remove(String dishName) {
        synchronized (this) {
            String name = Thread.currentThread().getName();

            while (dishes.size() == 0) {
                System.out.println(name + " is waiting.");
                try {
                    // 테이블에 음식이 없으니 CUST 쓰레드 wait()
                    wait();
                    Thread.sleep(500);
                } catch (InterruptedException e) {}
            }

            while (true) {
                for (int i = 0; i < dishes.size(); i++) {
                    if (dishName.equals(dishes.get(i))) {
                        dishes.remove(i);
                        // 음식을 하나 먹었으니 테이블이 꽉차서 waiting pool에 있던 COOK 쓰레드 notify()
                        notify();
                        return;
                    }
                }

                try {
                    System.out.println(name + " is waiting.");
                    // 위의 for 문에서 자기가 원하는 음식을 찾지 못한 CUST 쓰레드 wait()
                    wait();
                    Thread.sleep(500);
                } catch (InterruptedException e) {}
            } // while(true)
        } // synchronized
    }

    public int dishNum() {
        return dishNames.length;
    }
}

class Ex13_15 {
    public static void main(String[] args) throws Exception {
        Table2 table = new Table2();

        // 요리사 쓰레드
        new Thread(new Cook2(table), "COOK").start();
        // donut만 먹는 CUST1 쓰레드, burger만 먹는 CUST2 쓰레드
        new Thread(new Customer2(table, "donut"), "CUST1").start();
        new Thread(new Customer2(table, "burger"), "CUST2").start();
        Thread.sleep(2000);
        System.exit(0);
    }
}

• 총 4개의 쓰레드가 있다.
  • 2초 일시정지했다가 프로그램을 종료해버리는 main 쓰레드
  • donut, burger 2가지 음식을 만드는 COOK 쓰레드
  • donut만 먹는 CUST1 쓰레드
  • burger만 먹는 CUST2 쓰레드

• Table 클래스에는 음식을 만드는 add()와 음식을 먹는(제거하는) remove()가 있다. 이 두 메서드는 여러 쓰레드가 동시에 접근하면 안되기 때문에 동기화를 해주었다.

wait()

public synchronized void add(String dish) {
    // while문 : 테이블에 음식이 가득찼으면 COOK 쓰레드 wait()
    while (dishes.size() >= MAX_FOOD) {
        String name = Thread.currentThread().getName();
        System.out.println(name + " is waiting.");
       try {
            wait();
            Thread.sleep(500);
        } catch (InterruptedException e) {}
    }
    ...

• COOK 쓰레드는 Table 객체에 dishes라는 ArrayList에 add()를 통해서 음식을 추가한다. 이때 dishes.size()가 MAX_FOOD 이상이 되면 wait() 을 통해 락을 풀고 waiting pool에서 음식이 제거될 때까지 대기한다.

public void remove(String dishName) {
    synchronized (this) {
        String name = Thread.currentThread().getName();

        while (dishes.size() == 0) {
            System.out.println(name + " is waiting.");
            try {
                // 테이블에 음식이 없으니 CUST 쓰레드 wait()
                wait();
                Thread.sleep(500);
            } catch (InterruptedException e) {}
        }
        ...

• CUST 쓰레드는 remove()로 음식을 먹는다. 만약, dishes.size()가 0이라면 음식이 없다는 뜻이고 이때 CUST 쓰레드는 wait() 을 통해 락을 풀고 waiting pool에서 음식이 추가될 때까지 대기한다.

public void remove(String dishName) {
    synchronized (this) {
        String name = Thread.currentThread().getName();
        while (dishes.size() == 0) {
            ...
       }

       while (true) {
           for (int i = 0; i < dishes.size(); i++) {
               if (dishName.equals(dishes.get(i))) {
                   dishes.remove(i);
                   // 음식을 하나 먹었으니 테이블이 꽉차서 waiting pool에 있던 COOK 쓰레드 notify()
                   notify();
                   return;
               }
           }

           try {
               System.out.println(name + " is waiting.");
               // 위의 for 문에서 자기가 원하는 음식을 찾지 못한 CUST 쓰레드 wait()
               wait();
               Thread.sleep(500);
           } catch (InterruptedException e) {}
       } // while(true)
   } // synchronized
}

• remove()의 두 번째 while 문에서 CUST 쓰레드는 음식을 먹는 작업을 수행한다.(두 번째 while 문안의 for 문) CUST1 쓰레드는 도넛만 먹고 CUST2 쓰레드는 버거만 먹는데 dishes에 원하는 음식이 없다면 for 문을 통과하게 되고 이때 자기가 원하는 음식이 나올 때까지 wait() 을 통해 락을 풀고 waiting pool에서 대기한다.

notify()

public synchronized void add(String dish) {
    ...
    dishes.add(dish);
        // 음식을 추가했으니 waiting pool에서 대기중인 CUST 쓰레드 notify()
    notify();
    System.out.println("Dishes:" + dishes.toString());
}

• 음식이 추가됐으니 아까 dishes.size()가 0이어서 wait() 했던 CUST 쓰레드를 notify()를 통해 깨운다.

public void remove(String dishName) {
    synchronized (this) {
        String name = Thread.currentThread().getName();
        while (dishes.size() == 0) {
            ...
       }

       while (true) {
           for (int i = 0; i < dishes.size(); i++) {
               if (dishName.equals(dishes.get(i))) {
                   dishes.remove(i);
                   // 음식을 하나 먹었으니 테이블이 꽉차서 waiting pool에 있던 COOK 쓰레드 notify()
                   notify();
                   return;
               }
            }
            ...
       } // while(true)
   } // synchronized
}

• 두 번째 while 문안에서 for 문을 통해 음식을 하나 먹었으니 아까 dishes.size()가 꽉차서 wait()로 대기중인 COOK 쓰레드를 notify()를 통해 깨운다.

예제에서도 알 수 있듯이 wait(), notify() 어떤 쓰레드를 대기시키고 깨우는지 알 수 없다. 이를 보완하기 위해 Lock 인터페이스와 Condition 인터페이스가 나왔다.이 두 인터페이스를 이용하면 쓰레들을 구분해서 작업할 수 있다.

자바 객체지향 프로그래밍은 프로그램을 객체라는 단위로 나누고 이들 객체 간의 상호작용으로 프로그램을 구성하는 방식입니다. 객체는 데이터와 데이터를 다루는 메서드로 이루어져 있으며 이러한 객체들은 클래스라는 틀을 이용하여 생성됩니다.

객체지향 프로그래밍은 캡슐화, 상속, 추상화, 다형성 등의 개념을 기반으로 하며, 이를 통해 프로그램의 유지보수와 확장을 용이하게 만들고 코드의 가독성과 재사용성을 높일 수 있습니다.

• 캡슐화는 객체의 데이터와 메서드를 하나로 묶고, 외부에서 직접 접근하지 못하도록 정보를 은닉하는 것을 의미합니다. 객체의 내부 구현 세부사항을 숨김으로써, 객체 간의 결합도가 느슨해지고 코드의 변화와 확장에 용이해집니다.

• 상속은 상위 클래스(부모 클래스)의 특성을 하위 클래스(자식 클래스)가 물려받아 사용할 수 있도록 하는 것을 의미합니다. 상속을 통해 클래스 간의 관계를 형성하고, 하위 클래스는 상위 클래스의 모든 멤버를 물려받기 때문에 코드의 재사용성을 높일 수 있습니다.

• 추상화는 객체의 복잡한 세부사항을 숨기고, 핵심적인 부분만을 표현하는 것을 의미합니다. 즉, 여러 클래스들의 공통되는 부분을 뽑아내서 추상 클래스 혹은 인터페이스로 만드는 것입니다. 이를 통해, 구체적인 구현에 의지하는 것이 아닌 추상적인 역할에 의지할 수 있게 되고 코드의 중복이 줄어들고 코드의 가독성이 향상됩니다.

• 다형성은 하나의 객체가 여러가지 형태를 가질 수 있는 것을 의미합니다. 즉, 상위타입의 참조변수로 타입의 객체를 다룰 수 있습니다. 예를 들어, 참조형 매개변수를 가진 메서드를 호출할 때, 하위타입의 인스턴스를 넘겨줄 수 있고 상위타입의 배열에 하위타입의 객체를 담을 수 있습니다. 이를 통해, 코드의 유연성과 확장성이 높아집니다.

📌OOP의 장점과 단점에 대해 설명해주세요.

OOP의 장점에는 여러가지가 있습니다.

• 상속을 통해 기존의 클래스를 확장하고, 추상화를 통해 공통적인 부분을 추출하여 코드의 재사용성을 높일 수 있습니다.

• 캡슐화를 통해 내부 구현 세부사항을 외부로부터 숨기고, 필요한 부분만 드러냄으로써 외부에서의 예측하지 못한 상태 변경에 대한 영향을 최소화할 수 있습니다. 이로 인해 코드의 안정성과 보안성이 향상되고, 객체 간의 결합도가 낮아져 코드의 유지보수가 쉬워집니다.

• 다형성을 통해 상위타입의 참조변수로 하위타입의 여러 객체를 다룰 수 있고, 상속을 통해 확장이 쉬워지므로, 코드의 유연성이 높아집니다.

• 추상화를 통해 객체의 복잡한 세부사항을 숨기고 공통적인 부분만을 모아 표현하기 때문에 코드의 가독성이 높아집니다.

단점은 실행 속도가 상대적으로 느리다는 것입니다. 객체를 많이 만들어 놓으니 절차지향언어에 비해 실행 속도가 상대적으로 느리다고 합니다. 또한 설계시 많은 시간과 노력이 필요하다는 것도 단점 중 하나입니다.

📌추상 클래스와 인터페이스의 차이는 무엇인가요?

추상 클래스는 추상 메서드를 포함하고 있는 클래스를 말하고 인터페이스는 추상 메서드로만 이루어져 있는 것을 말합니다. 추상 클래스는 일바 클래스처럼 인스턴스 변수, 인스턴스 메서드, 생성자 등을 가질 수 있지만 인터페이스는 위의 것들을 가질 수 없습니다. 추상 클래스는 다중상속이 불가능하지만, 인터페이스는 다중상속이 가능합니다.

📌컬렉션과 스트림의 차이에 대해서 설명해주세요.

1. 데이터를 다루는 목적이 다릅니다. 컬렉션은 데이터를 저장하고 조회하는 것이 목적입니다. 예를 들어, List를 순회하며 요소를 삭제하거나 추가할 수 있습니다. 스트림은 데이터를 처리하는 것이 목적입니다. 스트림을 사용하면 데이터를 필터링, 매핑, 정렬 등의 다양한 작업을 수행할 수 있습니다.

2. 데이터를 반복 처리하는 방식이 다릅니다. 컬렉션은 명시적인 for-each 루프나 iterator 반복자를 사용하여 데이터를 외부 반복을 통해 처리합니다. 스트림은 내부 반복을 사용하여 데이터를 처리합니다. 스트림은 내부적으로 for-each 루프를 사용하지만 개발자가 이를 직접 구현할 필요가 없습니다.

3. 다루는 데이터 소스의 유형이 다릅니다. 컬렉션은 메모리에 저장된 데이터를 처리합니다. 즉, 모든 데이터가 메모리에 로드되어 있으므로 데이터를 쉽게 검색하고 수정할 수 있습니다. 스트림은 컬렉션, 배열, 파일 등 다양한 데이터 소스를 처리할 수 있습니다. 스트림은 데이터를 순차적으로 읽어 들이는 방식으로 처리되므로, 전체 데이터를 한 번에 로드하지 않아도 됩니다. 이러한 특성은 대용량의 데이터를 처리할 때 유용합니다.

프로세스 : 실행 중인 프로그램. 자원(resources)과 쓰레드로 구성

• 자원 : 메모리, CPU, 하드 디스크, 키보드 등

쓰레드 : 프로세스 내에서 실제 작업을 수행. 모든 프로세스는 최소한 하나의 쓰레드를 가지고 있다.

• 싱글쓰레드 프로세스 = 자원 + 쓰레드
• 멀티쓰레드 프로세스 = 자원 + 쓰레드 + 쓰레드 +...+ 쓰레드

프로세스 : 쓰레드 = 공장 : 일꾼

하나의 새로운 프로세스를 생성하는 것보다 하나의 새로운 쓰레드를 생성하는 것이 더 적은 비용이 든다.

• 2 프로세스 1 쓰레드 vs 1 프로세스 2 쓰레드

• 1 프로세스 2 쓰레드가 더 효율적

📌멀티쓰레드의 장단점

대부분의 프로그램이 멀티쓰레드로 작성되어 있다. 하지만 멀티쓰레드 프로그래밍이 장점만 있는 것은 아니다.

장점

• 시스템 자원을 보다 효율적으로 사용할 수 있다.

• 사용자에 대한 응답성이 향상된다.

• 작업이 분리되어 코드가 간결해진다.

  단점

• 동기화(synchronization)에 주의해야 한다.

  쓰레드 동기화는 여러 쓰레드가 동일한 리소스를 공유하여 사용하게 되면 서로의 결과에 영향을 주기 때문에 이를 방지하는 기법이다.

• 교착상태(dead-lock)가 발생하지 않도록 주의해야 한다.

  교착상태(dead-lock) : 둘 이상의 작업이 서로 상대방 작업이 끝나기만 기다리고 있어서 서로 다음 단계로 진행하는 못하는 상태로 서로 무한 대기 상태로 빠지게 된다.

• 기아가 발생하지 않도록 각 쓰레드가 효율적으로 고르게 실행될 수 있도록 해야 한다.

  기아 : 특정 쓰레드보다 우선순위가 높은 쓰레드만 계속 실행되면서 특정 쓰레드가 실행될 기회를 얻지 못하는 상태

📌쓰레드의 구현과 실행

구현

쓰레드를 구현하는 방법은 2가지가 있다. Thread 클래스를 상속 Runnable 인터페이스를 구현

상속으로 구현을 하게 되면 자바는 단일 상속이기 때문에 다른 클래스를 상속 못한다는 단점이 있다. 그래서 일반적으로 Runnable 인터페이스를 구현 방법을 사용한다.

1. Thread 클래스를 상속

   class Thread1 extends Thread {
    public void run() {
    /*작업내용*/
    }
   }

• run() 메서드는 Thread 클래스의 run() 메서드를 오버라이딩한 것이다.

2. Runnable 인터페이스를 구현

   class Thread2 implements Runnable {
    public void run() {
    /*작업내용*/
    }
   }

• run() 메서드는 Runnable 인터페이스의 run() 추상 메서드를 구현한 것이다.

실행

class Ex13_1 {
    public static void main(String[] args) {
        Thread1 t1 = new Thread1();

        Runnable r = new Thread2();
        Thread t2 = new Thread(r); // 생성자 Thread(Runnable target)

        t1.start();
        t2.start();
    }
}

class Thread1 extends Thread {
    public void run() { // 쓰레드가 수행할 작업을 작성
        for (int i = 0; i < 5; i++) {
            // 조상인 Thread의 getName()을 호출
            System.out.printf("(%s)%n", getName());
        }
    }
}

class Thread2 implements Runnable {
    public void run() {
        for (int i = 0; i < 5; i++) {
            // 현재 실행중인 Thread의 이름을 반환
            System.out.printf("(%s)%n", Thread.currentThread().getName());
        }
    }
}

(Thread-0) (Thread-0) (Thread-0) (Thread-1) (Thread-1) (Thread-1) (Thread-1) (Thread-1) (Thread-0) (Thread-0)

• t1.start()을 먼저 적어줬다고 해서 t1이 먼저 실행되지는 않는다. 이는 OS의 스케쥴러가 결정해준다.
• 실행할 때마다 순서는 바뀔 수 있다.

  Runnable r = new Thread2();
  Thread t2 = new Thread(r); // 생성자 Thread(Runnable target)

• Runnable을 구현한 쓰레드는 객체를 생성할 때 생성자 Thread(Runnable target)를 이용해줘야 한다.
• Thread t2 = new Thread(new Thread2()); : 이렇게 한 줄로 바꿔줄 수도 있다.

// 조상인 Thread의 getName()을 호출
System.out.printf("(%s)%n", getName());
...
// 현재 실행중인 Thread의 이름을 반환
System.out.printf("(%s)%n", Thread.currentThread().getName());

• Thread를 상속한 쓰레드는 조상의 메서드인 getName()을 호출해서 쓰레드의 이름을 출력할 수 있다.
• Runnable을 구현한 쓰레드는 Thread.currentThread().getName()); 메서드를 통해서 현재 쓰레드의 이름을 반환할 수 있다.

start()

쓰레드를 생성한 후에 start()를 호출해야 쓰레드가 작업 가능한 상태가 된다.

t1.start();
t2.start();

• start()를 호출하면 쓰레드가 실행 가능한 상태가 되는 것이지 실행이 되는 것이 아니다. 실제로 언제 실행이 될지는 OS의 스케쥴러가 실행 순서를 결정한다.

• t1.start(); 먼저 적는다고 해도 먼저 호출되는 것이 아니다.

run() 메서드를 통해 수행할 작업을 작성했지만 호출은 start() 메서드로 하는 이유

1. 호출 스택에서 start() 메서드가 새로운 호출 스택 생성

2. start() 메서드는 종료되고 새로운 호출 스택에서 run() 메서드가 동작함으로써 서로 독립적인 작업 수행이 가능(멀티쓰레드)

t1.start();가 아닌 t1.run();을 하게될 경우

• 멀티쓰레드가 아닌 main쓰레드에서 싱글쓰레드로 동작하게 된다.

📌main쓰레드

: main메서드의 코드를 수행하는 쓰레드

쓰레드는 "사용자 쓰레드"와 "데몬 쓰레드" 두 종류가 있다.

• 데몬 쓰레드는 보조 쓰레드 개념이다.
• 실행 중인 사용자 쓰레드가 하나도 없을 때 프로그램은 종료된다.(데몬 쓰레드의 실행 여부는 신경X)

public class MainThread {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyThread1());
        Thread t2 = new Thread(new MyThread2());

        t1.start();
        t2.start();

        for (int i = 0; i < 100; i++) {
            System.out.print(0);
        }
    }
}

class MyThread1 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.print(1);
        }
    }
}

class MyThread2 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.print(2);
        }
    }
}

00002112222222222222222222222220000000000000000000000000000000000000000000000022222222222222222221111111111111222222222222222222220000000000000000000000000000000000000000000000000main쓰레드 종료시점222222222222222222222222222222222222MyThread2 종료시점1111111111111111111111111111111111111111111111111111111111111111111111111111111111111MyThread1 종료시점

• main, MyThread2, MyThread1 총 3개의 "사용자 쓰레드"가 모두 종료될 때까지 프로그램은 종료되지 않는다.

📌싱글쓰레드와 멀티쓰레드

싱글쓰레드

public class MainThread {
        for (int i = 0; i < 100; i++) {
            System.out.print(0);
        }
        for (int i = 0; i < 100; i++) {
            System.out.print(1);
        }
    }
}

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

• 0을 다 출력하고나서 1이 출력된다.

멀티쓰레드

public class MainThread {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyThread1());

        t1.start();

        for (int i = 0; i < 100; i++) {
            System.out.print(0);
        }
    }
}

class MyThread1 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.print(1);
        }
    }
}

01000000000000000000000000000000111111111111110000000000000000000000000000000000000000000000000000010011111111111111111111111111111111111111111111111111111111111111100000000000000111111111111111111111

• 멀티쓰레드로 작성하면 0과 1이 번갈아가면서 출력된다.

싱글쓰레드와 멀티쓰레드 그래프

싱글쓰레드와 멀티쓰레드를 그래프로 그려보면 다음과 같다.

• 가로축을 보게 되면 멀티쓰레드가 시간이 약간 더 걸린다는 것을 알 수 있다. 그 이유는 main쓰레드가 실행되다가 t1쓰레드가 실행되면 쓰레드 간의 작업 전환(context switching)이 발생하면서 시간이 조금씩 소모하기 때문이다.

• 사실 위의 멀티쓰레드 그래프는 이상적인 그래프이다. 해당 쓰레드가 언제 얼마만큼 실행될지는 OS의 스케쥴러가 결정하기 때문에 실제로는 위의 그래프처럼 일정한 시간동안 두 쓰레드가 번갈아가며 실행되지 않는다. OS 스케쥴러는 OS 전체의 프로세스와 쓰레드를 총괄하기 때문에 시시각각 변하는 모든 프로레스와 쓰레드의 상황을 고려해서 실행순서와 실행기간을 정해 스케쥴링을 한다. 따라서, 우리가 작성한 쓰레드는 실행할 때마다 결과가 달라지는 것이다.

쓰레드의 I/O 블락킹(blocking)

싱글쓰레드로 작성

import javax.swing.JOptionPane;

class Ex13_4 {
    public static void main(String[] args) throws Exception {
        String input = JOptionPane.showInputDialog("아무 값이나 입력하세요.");
        System.out.println("입력하신 값은 " + input + "입니다.");

        for (int i = 5; i > 0; i--) {
            System.out.println(i);
            try {
                Thread.sleep(500);
            } catch (Exception e) {
            }
        }
    }
}

• 입력을 받을 때까지 다음 작업은 실행되지 않고 대기상태에 머무르게 된다. 즉, for 문(카운트다운)이 실행되지 않는다. 이것을 I/O Blocking 이라고 한다.

멀티쓰레드로 작성

import javax.swing.JOptionPane;

class Ex13_4 {
    public static void main(String[] args) throws Exception {
        Thread t1 = new ThreadEx5();
        t1.start();

       String input = JOptionPane.showInputDialog("아무 값이나 입력하세요.");
        System.out.println("입력하신 값은 " + input + "입니다.");
    }
}

class ThreadEx5 extends Thread {
    public void run() {
        for (int i = 5; i > 0; i--) {
            System.out.println(i);
            try {
                sleep(500);
            } catch (Exception e) {
            }
        }
    }
}

• 멀티쓰레드로 작성하게 되면 입력을 받지 않아도 멀티쓰레드인 t1쓰레드가 실행되면서 for 문(카운트다운)이 동작하게 된다.

결론 : 멀티쓰레드를 통해서 I/O Blocking을 해결할 수 있다.

📌쓰레드의 우선순위(Priority of thread)

: 작업의 중요도에 따라 쓰레드의 우선순위를 다르게 하여 특정 쓰레드가 더 많은 작업 시간을 갖게 할 수 있다.

void setPriority(int newPriority) : 지정한 값으로 우선순위 변경 int getPriority() : 우선순위 반환 우선순위 범위 : 1 (최소) ~ 10 (최대) 우선순위 default 값 : 5 main쓰레드 우선순위 : 5

JVM의 우선순위는 범위가 1 ~ 10으로 지정할 수 있도록 정해져있고 Windows OS의 경우에는 우선순위 범위가 32단계로 나뉘어져 있다. JVM에서 설정된 쓰레드들의 우선순위를 OS 스케줄러에 전달하는 것이다.

그러나 우리가 쓰레드들의 우선순위를 각자 지정한다고 현재 OS 전체 작업을 다 제끼고 우선적으로 설정되는 것이 아니라 그저 희망 사항을 스케쥴러에 전달하는 것 뿐이다.

OS 스케쥴러는 우리가 전달한 희망 사항을 참고할 뿐 결국 OS 내에서 돌아가는 전체 프로그램들의 작업 효율을 따져 실행 순서를 정한다.

📌쓰레드 그룹

서로 관련된 쓰레드를 그룹으로 묶어서 다루기 위한 것

모든 쓰레드는 반드시 하나의 쓰레드 그룹에 포함되어 있어야 하고 쓰레드 그룹을 지정하지 않고 생성한 쓰레드는 자동으로 main쓰레드 그룹에 속한다.

자신을 생성한 쓰레드(부모 쓰레드)의 그룹과 우선순위를 상속받는다.

Thread 생성자

Thread(ThreadGroup group, String name) // Thread 클래스 상속받아서 만들어진 경우
Thread(ThreadGroup group, Runnable target) // Runnable 인터페이스 구현해서 만들어진 경우 
Thread(ThreadGroup group, Runnable target, String name)
Thread(ThreadGroup group, Runnable target, String name , long stackSize) // 생성할 호출스택 사이즈 설정 

쓰레드 그룹 메서드

void uncaughtException(Thread th, Throwable e) 메서드

• 쓰레드 그룹에 있는 쓰레드가 예외처리를 하지 못하고 종료되었을 때 실행될 예외처리 동작을 오버라이딩 해주는 메서드. JVM에 의해 자동적으로 호출된다.

class Demo implements Runnable {
    @Override
    public void run() {
        int x = 10 / 0; // ArithmeticException 발생
    }
}

class MyHandler implements Thread.UncaughtExceptionHandler {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println("쓰레드 " + t.getName() + "에서 " + e.getMessage() + " 발생");
        // 로깅 작업 등을 할 수 있다.
    }
}

public class GFG {
    public static void main(String[] args) {
        Thread t = new Thread(new Demo());
        t.setUncaughtExceptionHandler(new MyHandler()); // uncaughtException 설정
        t.start();
    }
}

쓰레드 Thread-0에서 / by zero 발생

실습 예제

public class MainThread {
    public static void main(String[] args) {
        ThreadGroup root = new ThreadGroup("rootGroup"); // 루트 그룹 생성
        ThreadGroup childGroup = new ThreadGroup(root, "childGroup"); // 루트 그룹에 속하는 자식 그룹 생성
        rootThread rt = new rootThread(root, "rt"); // 루트 그룹에 속하는 쓰레드 생성
        Thread ch1 = new Thread(childGroup, new childThread1(), "ch1"); // 자식 그룹에 속하는 쓰레드 생성
        Thread ch2 = new Thread(new childThread2(), "ch2"); // 쓰레드 그룹 미지정 -> 자동으로 main쓰레드 그룹에 속함

        rt.start(); // 루트 그룹의 쓰레드 시작
        ch1.start(); // 자식 그룹의 쓰레드 시작
        ch2.start(); // main쓰레드 그룹의 쓰레드 시작

        root.list(); // 루트 그룹과 하위 그룹들의 정보 출력
        System.out.println();
    }
}

class childThread1 implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "가 속한 쓰레드 그룹 : " + Thread.currentThread().getThreadGroup().getName());
    }
}

class childThread2 implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "가 속한 쓰레드 그룹 : " + Thread.currentThread().getThreadGroup().getName());
    }
}

class rootThread extends Thread {
    public rootThread(ThreadGroup group, String name) {
        super(group, name);
    }

    @Override
    public void run() {
        System.out.println(getName() + "가 속한 쓰레드 그룹 : " + getThreadGroup().getName()); // rt의 쓰레드 그룹 이름 출력
    }
}

• 쓰레드에 어떤 명령을 내릴 때 쓰레드 그룹에 한번에 명령을 내릴 수 있다.

• rootThread rt = new rootThread(root, "rt"); : Thread(ThreadGroup group, String name) 생성자 사용

• Thread ch1 = new Thread(childGroup, new childThread1(), "ch1"); : Thread(ThreadGroup group, Runnable target, String name) 생성자 사용

• 쓰레드를 생성할 땐 생성자를 통해 쓰레드 그룹을 지정해줘야 하지만 지정해주지 않으면 자동으로 main쓰레드 그룹에 속하게 된다. -> Thread ch2 = new Thread(new childThread2(), "ch2");

📌데몬 쓰레드(Daemon thread)

: 일반 쓰레드의 작업을 돕는 보조적인 역할을 수행하는 쓰레드

일반 쓰레드가 모두 종료되면 자동적으로 종료된다.(일반 쓰레드의 보조적인 역할로써 일반 쓰레드가 종료되면 존재의 의미가 없어지기 때문에)

데몬 쓰레드 예시 : 가비지 컬렉터(GC), 자동 저장, 화면 자동갱신 등

데몬 쓰레드 작성 방법

: 무한루프와 조건문을 이용해서 실행 후 대기 상태에 있다가 특정 조건이 만족되면 작업을 수행하고 다시 대기하도록 작성

• boolean isDaemon() : 쓰레드가 데몬 쓰레드인지 확인. 데몬 쓰레드면 true 반환

• void setDaemon(boolean on) : 쓰레드를 데몬 쓰레드로 또는 일반 쓰레드로 변경. 매개변수로 true를 지정하면 데몬 쓰레드가 된다.

• void setDaemon(boolean on)는 반드시 start() 메서드를 호출하기 전에 실행되어야 한다. 그렇지 않으면 IllegalThreadStateException 발생*

class Ex13_7 implements Runnable {
    static boolean autoSave = false;

    public static void main(String[] args) {
        Thread t = new Thread(new Ex13_7());
        t.setDaemon(true); // 쓰레드 t를 데몬 쓰레드로 변경
        t.start();

        for (int i = 1; i <= 10; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            System.out.println(i);

            if (i == 5) autoSave = true; // 5초가 지나면 autoSave를 true로 설정
        }

        System.out.println("프로그램을 종료합니다.");
    }

    public void run() {
        while (true) { // 무한루프로 작성
            try {
                Thread.sleep(3 * 1000);
            } catch (InterruptedException e) {
            }

            if (autoSave) autoSave(); // autoSave가 true 조건을 만족할 때만 작업을 수행
        }
    }

    public void autoSave() {
        System.out.println("작업 파일이 자동 저장 되었습니다.");
    }
}

1 2 3 4 5 작업 파일이 자동 저장 되었습니다. 6 7 8 작업 파일이 자동 저장 되었습니다. 9 10 프로그램을 종료합니다.

• 5초 이후 autoSave를 true로 변경하고 이 때부터 데몬 쓰레드의 if 조건문이 true가 되면서 3초마다 자동 저장하는 데몬 쓰레드가 동작한다.

• 일반 쓰레드가 10초 후 프로그램 종료가 되도록 설정되었기 때문에 10초 후 데몬 쓰레드도 자동적으로 종료된다.

• t.setDaemon(true); : 쓰레드 t를 데몬 쓰레드로 변경. 반드시 start() 메서드 전에 실행되어야 한다.

📌쓰레드의 상태

• 쓰레드가 생성되었지만 아직 start() 메서드가 호출되기 전을 NEW 상태라고 한다.

• 실행 뿐만 아니라 실행 후에 다시 자신 차례가 올 때까지 실행 대기를 하는 상태 또한 RUNNABLE 상태라고 한다.

• 작업을 다 마치거나 stop() 메서드가 호출되면 TERMINATED 상태가 된다.

• suspend() ↔ resume()

  • suspend() 메서드가 호출되면 쓰레드가 WAITING / BLOCKED 상태가 된다.
  • resume() 메서드를 호출하면 다시 RUNNALBLE 상태가 된다.

• sleep() ↔ time-out, interrupt()

  • sleep() 메서드가 호출되면 쓰레드가 지정한 시간동안 WAITING / BLOCKED 상태가 된다.
  • 지정된 시간이 모두 지나면 time-out이 되고 다시 RUNNALBLE 상태가 된다.
  • 지정된 시간이 모두 지나기 전에 interrupt() 메서드를 호출하면 중간에 바로 RUNNABLE 상태가 된다.

• wait() ↔ notify()

  • wait() 메서드가 호출되면 쓰레드가 WAITING / BLOCKED 상태가 된다.
  • notify() 메서드를 호출하면 다시 RUNNALBLE 상태가 된다.

• join() : 지정한 다른 쓰레드가 종료될 때까지 기다리는 메서드

  • Ex) main 쓰레드에서 t1.join() 을 호출하면 main 쓰레드는 t1 쓰레드가 종료될 때까지 일시정지 상태에 있게 된다.

• I/O block : 입출력이 완료될 때까지 대기

suspend() vs wait()

suspend()와 wait()는 자바에서 쓰레드를 일시 정지시키는 메서드이다. 그러나 두 메소드는 다음과 같은 차이점이 있습니다.

• suspend()는 쓰레드가 속한 Thread 클래스의 메서드이고,
  wait()는 모든 객체가 상속하는 Object 클래스의 메서드이다.

• suspend()는 쓰레드를 일시 정지시키면서 락을 해제하지 않는다. 이로 인해 다른 쓰레드가 공유 자원에 접근할 수 없게 되어 교착 상태(dead-lock)가 발생할 수 있다.
  반면 wait()는 쓰레드를 일시 정지시키면서 락을 해제한다. 이로 인해 다른 쓰레드가 공유 자원에 접근하고 통지(notify)를 보낼 수 있다.

• suspend()는 resume() 메서드로만 재개될 수 있다. 이 때 resume() 메서드가 호출되기 전에 suspend()된 쓰레드가 종료되면 문제가 발생할 수 있다.
  반면 wait()는 notify(), notifyAll(), interrupt(), time-out 등의 방법으로 재개될 수 있다.

따라서 suspend()와 resume()은 권장되지 않는 방법이며, 대신 wait()/notify(), sleep()/interrupt() 등의 방법을 사용하는 것이 더 좋다.

: 서로 관련된 상수들을 같이 묶어 놓은 것.

class Card {
    static final int CLOVER = 0;
    static final int HEART = 1;
    static final int DIAMOND = 2;
    static final int SPADE = 3;

    static final int TWO = 0;
    static final int THREE = 1;
    static final int FOUR = 2;
}

열거형 사용🔽

class Card {
    enum Kind {CLOVER, HEART, DIAMOND, SPADE} 
    enum Value {TWO, THREE, FOUR}

    final Kind kind;
    final Value value;
}

• 값은 0부터 자동으로 매겨진다. CLOVER = 0, HEART = 1, DIAMOND = 2, SPADE = 3

if(Card.CLOVER == Card.TWO) // true

• 결과는 true로 나오지만 의미상으로는 false가 나와야 맞는 조건이다. 열거형 비교🔽

  if(Card.Kind.CLOVER == Card.Value.TWO) // 컴파일 에러

• 자바의 열거형은 값과 타입을 모두 체크하기 때문에 타입이 다르다고 컴파일 에러가 난다. 이러한 이유 때문에 자바는 타입에 안전한 열거형을 제공한다고 한다.

열거형의 정의와 사용

정의 enum 열거형 이름 {상수명1, 상수명2 ...}

예시) enum Direction {EAST, SOUTH, WEST, NORTH}

열거형 타입의 변수를 선언하고 사용

class Unit {
    Direction dir = Direction.EAST;
    ...
}

열거형 상수의 비교는 == 와 compareTo() 사용 가능

if (dir == Direction.EAST) { // OK
    ...
} else if (dir < Direction.WEST) { // 에러
    ...
} else if (dir.compareTo(Direction.SOUTH) > 0 ) { // OK
    ...
}

• else if (dir < Direction.WEST) : 열거형 상수에는 비교연산자 사용 불가

열거형의 조상 - java.lang.Enum

모든 열거형이 상속 받는 메서드들

컴파일러가 자동으로 추가해주는 메서드

실습 예제

열거형 상수 정의 및 변수 선언

enum Direction {EAST, SOUTH, WEST, NORTH} // values = 0, 1, 2, 3

class Ex12_5 {
    public static void main(String[] args) {
        Direction d1 = Direction.EAST;
        Direction d2 = Direction.valueOf("WEST");
        Direction d3 = Enum.valueOf(Direction.class, "EAST");

        System.out.println("d1 = " + d1);
        System.out.println("d2 = " + d2);
        System.out.println("d3 = " + d3);
        ...

d1 = EAST d2 = WEST d3 = EAST

• 값을 따로 지정해주지 않으면 자동으로 0에서부터 값이 할당된다.

• Direction d1 = Direction.EAST; : 보통 이 방법을 제일 많이 쓴다. 나머지 2가지 방법도 기능은 똑같다.

열거형 상수 비교

        ...
        System.out.println("d1 == d2 ? " + (d1 == d2));
        System.out.println("d1 == d3 ? " + (d1 == d3));
        System.out.println("d1.equals(d3) ? " + d1.equals(d3));
//        System.out.println("d2 > d3 ? "+ (d1 > d3)); // 컴파일 에러
        System.out.println("d1.compareTo(d3) ? " + (d1.compareTo(d3)));
        System.out.println("d1.compareTo(d2) ? " + (d1.compareTo(d2)));
        ...

d1 == d2 ? false d1 == d3 ? true d1.equals(d3) ? true d1.compareTo(d3) ? 0 d1.compareTo(d2) ? -2

• 열거형 상수들은 기본형이 아닌 하나하나가 객체이기 때문에 비교연산자 사용 불가

values() 메서드

        ...
        Direction[] dArr = Direction.values();

        for (Direction d : dArr)
            System.out.printf("%s = %d%n", d.name(), d.ordinal());
        ...

EAST = 0 SOUTH = 1 WEST = 2 NORTH = 3

• Direction.values() : 열거형의 모든 상수를 배열로 반환

• for (Direction d : dArr) : for (Direction d : Direction.values()) 와 동일

• d.name() : 열거형 상수의 이름 반환

• d.ordinal() : 열거형 상수의 순서 반환(주의 : 값 아님)

열거형에 멤버 추가

enum Direction {
    EAST(1, "▶"), SOUTH(2, "▼"), WEST(3, "◀"), NORTH(4, "▲");

    private final int value;
    private final String symbol;

    Direction(int value, String symbol) {
        this.value = value;
        this.symbol = symbol;
    }

    public int getValue() {
        return value;
    }

    public String getSymbol() {
        return symbol;
    }
}    

• EAST(1, "▶"), SOUTH(2, "▼"), WEST(3, "◀"), NORTH(4, "▲"); : 원하는 값을 괄호안에 적는다.

• private final int value;, private final String symbol; : 괄호안에 들어갈 값을 저장할 인스턴스 변수를 추가해준다.

  Direction(int value, String symbol) {
    this.value = value;
    this.symbol = symbol;
  }

• 추가한 iv값을 매개변수로 하는 생성자를 만들어준다.

• 열거형의 생성자는 항상 묵시적으로 private 접근 제어자이기 때문에, 외부에서 객체 생성 불가

  • Direction d = new Direction(1, "▶"); : 에러. 외부에서 호출 불가

public int getValue() {
    return value;
}

public String getSymbol() {
    return symbol;
}

• private으로 생성한 iv 값에 대한 getter을 public 제어자로 만들어준다.

열거형 상수 출력

public class EnumExample {
    public static void main(String[] args) {
        for (Direction dir : Direction.values()) {
            System.out.printf("%-5s : value : %d, symbol : %s, ordinal: %d%n",
                    dir.name(), dir.getValue(), dir.getSymbol(), dir.ordinal());
        }
    }
}

• dir.getValue()와 dir.ordinal() 차이
  • dir.getValue()는 열거형 상수 괄호안에 들어간 값
  • dir.ordinal()는 열거형 상수들의 순서(0부터 시작)

📌애너테이션(Annotation)

: 주석처럼 프로그래밍 언어에 영향을 미치지 않으며, 유요한 정보를 제공

표준 애너테이션

: Java에서 제공하는 애너테이션

@Override

오버라이딩을 제대로 했는지 컴파일러가 체크하게 한다.

오버라이딩할 때 메서드 이름을 잘못 적는 실수를 예방

class Product {
    void operate() {}
}

class Tv extends Product {
    @Override
    void opearte() {} // 컴파일 에러
}

• @Override 애너테이션을 안붙이면 철자 실수로 인해 내 작성 의도와 다르게 새로운 메서드를 작성한 것처럼 되서 컴파일은 정상적으로 작동한다. 그러나 @Override 를 붙임으로써 작성한 메서드가 조상 클래스에 없는 클래스라고 컴파일러가 알려준다.

@Deprecated

앞으로 사용하지 않을 것을 권장하는 필드나 메서드에 붙인다.

class Parent {
    void parentMethod() { }
}

class Child extends Parent {
    @Override
    @Deprecated
    void parentMethod() { }
}

public class Ex12_7 {
    public static void main(String[] args) {
        Child child = new Child();
        child.parentMethod();
    }
}

• cmd 에서 javac Ex12_7.java를 치면 deprecated API를 썼다는 경고문구가 뜬다.
• javac -Xlint:deprecation Ex12_7.java로 더 자세한 경고 내용을 볼 수 있다. warning: [deprecation] parentMethod() in Child has been deprecated child.parentMethod();

@FunctionalInterface

함수형 인터페이스는 단 하나의 추상 메서드만 가질 수 있다. 이 애너테이션을 붙이면 컴파일러가 제대로 작성했는지 체크해준다.

@FunctionalInterface
interface Testable {
    void test();
    void test2(); // 컴파일 에러
}

• @FunctionalInterface 이 애너테이션을 붙인 인터페이스가 2개 이상의 추상 메서드를 작성하면 에러가 난다.
• 함수형 인터페이스는 하나의 추상 메서드만 가질 수 있다.

@SuppressWarnings

컴파일러의 경고 메시지가 나타나지 않게 억제

@SuppressWarnings("unchecked")
ArrayList list = new ArrayList();
list.add(1);

• 괄호 안에 억제하고자 하는 경고의 종류를 문자열로 지정한다.

• @SuppressWarnings("unchecked") : 제네릭스와 관련된 경고를 억제

• 경고가 실행에 영향을 주진 않지만 내가 이 경고를 보고 확인했다는 의미에서 이 애너테이션을 붙인다.

둘 이상의 경고를 동시에 억제하는 법

@SuppressWarnings({"deprecation", "unchecked", "varargs"})

메타 애너테이션

애너테이션을 정의할 때 사용하는 애터네이션. java.lang.annotation 패키지에 포함

@Target

애너테이션을 정의할 때, 적용 대상 지정에 사용된다.

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, MODULE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
    String[] value();
}

• @SuppressWarnings 애너테이션의 적용 대상 타입 설정해준다.

@Retention

애너테이션이 유지(retention)되는 기간을 정하는데 사용

• CLASS는 잘 쓰이지 않고 SOURCE와 RUNTIME이 자주 사용된다.

컴파일러에 의해 사용되는 애너테이션의 유지 정책은 SOURCE 이다.

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {}

• @Override 는 컴파일러가 오버라이딩 체크하고 끝이기 때문에 실행 시에 필요가 없다. 따라서 유지 정책이 클래스 파일에 존재하지 않는 SOURCE 이다.

실행 시 사용 가능한 애너테이션의 유지 정책은 RUNTIME 이다.

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface FunctionalInterface {}

• RUNTIME 유지 정책은 실행 시에만 존재하는게 아니라 컴파일 타임부터 실행 시까지 유지되는 것이다.

@Documented, @Inherited

@Documented : javadoc으로 작성한 문서에 포함시킬 때 붙인다.

@Inherited : 애너테이션을 자손 클래스에 상속하고자할 때 붙인다.

@Inherited
@interface MyAnno{}

@MyAnno
class Parent{}

class Child extends Parent{} // Parent클래스에 붙어있던 MyAnno가 동일하게 붙은 것으로 인식

• Child 클래스에는 @MyAnno이 붙어있지 않지만 @Inherited 으로 인해 조상의 애너테이션을 상속받아 @MyAnno이 붙어있는 것으로 인식된다.

@Repeatable

반복해서 붙일 수 있는 애너테이션을 정의할 때 사용

// @ToDo를 @Repeatable으로 지정
@Repeatable(ToDos.class) 
@interface ToDo {
    String value();
}
// 여러번 반복해서 붙일 수 있다.
@ToDo("update codes")
@ToDo("override inherited methods")
class MyClass {
    ...
}

• @Repeatable이 붙은 애너테이션으 반복해서 붙일 수 있다.

// @ToDo를 하나로 묶을 컨테이너 애너테이션
@interface ToDos {
    ToDo[] value(); // 반드시 value
}

• @Repeatable로 반복해서 붙일 수 있도록 정의한 애너테이션을 하나로 묶을 컨테이너 애너테이션도 정의해줘야 한다.

애너테이션 타입 정의하기

@interface 애너테이션 이름 {
    타입 요소이름();
    ...
}

애너테이션의 메서드는 추상 메서드이며, 애너테이션을 적용할 때 지정(순서X)

enum TestType { FIRST, FINAL }

@interface DateTime {
    String yymmdd() ;
    String hhmmss() ;
}

@interface Test {
    int count(); // 정수
    String testedBy() ; // 문자열
    String[] testTools() ; // 문자열 배열
    TestType testType(); // Enum
    DateTime testDate(); // 다른 애너테이션 
}

• 애너테이션의 추상 메서드 타입으로 enum이 올 수 있고, 다른 애너테이션이 올 수 있다.

  @Test(
    count = 3,
    testedBy = "Jung",
    testTools = {"JUnit", "AutoTester"},
    testType = TestType.FIRST 
    testDate = @DateTime(yymmdd="", hhmmss="")
  )
  public class NewTest {
    ... // Test 애너테이션 사용가능
  }

• 요소의 타입과 이름에 맞게 값을 지정해주고 순서는 상관 없다. 다만, 모든 요소에 대해 값을 적용해줘야 한다.

애너테이션의 요소

적용 시 값을 지정하지 않으면, 사용될 수 있는 기본값 지정 가능(null 제외)

@interface Test {
    int count() default 1;
}

@Test
public class NewTest {
    ... // Test 애너테이션 사용가능
}

• 원래는 @Test(count=1) 이런 식으로 애너테이션의 정의된 요소의 값을 전부 정의해줘야 한다. 하지만 애너테이션을 생성할 때 default 값을 줬다면 @Test 이런 식으로만 써줘도 된다.

요소가 하나이고 이름이 value일 때는 요소의 이름을 생략할 수 있다.

@interface Test {
    String value();
}

@Test("passed")
public class NewTest {
    ... // Test 애너테이션 사용가능
}

• 원래는 @Test(value="passed") 라고 적어줘야 하지만 요소가 하나이고 그 요소의 이름이 value일 때는 요소의 이름을 생략하고 값만 적어줘도 된다.

요소의 타입이 배열인 경우, 중괄호{}를 사용해야 한다.

@interface Test {
    String[] testTools();
}

@Test(testTools={"JUnit", "Auto"})
public class NewTest {
    ... // Test 애너테이션 사용가능
}

• @Test(testTools={"JUnit", "Auto"}) : 배열의 값을 적어줄 때 중괄호를 적어줘야 한다.

• @Test(testTools="JUnit") : 배열의 값이 1개일 때는 중괄호 생략 가능

• @Test(testTools={}) : 배열에 값이 없을 때는 반드시 빈 중괄호{}를 적어줘야 한다.

모든 애너테이션의 조상

Annotation 인터페이스는 모든 애너테이션의 조상이지만 상속은 불가하다.

package java.lang.annotation;

public interface Annotation {
    boolean equals(Object obj);
    int hashCode();
    String toString();

    Class<? extends Annotation> annotationType();
}

• Annotation 인터페이스는 4개의 추상 메서드를 가지고 있고 모든 애너테이션은 구현하지 않아도 이 4개의 추상 메서드를 사용할 수 있다.
• Class<? extends Annotation> annotationType(); : 애너테이션의 타입을 반환

마커 애너테이션

요소가 하나도 정의되지 않은 애너테이션

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {} // 정의된 요소가 하나도 없다.

• @Override : 대표적인 마커 애너테이션

애너테이션 요소의 규칙

애너테이션의 요소를 선언할 때 지켜야할 규칙들

• 요소의 타입은 기본형, String, enum, 애너테이션, Class(설계도 객체)만 허용된다.

• 괄호()안에 매개변수를 선언할 수 없다.

• 예외를 선언할 수 없다.

• 요소를 타입 매개변수로 정의할 수 없다.

: 컴파일 시 타입을 체크해주는 기능

ArrayList<Tv> tvList = new ArrayList<>();

tvList.add(new Tv());
tvList.add(new DVD()); // 컴파일 에러

• <Tv> : ArrayList에 Tv 객체 타입만 저장할 수 있게 설정해주는 제네릭스이다.

객체의 타입 안정성을 높이고 형변환의 번거로움을 줄여준다.

ArrayList list = new ArrayList();
list.add(10);
list.add("20"); // String 추가

Integer i = (Integer) list.get(1); // 컴파일 OK

• (Integer) list.get(1) 은 컴파일 에러가 나지 않는다. get() 메서드의 반환 타입이 Object라서 그 안의 값이 String 타입인지 Integer 타입인지 컴파일러가 구분할 수 없기 때문이다. 그러나 실행 시에 형변환 에러인 ClassCastException 예외가 발생하게 된다. 실행 시에 발생하는 예외를 제네릭스들 통해 컴파일에게 타입의 정보를 알려줌으로써 컴파일 때 예외를 체크할 수 있게 해준다. 이로써, 객체의 타입 안정성을 높일 수 있다.

ArrayList<Tv> tvList = new ArrayList<>();

tvList.add(new Tv());
Tv t = tvList.get(0);

• get() 메서드는 반환 타입이 Object라서 Tv t = (Tv) tvList.get(0); 이런 식으로 (Tv)를 붙여 형변환을 해줘야 한다. 하지만 tvList는 제네릭스를 통해 Tv 객체만 저장하도록 설정해줬기 때문에 tvList에 저장되어 있는 객체들은 모두 Tv 타입인 걸 알 수 있다. 따라서, 형변환을 해주지 않아도 된다.

📌타입 변수

클래스를 작성할 때, Object 타입 대신 타입 변수<E>를 선언해서 사용

객체 생성 시, 타입 변수 대신 실제 타입을 대입

public class ArrayList<E> ... {
    public boolean add(E e) {
        modCount++;
        add(e, elementData, size);
        return true;
    }
    ...
        public E get(int index) {
        Objects.checkIndex(index, size);
        return elementData(index);
    }
}

• ArrayList<E> 클래스 안의 add(E e) 메서드는 매개변수가 타입 변수 <E>로 되어 있고 public E get(int index) 메서드는 반환 타입이 타입 변수 <E>로 되어 있다.

제네릭 타입과 다형성

참조 변수와 생성자의 대입된 타입은 일치해야 한다.

class Product {}
class Tv extends Produce {}
...
ArrayList<Tv> list = new ArrayList<Tv>();
ArrayList<Product> list = new ArrayList<Tv>(); // 에러

• 대입된 타입은 다형성이 성립 안되고 무조건 일치해야 한다.

제네릭 클래스간의 다형성은 성립된다.

List<Product> list = new ArrayList<Product>();
List<Product> list = new LinkedList<Product>(); // OK

• ArrayList, LinkedList가 List 인터페이스를 구현했기 때문에 다형성 성립

매개변수의 다형성도 성립된다.

ArrayList<Product> list = new ArrayList<Product<();

list.add(new Product());
list.add(new Tv()); // OK

• list.add(new Tv()); : 매개변수 타입이 Product이기 때문에 다형성에 의해 그 자손들도 매개변수 타입으로 올 수 있다.

반환타입의 다형성 성립(형변환 필요)

ArrayList<Product> list = new ArrayList<Product<();

list.add(new Product());
list.add(new Tv()); // OK

Product p = list.get(0);
Tv t = (Tv) list.get(1);

• Tv t = (Tv) list.get(1); : list.get(1)의 반환타입은 Product기 때문에 (Tv)로 형변환을 해줘야 한다.

📌제한된 제네릭 클래스

extends로 대입할 수 있는 타입을 제한

class FruitBox<T extends Fruit> {}
...
interface Eatable {}
class FruitBox<T extends Eatable> {}

• <T extends Fruit> : Fruit과 Fruit의 자손만 타입으로 지정할 수 있게 제한
• <T extends Eatable> : 타입을 제한할 때 인터페이스도 implements가 아닌 extends를 쓴다.(주의)

📌제네릭스의 제약

타입 변수에 대입은 인스턴스별로 다르게 가능하다.

class FruitBox<T extends Fruit> {}
class Fruit {}
class Apple extends Fruit {}
class Grape extends Fruit {}
...
FruitBox<Fruit> fruitBox = new FruitBox<>();
FruitBox<Apple> appleBox = new FruitBox<>(); // OK
FruitBox<Grape> grapeBox = new FruitBox<>(); // OK

static 멤버에는 타입 변수 사용 불가

class Box<T> {
    static T item; // 에러
    static void add(T item) {} // 에러
}

• 이유 : static이 붙으면 모든 인스턴스에 공통으로 사용이 가능하기 때문에 인스턴스마다 다르게 대입이 가능한 제네릭스는 사용이 불가하다.

객체(배열) 생성할 때 타입 변수 사용 불가. 타입 변수로 배열 선언은 가능

T[] itemArr; // OK

T[] tmpArr = new T(itemArr.length); // 사용 불가

• new 연산자 다음에는 확정된 타입이 와야 한다.

📌와일드 카드 <?>

class Product {}
class Tv extends Product {}
...
ArrayList<? extends Product> list = new ArrayList<Tv>(); // OK
ArrayList<? super Tv> list = new ArrayList<Product>(); // OK
ArrayList<?> list = new ArrayList<Object>();

• <? extends T> : T와 그 자손들만 가능
• <? super T> : T와 그 조상들만 가능
• <?> : 제한 없음. <? extends Object>와 동일

메서드의 매개변수에 와일드 카드 사용

class Juicer {
    static Juice makeJuice(FruitBox<? extends Fruit> box) {}
    ...
}
...
Juicer.makeJuice(new FruitBox<Fruit>()); // OK
Juicer.makeJuice(new FruitBox<Apple>()); // OK

📌제네릭 메서드

: 제네릭 타입이 선언된 메서드(타입 변수는 메서드 내에서만 유효)

class FruitBox<T> {
    static <T> void sort(List<T>) {}
    ...
}

• 클래스 FruitBox<T>의 타입변수 <T>와 메서드 static <T> void sort(List<T>) 의 타입변수 <T> 은 별개의 타입변수이다.

메서드를 호출할 때마다 타입을 대입해야 한다.(대부분 생략 가능)

static <T extends Fruit> Juice makeJuice(FruitBox<T> box) {}
...

FruitBox<Fruit> fruitBox = new FruitBox<>();
FruitBox<Apple> appleBox = new FruitBox<>();

System.out.println(Juicer.<Fruit>makeJuice(fruitBox));
System.out.println(Juicer.<Apple>makeJuice(appleBox));

• makeJuice(FruitBox<T> box) : makeJuice 메서드는 <T extends Fruit> 타입을 제한하고 있기 때문에 FruitBox<T> 에서 <T>에는 Fruit과 그 자손만 올 수 있다.

• Juicer.<Fruit>makeJuice(fruitBox) 여기서 <Fruit> 생략 가능하다. 참조변수 fruitBox 생성할 때 이미 <Fruit> 타입인지 알고있기 때문이다.

와일드카드가 사용된 메서드와 비교

// 와일드카드가 사용된 메서드
static Juice makeJuice(FruitBox<? extends Fruit> box) {}
// 제네릭 메서드
static <T extends Fruit> Juice makeJuice(FruitBox<T> box) {}

• 와일드카드가 사용된 메서드는 하나의 참조변수로 서로 다른 타입이 대입된 여러 제네릭 객체를 다루기 위한 것

• 제네릭 메서드는 메서드를 호출할 때마다 다른 제네릭 타입을 대입할 수 있게 한 것

• 둘은 서로 다른 메서드지만 기능은 똑같다. 그래서 와일드카드를 쓸 수 없을 때 제네릭 메서드를 사용한다.

📌제네릭 타입의 형변환

제네릭 타입과 원시 타입간의 형변환은 가능하지만 바람직하지 않다.(경고 발생)

Box b = null;
Box<String> bStr = null;

b = (Box) bStr; // 가능하지만 경고 발생
bStr = (Box<String>) b; // 가능하지만 경고 발생

• 원시 타입 자체를 쓰지 않는게 좋다.

제네릭 타입 간의 형변환 불가능. 와일드 카드가 사용된 제네릭 타입은 형변환 가능

Box<Object> bObj = new Box<String>(); // 에러

Box<? extends Object> bWild = new Box<String>(); // OK

• Box<? extends Object> bWild = new Box<String>(); 이 문장은 양변의 타입이 불일치하기 때문에 형변환을 해줘야한다. 사실 Box<? extends Object> bWild = (Box<? extends Object>) new Box<String>(); 이 문장에서 형변환해주는 (Box<? extends Object>) 이게 생략되어있는 것이다.

📌제네릭 타입의 제거

컴파일러는 제네릭 타입을 제거하고, 필요한 곳에 형변환을 넣는다.

class  Box<T extends Fruit> {
    void add(T t) {};
}

컴파일🔽

class  Box {
    void add(Fruit t) {};
}

• 기본적으로는 컴파일 하면 <T> -> Object로 바뀌지만 제한된 제네릭 타입은 조상 타입으로 바뀐다.

• 자바는 하위호환성(안정성)을 중요하게 생각하기 때문에 제네릭스가 나오기 전에 Object를 쓴 것처럼 컴파일을 하면 컴파일러가 제네릭 타입을 제거하고 Object로 바꾼다.

T get(int i) {
    return list.get(i);
}

컴파일🔽

Fruit get(int i) {
    return (Fruit)list.get(i);
}

• 제네릭 타입을 쓰면 형변환을 생략해도 된다는 장점이 있다. 그러나 컴파일을 하면 컴파일러가 자동으로 제네릭 타입을 제거하고 형변환을 추가한다.

toString(), deepToString()

: 배열의 출력. 다양한 타입의 배열을 문자열 형태로 출력

int[] arr = {0,1,2,3,4};
int[][]    arr2D = {{11,12,13}, {21,22,23}};

System.out.println("arr = "+Arrays.toString(arr));
System.out.println("arr2D = "+Arrays.deepToString(arr2D));

arr = [0, 1, 2, 3, 4] arr2D = [[11, 12, 13], [21, 22, 23]]

• deepToString() : 다차원 배열을 출력할 때 사용

copyOf(), copOfRange()

: 배열의 복사. 새로운 배열을 생성해서 반환

int[] arr2 = Arrays.copyOf(arr, arr.length);
int[] arr3 = Arrays.copyOf(arr, 3);
int[] arr4 = Arrays.copyOf(arr, 7);
int[] arr5 = Arrays.copyOfRange(arr, 2, 4);
int[] arr6 = Arrays.copyOfRange(arr, 0, 7);

System.out.println("arr2 = " + Arrays.toString(arr2));
System.out.println("arr3 = " + Arrays.toString(arr3));
System.out.println("arr4 = " + Arrays.toString(arr4));
System.out.println("arr5 = " + Arrays.toString(arr5));
System.out.println("arr6 = " + Arrays.toString(arr6));

arr2 = [0, 1, 2, 3, 4] arr3 = [0, 1, 2] arr4 = [0, 1, 2, 3, 4, 0, 0] arr5 = [2, 3] arr6 = [0, 1, 2, 3, 4, 0, 0]

• Arrays.copyOfRange(arr, 0, 7); : 뒤에 남는 나머지 공간은 0으로 채운다.

fill(), setAll()

: 배열 채우기

int[] arr7 = new int[5];
Arrays.fill(arr7, 9);
System.out.println("arr7 = " + Arrays.toString(arr7));

Arrays.setAll(arr7, i -> (int) (Math.random() * 6) + 1);
System.out.println("arr7 = " + Arrays.toString(arr7));

arr7 = [9, 9, 9, 9, 9] arr7 = [5, 3, 6, 2, 5]

• Arrays.fill(arr7, 9); : arr7 배열을 9로 채운다.
• i -> (int) (Math.random() * 6) + 1 : 람다식. 1~6까지의 난수로 채운다.

sort(), binarySearch()

: 배열의 정렬과 탐색. binarySearch() - 이진 탐색

char[] chArr = {'C', 'A', 'D', 'B', 'E'};

System.out.println("chArr = " + Arrays.toString(chArr));
System.out.println("index of B = " + Arrays.binarySearch(chArr, 'B'));
System.out.println("= After sorting = ");
Arrays.sort(chArr);
System.out.println("chArr = " + Arrays.toString(chArr));
System.out.println("index of B = " + Arrays.binarySearch(chArr, 'B'));

chArr = [C, A, D, B, E] index of B = -1 = After sorting = chArr = [A, B, C, D, E] index of B = 1

• Arrays.binarySearch(chArr, 'B'); : 결과는 -1. binarySearch() 는 정렬된 배열에서만 사용 가능하다.
• Arrays.sort(chArr); 로 정렬 후 Arrays.binarySearch(chArr, 'B'); 하니까 제대로 된 결과인 1이 나온다.

순차 탐색과 이진 탐색

순차 탐색 : 정렬하지 않고 처음부터 순서대로 탐색하는 방법

• 10개의 요소 중 평균 5.5회 만에 탐색한다.

이진 탐색 : 정렬 후에 반복적으로 반으로 나눠서 탐색하는 방법

• 반으로 나눈 후 가운데 요소와 찾는 요소와 비교해서 계속 범위를 줄여나간다.
• 10개의 요소 중 평균 3~4번 만에 탐색한다.
• 탐색을 하기 전 정렬을 해야만 한다는 단점이 있다.

deepEquals()

: 다차원 배열의 비교

String[][] str2D = new String[][]{{"aaa", "bbb"}, {"AAA", "BBB"}};
String[][] str2D2 = new String[][]{{"aaa", "bbb"}, {"AAA", "BBB"}};

System.out.println(Arrays.equals(str2D, str2D2));     
System.out.println(Arrays.deepEquals(str2D, str2D2)); 

false true

• 다차원 배열을 비교할 땐 equals() 대신 deepEquals() 사용

asList(Object... a)

: 배열을 List로 변환. (Object... a) - 갯수가 정해져 있지 않은 가변 매개변수

List list = Arrays.asList(1,2,3,4,5);
list.add(6); // UnsupportedOperationException 예외 발생

List list = new ArrayList(Arrays.asList(1,2,3,4,5));
list.add(6); // 가능

• List list = Arrays.asList(1,2,3,4,5); : 읽기만 가능하다. add() 메서드 사용 불가

• new ArrayList(Arrays.asList(1,2,3,4,5)); : List의 내용을 복사해서 List를 생성자로 하는 new ArrayList를 새로 만들면 변경이 가능하다.

📌Comparator와 Comparable

객체 정렬에 필요한 메서드(정렬 기준 제공)를 정의한 인터페이스

• Comparable : 기본 정렬 기준을 구현하는데 사용
• Comparator : 기본 정렬 기준 외에 다른 기준으로 정렬할 때 사용

public interface Comparable {
    int compareTo(Object o);
}

public interface Comparator {
    int compare(Object o1, Object o2);
}

• int compareTo(Object o); : 주어진 객체(o)를 자신과 비교
• int compare(Object o1, Object o2); : o1, o2 두 객체를 비교
• 반환 타입이 int인 이유
  • 0이면 두 객체가 같다.
  • 양수면 왼쪽이 크다.
  • 음수면 오른쪽이 크다.

정렬은 1. 두 객체를 비교 2. 자리 바꿈 이 2가지를 반복하는 것이다.

실습 예제

class Ex11_7 {
    public static void main(String[] args) {
        String[] strArr = {"cat", "Dog", "lion", "tiger"};

        Arrays.sort(strArr); // String의 Comparable 구현에 의한 정렬
        System.out.println("strArr=" + Arrays.toString(strArr));

        Arrays.sort(strArr, String.CASE_INSENSITIVE_ORDER); // 대소문자 구분안함
        System.out.println("strArr=" + Arrays.toString(strArr));

        Arrays.sort(strArr, new Descending()); // 역순 정렬
        System.out.println("strArr=" + Arrays.toString(strArr));
    }
}

class Descending implements Comparator { 
    public int compare(Object o1, Object o2){
        if( o1 instanceof Comparable && o2 instanceof Comparable) {
            Comparable c1 = (Comparable)o1;
            Comparable c2 = (Comparable)o2;
            return c1.compareTo(c2) * -1 ;
        }
        return -1;
    } 
}

strArr=[Dog, cat, lion, tiger] strArr=[cat, Dog, lion, tiger] strArr=[tiger, lion, cat, Dog]

• Arrays.sort(strArr); : 정렬 기준은 String의 Comparable 구현에 의한 정렬이다. 객체 배열에 저장된 객체(strArr)가 정렬 기준을 구현하고 있어야지만 정렬 기준을 생략할 수 있다.

• strArr=[Dog, cat, lion, tiger] : Comparable 인터페이스는 기본 정렬 기준을 제공한다. 문자열의 기본 정렬 기준을 사전순서이다. 따라서 대문자가 먼저 오고 그 다음 알파벳 순서대로 정렬이 된다.

• Arrays.sort(strArr, String.CASE_INSENSITIVE_ORDER); : 정렬 기준은 String.CASE_INSENSITIVE_ORDER - 대소문자 구분안하는 정렬 기준

class Descending implements Comparator { 
    public int compare(Object o1, Object o2){
        if( o1 instanceof Comparable && o2 instanceof Comparable) {
            Comparable c1 = (Comparable)o1;
            Comparable c2 = (Comparable)o2;
            return c1.compareTo(c2) * -1; // c2.compareTo(c1); 도 가능
        }
        return -1;
    } 
}

• Comparator 인터페이스의 compare(Object o1, Object o2) 메서드를 오버라이딩해서 구현해준다.

• c1.compareTo(c2) * -1; : 기본 정렬 기준에 * -1을 해줌으로써 오름차순이었던 정렬 기준을 내림차순으로 바꿔준다.

• c2.compareTo(c1); 으로 해도 정렬 기준이 내림차순으로 바뀐다.

Integer와 Comparable

public final class Integer extends Number implements Comparable<Integer> {
    ...
    public int compareTo(Integer anotherInteger) {
        return compare(this.value, anotherInteger.value);
    }
    public static int compare(int x, int y) {
        return (x < y) ? -1 : ((x == y) ? 0 : 1);
    }
    ...
}

• return (x < y) ? -1 : ((x == y) ? 0 : 1); : 비교하는 값이 같으면 0, 오른쪽(y)이 크면 -1, 왼쪽(x)이 크면 1 반환

• Integer, String, Double 등의 클래스들은 기본 정렬 기준을 제공하는 Comparable 인터페이스를 구현하고 있다. 정렬 기준이 없을 때 기본 정렬 기준을 제공한다.

• 정렬 방법은 이미 코드가 잘 짜여져 있다.(불변) 따라서, 정렬 기준(가변)만 우리가 제공해주면 된다.

📌HashSet - 순서X, 중복X

: Set 인터페이스를 구현한 대표적인 컬렉션 클래스

• 순서를 유지하려면 LinkedHashSet 클래스를 사용

TreeSet

• 범위 검색과 정렬에 유리한 컬렉션 클래스
• HashSet 보다 데이터 추가, 삭제에 시간이 더 걸린다.

HashSet의 메서드

생성자

• HashSet() : 기본 생성자

• HashSet(Collection c) : 컬렉션끼리 변환할 때 사용하는 생성자

• HashSet(int initialCapacity) : 초기 용량 정해주는 생성자

• HashSet(int initialCapacity, float loadFactor) : loadFactor 만큼 용량이 차면 용량을 x2 해준다.(loadFactor = 0.8 -> 80% 찼을 때)

주요 메서드

• boolean add(Object o) : 추가

• boolean addAll(Collection c) : 합집합

• boolean remove(Object o) : 삭제

• boolean removeAll(Collection c) : 차집합

• boolean retainAll(Collection c) : 교집합

• void clear() : 전체 삭제

• boolean contains(Object o) : 객체(o)를 포함하고 있는지

• boolean containsAll(Collection c) : 컬렉션(c)에 담긴 객체들이 모두 포함하고 있는지

• Iterator iterator() : 컬렉션의 요소들을 읽어오는 메서드

• boolean isEmpty() : 비어있으면 true

• int size() : 저장된 객체의 개수 반환

• Object[] toArray() : Set에 저장되어 있는 객체를 객체 배열로 반환

• Object[] toArray(Object[] a) : Set에 저장되어 있는 객체를 객체 배열로 반환

실습 예제

Object[] objArr = {"1", new Integer(1), "2", "3", "3", "4", "4"};
Set set = new HashSet();

for (int i = 0; i < objArr.length; i++) {
    set.add(objArr[i]);
}

System.out.println(set);

[1, 1, 2, 3, 4]

• 중복은 전부 제거되었다.

• 1이 2개 있는 이유는 하나는 문자열 "1" 이고 나머지 하나는 new Integer(1) 이기 때문이다.

로또 번호 6자리 출력하는 예제

Set set = new HashSet();

for (int i = 0; i < set.size() < 6; i++) {
    int num = (int)(Math.random() * 45) + 1;
    set.add(num);
}

List list = new LinkedList(set); // LinkedList(Collection c)
Collections.sort(list); // Collections.sort(List list)
System.out.println(list);

[5, 12, 18 ,22, 33, 44]

• for 문은 Math.random()을 이용해서 6개의 난수 번호를 set에 저장한다.

• Collections.sort(List list) 은 정렬해주는 메서드인데 매개변수로 List 인터페이스만 올 수 있다. 따라서, Set 은 정렬을 할 수 없기 때문에 LinkedList(Collection c) 생성자를 이용해서 Set을 List로 변환해주고 Collections.sort(List list) 로 정렬해준다.

HashSet은 객체를 저장하기 전에 기존에 같은 객체가 있는지 확인한다. 같은 객체가 없으면 저장하고, 있으면 저장하지 않는다.

boolean add(Object o)는 저장할 객체의 equals()와 hashCode()를 호출한다. 따라서 equals()와 hashCode()가 오버라이딩 되어 있어야 한다.

class Ex11_11 {
    public static void main(String[] args) {
        HashSet<Person> set = new HashSet<>();

        set.add(new Person("David",10));
        set.add(new Person("David",10));

        System.out.println(set);
    }
}

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String toString() {
        return name +":"+ age;
    }
}

[David:10, David:10]

• Person 클래스에서 equals()와 hashCode()를 오버라이딩 해주지 않아서 HashSet에 중복으로 저장이 된다.

equals()와 hashCode() 오버라이딩하는 방법

@Override
public int hashCode() {
    return Objects.hash(name, age);
}

@Override
public boolean equals(Object obj) {
    if (!(obj instanceof Person)) return false;

    Person p = (Person) obj;
    return this.name.equals(p.name) && this.age == p.age;
}

[David:10]

• equals()와 hashCode() 오버라이딩하니까 중복이 제거되었다.

집합 예제

class Ex11_12 {
    public static void main(String args[]) {
        HashSet setA   = new HashSet();
        HashSet setB   = new HashSet();
        HashSet setHab = new HashSet();
        HashSet setKyo = new HashSet();
        HashSet setCha = new HashSet();

        setA.add("1");     setA.add("2");  setA.add("3");
        setA.add("4");  setA.add("5");
        System.out.println("A = "+setA);

        setB.add("4");     setB.add("5");  setB.add("6");        
      setB.add("7");  setB.add("8");
        System.out.println("B = "+setB);

        Iterator it = setB.iterator();
        // 교집합
        while(it.hasNext()) {
            Object tmp = it.next();
            if(setA.contains(tmp))
                setKyo.add(tmp);
        }
        // 차집합
        it = setA.iterator();
        while(it.hasNext()) {
            Object tmp = it.next();
            if(!setB.contains(tmp))
                setCha.add(tmp);
        }
        // 합집합
        it = setA.iterator();
        while(it.hasNext())
            setHab.add(it.next());

        it = setB.iterator();
        while(it.hasNext())
            setHab.add(it.next());

        System.out.println("A ⋂ B = " + setKyo);
        System.out.println("A U B = " + setHab);
        System.out.println("A - B = " + setCha); 
    }
}

A = [1, 2, 3, 4, 5] B = [4, 5, 6, 7, 8] A ⋂ B = [4, 5] A U B = [1, 2, 3, 4, 5, 6, 7, 8] A - B = [1, 2, 3]

교집합, 차집합, 합집합 더 쉽게 구하는 방법

setA.retainAll(setB); // 교집합
setA.addAll(setB); // 합집합
setA.removeAll(setB); // 차집합

• setA.retainAll(setB); : 교집합. 공통된 요소만 남기고 삭제

• setA.addAll(setB); : 합집합. setB의 모든 요소를 추가(중복 제외)

• setA.removeAll(setB); : 차집합. setB와 공통 요소를 제거

📌TreeSet - 범위 탐색, 정렬

이진 탐색 트리(binary search tree)로 구현. 범위 탐색과 정렬에 유리

이진 트리는 모든 노드가 최대 2개(0~2개)의 하위 노드를 갖는다.

• 각 요소(node)가 나무(tree)형태로 연결되어있다.(LinkedList의 변형) ```java class TreeNode { TreeNode left; // 왼쪽 자식노드 Object element; // 저장할 객체 TreeNode right; // 오른쪽 자식노드 } ``` - 노드 하나를 트리노드라고 부르고 총 3개의 변수가 저장되어 있다.

이진 탐색 트리(Binary search tree)

부모보다 작은 값은 왼쪽. 큰 값은 오른쪽에 저장한다.

단점 : 데이터가 많아질수록 비교 횟수 증가에 따라 추가, 삭제에 시간이 더 걸린다.

TreeSet 데이터 저장 과정

TreeSet에 7, 4, 9, 1, 5의 순서로 데이터를 저장하면 아래의 과정을 거친다.

• 요소를 저장해감에 따라 비교 횟수가 점점 늘어나면서 저장하는 시간이 많이 걸린다.

TreeSet의 메서드

add(), remove(), size(), iterator()와 같은 기본적인 메서드들은 적지 않았다.

생성자

• TreeSet() : 기본 생성자. 정렬 기준이 없으면 저장하는 객체의 기본 정렬 기준인 Comparable 사용

• TreeSet(Collection c) : 컬렉션(c)를 TreeSet으로 변환하는 생성자

• TreeSet(Comparator comp) : 주어진 정렬 기준으로 정렬하는 생성자

주요 메서드

• Object first() : 정렬된 순서에서 첫 번째 객체를 반환한다.(오름차순일 때 제일 작은 값)

• Object last() : 정렬된 순서에서 마지막 객체를 반환한다.(오름차순일 때 제일 큰 값)

• Object ceiling(Object o) : 객체(o)와 같은 객체를 반환. 없으면 객체보다 큰 값 중 가장 가까운 값의 객체를 반환. 없으면 null

• Object floor(Object o) : 객체(o)와 같은 객체를 반환. 없으면 객체보다 작은 값 중 가장 가까운 값의 객체를 반환. 없으면 null

• Object higher(Object o) : 객체(o)보다 큰 값 중 가장 가까운 값의 객체를 반환. 없으면 null

• Object lower(Object o) : 객체(o)보다 작은 값 중 가장 가까운 값의 객체를 반환. 없으면 null

• SortedSet subSet(Object from, Object to) : from~to 사이의 값을 반환한다.(to 포함x)

• SortedSet headSet(Object to) : to보다 작은 값의 객체들을 반환한다.

• SortedSet tailSet(Object from) : from보다 큰 값의 객체들을 반환한다.

실습 예제

Set set = new TreeSet();

for (int i = 0; set.size() < 6 ; i++) {
    int num = (int)(Math.random()*45) + 1;
    set.add(num);  // set.add(new Integer(num));
}

System.out.println(set);

[11, 15, 20, 33, 36, 40]

• TreeSet은 따로 정렬을 하지 않아도 자동으로 정렬이 된다.
• Integer 클래스가 Comparable 구현의 의한 기본 정렬 기준을 가지고 있다.

class Ex11_13 {
    public static void main(String[] args) {
        Set set = new TreeSet();

        set.add(new Test());

        System.out.println(set);
    }
}

class Test {}

Exception in thread "main" java.lang.ClassCastException 에러가 난다.

• 에러가 나는 이유는 비교 기준이 없기 때문이다.

비교 기준을 만들어준다.

class Ex11_13 {
    public static void main(String[] args) {
        Set set = new TreeSet(new TestComp()); // 정렬 기준 넣어준다.
        //Set set = new TreeSet();

        set.add(new Test());

        System.out.println(set);
    }
}

class Test implements Comparable {
    public int compareTo(Object o) {
    return 0;
    }
}

class TestComp implements Comparator {
    public int compare(Object o1, Object o2) {
    return 0;
    }
}

• Set set = new TreeSet(new TestComp()); : Comparator 인터페이스를 구현한 정렬 기준을 TreeSet(Comparator comp) 생성자를 통해 정의해준다.

• Set set = new TreeSet(); : Test 클래스가 Comparable 인터페이스를 구현한다면 정렬 기준을 적지 않아도 기본 정렬 기준으로 정렬된다.

• TreeSet 클래스는 정렬 기준이 필요하기 때문에 1. 저장할 객체가 Comparable구현에 의한 정렬 기준을 가지고 있던가 2. TreeSet이 생성자를 통해 정렬 기준을 가지고 있던가 둘 중 하나는 해야 한다.

class Ex11_15 {
    public static void main(String[] args) {
        TreeSet set = new TreeSet();
        int[] score = {80, 95, 50, 35, 45, 65, 10, 100};

        for(int i=0; i < score.length; i++)
            set.add(new Integer(score[i]));

        System.out.println("50보다 작은 값 :" + set.headSet(new Integer(50)));
        System.out.println("50보다 큰 값 :"  + set.tailSet(new Integer(50)));
        System.out.println("40~80사이의 값 :"  + set.subSet(40, 80));
    }
}

50보다 작은 값 :[10, 35, 45] 50보다 큰 값 :[50, 65, 80, 95, 100] 40~80사이의 값 :[45, 50, 65]

• set.headSet(new Integer(50)); : 50보다 작은 값. 50 포함X

• set.tailSet(new Integer(50)); : 50보다 큰 값. 50 포함O

• set.subSet(40, 80) : 40 ~ 80 사이의 값. 80 포함X

• 이런 방식으로 동작하기 때문에 범위 검색에 유리하다.

트리 순회(Tree traversal)

: 이진 트리의 모든 노드를 한번씩 읽는 것

• 전위, 중위, 후위 순회법이 있으며, 중위 순회하면 오름차순으로 정렬된다.

• 이러한 동작 방식 때문에 TreeSet은 정렬에 유리하다.

📌HashMap - 순서X, 중복(키X, 값O)

: Map 인터페이스를 구현. 데이터를 키와 값의 쌍으로 저장

• 순서를 유지하려면 LinkedHashMap 클래스를 사용

Hashtable은 동기화O, HashMap은 동기화X

TreeMap - TreeSet과 특성이 유사

• 범위 검색과 정렬에 유리한 컬랙션 클래스
• HashMap보다 데이터 추가, 삭제에 시간이 더 걸린다.

HashMap의 키(key)와 값(value)

해싱(hashing)기법으로 데이터를 저장한다. 데이터가 많아도 검색이 빠르다.

키는 중복이 안되고 값은 중복이 된다.

HashMap<String, String> hashMap = new HashMap<>();
hashMap.put("myid", "asdf");
hashMap.put("yourid", "1122");
hashMap.put("yourid", "asdf");

• hashMap.put("yourid", "asdf"); : 같은 키에 다른 값을 2번 넣으면 나중에 넣은 값이 덮어쓴다.

키(key)와 값(value) 한 쌍이 Entry[] table 이라는 엔트리 배열에 저장된다.

해싱(Hashing)

: 해시 함수(hash function)로 해시 테이블에 데이터를 저장, 검색하는 기법

해시 테이블은 배열과 LinkedList가 조합된 형태이다.

• 배열의 장점인 접근성과 LinkedList의 장점인 변경에 유리함을 조합한 것이다.

해시 테이블에 저장된 데이터를 가져오는 과정

1. 키(key)로 해시 함수를 호출해서 해시 코드(배열의 index)를 얻는다.

2. 해시 코드(해시 함수의 반환값)에 대응하는 LinkedList를 배열에서 찾는다.

3. LinkedList에서 키(key)와 일치하는 데이터를 찾는다.

   • 해시 함수는 같은 키에 대해 항상 같은 해시 코드(배열의 index)를 반환해야 한다.
   • 서로 다른 키가 같은 값의 해시 코드를 반환할 수 있다.(75xxx와 72xxx의 해시 코드는 모두 7이다. = 같은 배열 data[7]에 있다.)

HashMap의 메서드

생성자

• HashMap() : 기본 생성자

• HashMap(int initialCapacity) : HashMap은 해시 테이블에 데이터를 저장한다. 해시 테이블은 배열 + LinkedList로 이루어져 있기 때문에 생성자를 통해 배열의 초기 용량을 정해줄 수 있다.

• HashMap(int initialCapacity, float loadFactor) : 용량이 loadFactor만큼 차면 용량을 x2 해주는 생성자

• HashMap(Map m) : 다른 Map을 HashMap으로 변환해주는 생성자

주요 메서드

• Object put(Object key, Object value) : 키(key)와 값(value)을 저장

• void putAll(Map m) : Map의 데이터들이 전부 저장된다.

• Object remove(Object key) : 키로 저장된 값(객체)을 제거

• Object replace(Object key, Object value) : 지정된 키의 값을 지정된 값으로 변경

• boolean replace(Object key, Object oldValue, Object newValue) : 지정된 키(key)와 값(oldValue)을 새로운 값(newValue)으로 변경

• Set entrySet() : 키와 값이 쌍으로 이루어진 entry를 Set 타입으로 저장해서 반환

• Set keySet() : 저장된 모든 키를 Set 타입으로 저장해서 반환

• Collection values() : 저장된 모든 값을 Collection 타입으로 저장해서 반환

• Object get(Object key) : 키에 해당하는 값을 반환

• Object getOrDefault(Object key, Object dafaultValue) : 해당하는 키가 없을 때 dafaultValue 값을 반환

• boolean containsKey(Object key) : 지정된 키를 포함하고 있으면 true

• boolean containsValue(Object value) : 지정된 값을 포함하고 있으면 true

• Object clone() : 복제하는 메서드

실습 예제

로그인

class Ex11_16 {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("myId", "1234");
        map.put("asdf", "1111");
        map.put("asdf", "1234");

        Scanner s = new Scanner(System.in);    // 화면으로부터 라인단위로 입력받는다.

        while(true) {
            System.out.println("id와 password를 입력해주세요.");
            System.out.print("id :");
            String id = s.nextLine().trim();

            System.out.print("password :");
            String password = s.nextLine().trim();
            System.out.println();

            if(!map.containsKey(id)) {
                System.out.println("입력하신 id는 존재하지 않습니다. 다시 입력해주세요.");
                continue;
            } 

            if(!(map.get(id)).equals(password)) {
                System.out.println("비밀번호가 일치하지 않습니다. 다시 입력해주세요.");
            } else {
                System.out.println("id와 비밀번호가 일치합니다.");
                break;
            }
        }
    }
}

• if(!(map.get(id)).equals(password)) : map.get(id) 키가 id인 값을 반환하고 이 값을 password와 비교해서 같지 않으면 비밀번호가 틀리다는 문구 출력

entry

class Ex11_17 {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("김자바", 90);
        map.put("김자바", 100); // 이 값이 덮어쓴다.
        map.put("이자바", 100);
        map.put("강자바", 80);
        map.put("안자바", 90);

        Set<Map.Entry<String, Integer>> set = map.entrySet();
        Iterator<Map.Entry<String, Integer>> it = set.iterator();

        while (it.hasNext()) {
            Map.Entry<String, Integer> e = it.next();
            System.out.println("이름 : " + e.getKey() + ", 점수 : " + e.getValue());
        }

        System.out.println("참가자 명단 : " + map.keySet());

        Collection<Integer> values = map.values();
        Iterator<Integer> it2 = values.iterator();

        int total = 0;
        while (it2.hasNext()) {
            int i = it2.next();
            total += i;
        }

        System.out.println("총점 : " + total);
        System.out.println("평균 : " + (float) total / set.size());
        System.out.println("최고점수 : " + Collections.max(values));
        System.out.println("최저점수 : " + Collections.min(values));
    }
}

이름 : 안자바, 점수 : 90 이름 : 김자바, 점수 : 100 이름 : 강자바, 점수 : 80 이름 : 이자바, 점수 : 100 참가자 명단 : [안자바, 김자바, 강자바, 이자바] 총점 : 370 평균 : 92.5 최고점수 : 100 최저점수 : 80

• Set<Map.Entry<String, Integer>> set = map.entrySet(); : Map 인터페이스의 내부 인터페이스인 Entry 인터페이스

public class Solution { 
  public HashMap<Character, Integer> countAllCharacter(String str) {
    HashMap<Character, Integer> hashMap = new HashMap<>();

    for (int i = 0; i < str.length(); i++) {
      char character = str.charAt(i);

      if (hashMap.containsKey(character))
        hashMap.put(character, hashMap.get(character) + 1);
      else
        hashMap.put(character, 1);
    }

    return str.length() == 0 ? null : hashMap;
  }
}

HashMap<Character, Integer> output = countAllCharacter("banana"); System.out.println(output); // --> {b=1, a=3, n=2}

• for 문 : 문자열의 첫 번째 문자부터 hashMap에 키로 포함하고 있으면 값을 +1하고 포함하고 있지 않다면 값에 1 저장 -> 문자열에 같은 문자가 몇번 반복되는지 세는 로직

📌Collections - 컬렉션을 위한 메서드(static) 제공

fill(), copy(), sort(), binarySearch()

: 컬렉션 채우기, 복사, 정렬, 이진 검색

synchronizedXXX()

: 컬렉션의 동기화

static Collection synchronizedCollection( Collection c )
static List synchronizedList( List list )
static Set synchronizedSet( Set s )
static Map synchronizedMap( Map m )
static SortedSet synchronizedSortedSet( SortedSet s )
static SortedMap synchronizedSortedMap( SortedMap m )

/* 사용 방법 */
List synchroList = Collections.synchronizedList( new ArrayList(...) ) ; // ArrayList는 동기화 되지 않은 List

unmodifiableXXX()

: 변경 불가(read Only) 컬렉션 만들기

static Collection unmodifiableCollection( Collection c )
static List unmodifiableList( List list )
static Set unmodifiableSet( Set s )
static Map unmodifiableMap( Map m )

static SortedSet unmodifiableSortedSet( SortedSet s )
static NavigableSet unmodifiableNavigableSet( NavigableSet s )
static SortedMap unmodifiableSortedMap( SortedMap m )
static NavigableMap unmodifiableNavigableMap( NavigableMap m )

singletonXXX()

: 싱글톤 컬렉션 만들기. 객체 1개만 저장 가능한 컬렉션

static List singletonList( Object o )
static Set singleton( Object o ) // Set는 그냥 singleton
static Map singletonMap( Object key, Object value )

checkedXXX()

: 한 종류의 객체만 저장하는 컬렉션 만들기

static Collection checkedCollection( Collection c, Class type )
static List checkedList( List list, Class type )
static Set checkedSet( Set s, Class type )
static Map checkedMap( Map m, Class keyType, Class valueType ) // 각 각 Type 지정

static Queue checkedQueue( Queue queue, Class type )

static SortedSet checkedSortedSet( SortedSet s, Class type  )
static NavigableSet checkedNavigableSet( NavigableSet s, Class type  )
static SortedMap checkedSortedMap( SortedMap m, Class keyType, Class valueType )
static NavigableMap checkedNavigableMap( NavigableMap m, Class keyType, Class valueType )

/* 사용 방법 */
List list = new ArrayList() ;
List checkedList = checkedList( list, String.class ) ; //String만 저장 가능하도록

checkedList.add("abc") ; // 가능
checkedList.add(new Integer(123)) ; // 불가능(에러) : ClassCastException 발생

• JDK 1.5 버전 이후에는 제네릭스로 대체되었다.

addAll([배열] , ...)

: 지정 Collection 에 '입력된 값들( 가변인자 )'을 추가

List list = new ArrayList();

addAll(list, 1,2,3,4,5); 
System.out.println(list);

[1, 2, 3, 4, 5]

rotate([배열] , int move)

: 오른쪽으로 move칸씩 이동

rotate(list, 2);  // 오른쪽으로 두 칸씩 이동 
System.out.println(list);

[4, 5, 1, 2, 3]

swap([배열], int idx1, int idx2)

: "idx1 위치의 값"과 "idx2 위치의 값"과 교환

swap(list, 0, 2); // 첫 번째와 세 번째를 교환(swap)
System.out.println(list);

[1, 5, 4, 2, 3]

shuffle([배열])

: 무작위 섞기

shuffle(list);    // 저장된 요소의 위치를 임의로 변경 
System.out.println(list);

[3, 4, 2, 1, 5]

sort([배열], reverseOrder())

: 역순 정렬. reverse([배열])과 동일

sort(list, reverseOrder()); // 역순 정렬 reverse(list);와 동일 
System.out.println(list);

[5, 4, 3, 2, 1]

nCopies([배열].size(), Object value)

: 지정 배열과 같은 크기의 새로운 리스트를 생성하고 value로 해당 리스트 채움

List newList = nCopies(list.size(), 2); 
System.out.println("newList="+newList);

newList=[2, 2, 2, 2, 2]

disjoint([배열 1], [배열 2])

: 두 배열에 공통 요소가 없으면 true 반환

컬렉션(collection) : 여러 객체(데이터)를 모아 놓은 것

프레임워크(framework) : 표준화, 정형화된 체계적인 프로그래밍 방식

컬렉션 프레임워크(collections framework)

• 컬렉션(다수의 객체)를 다루기 위한 표준화된 프로그래밍 방식
• 컬렉션을 쉽고 편리하게 다룰 수 있는 다양한 클래스들을 제공
• java.util 패키지에 포함

컬렉션 클래스(collection class)

• 다수의 데이터를 저장할 수 있는 클래스(Vector, ArrayList, HashSet 등)

컬렉션 프레임워크의 핵심 인터페이스

List 인터페이스 - 저장 순서O, 중복O

: 저장 순서가 있는 데이터의 집합. 데이터의 중복을 허용한다.

• 예시) 대기자 명단

• 구현 클래스 : ArrayList, LinkedList, Stack, Vector 등

  List 인터페이스 계층 구조

  

• 핵심 : ArrayList, LinkedList

List 인터페이스의 메서드

• get() : 읽기, set() : 변경, indexOf() : 검색, sort() : 정렬

Set 인터페이스 - 저장 순서X, 중복X

: 저장 순서를 유지하지 않는 데이터의 집합. 데이터의 중복을 허용하지 않는다.

• 예시) 소수의 집합, 육식동물의 집합

• List와 특징이 정반대

• 구현 클래스 : HashSet, TreeSet 등

  Set 인터페이스 계층 구조

  

• 핵심 : HashSet, TreeSet

Set 인터페이스의 메서드

Collection 인터페이스의 메서드와 동일

집합과 관련된 메서드들(Collection에 변화가 있으면 true, 아니면 false를 반환)

Map 인터페이스 - 저장 순서X, 중복(키X, 값O)

: 키(key)와 값(value)의 쌍(pair)으로 이루어진 데이터의 집합. 저장 순서는 유지하지 않으며, 키는 중복을 허용하지 않고 값은 중복을 허용한다.

• 예시) 아이디(key)-패스워드(value)

• 구현 클래스 : HashMap, TreeMap, Hashtable, Properties 등

  Map 인터페이스 계층 구조

  

• 핵심 : HashMap, TreeMap

• LinkedHashMap : 저장 순서가 있음

• Hashtable과 HashMap은 유사. 동기화 유무 차이(Hashtable 동기화O, HashMap 동기화X)

Map 인터페이스의 메서드

• put(), putAll() : 추가, containsKey(), containsValue(), get() : 검색, remove() : 삭제

• Set keySet() : 키만 읽기, Collection values() : 값만 읽기, Set entrySet() : Entry(키-값) 읽기

• Collection values() : 리턴 타입이 Collection이기 때문에 순서와 중복이 상관 없음

• Set keySet(), Set entrySet() : 리턴 타입이 Set이기 때문에 순서X, 중복X

Collection 인터페이스

Collection 인터페이스 계층 구조

Collection 인터페이스의 메서드

• add() : 추가, contains() : 검색, remove() : 삭제, clear() : 전체 삭제

📌ArrayList

ArrayList는 기존의 Vector를 개선한 것으로 구현 원리와 기능적으로 동일. ArrayList는 동기화X, Vector는 동기화O

List 인터페이스를 구현하므로, 저장 순서가 유지되고 중복을 허용한다.

데이터의 저장 공간으로 배열을 사용한다.(배열 기반)

ArrayList의 메서드

생성자

• ArrayList() : 기본 생성자

• ArrayList(Collection c) : 컬렉션끼리 변환할 때 사용

• ArrayList(int initialCapacity) : 배열의 길이 지정

추가

• boolean add(Object o) : 객체를 추가. 성공하면 true, 실패하면 false

• void add(int index, Object element) : 저장 위치(index) 지정 가능

• boolean addAll(Collection c) : 컬렉션의 모든 요소를 추가

• boolean addAll(int index, Collection c) : 컬렉션의 모든 요소를 저장 위치(index)에 추가

삭제

• boolean remove(Object o) : 객체 삭제

• Object remove(int index) : index의 객체 삭제

• boolean removeAll(Collection c) : 지정한 컬렉션의 객체들을 삭제

• void clear() : 모든 객체 삭제

검색

• int indexOf(Object o) : 객체가 몇 번째 index에 있는지 반환, 못 찾으면 -1 반환

• int lastindexOf(Object o) : 끝에서부터 객체를 찾음.

• boolean contains(Object o) : 객체가 존재하는지 물어봄. 있으면 true, 없으면 false

• Object get(int index) : index 위치의 객체를 읽음

• Object set(int index, Object element) : index의 위치에 있는 객체를 변경

기타

• List subList(int from, int to) : from부터 to까지의 인덱스를 뽑아내서 새로운 리스트를 만듬(to는 포함x)

• Object[] toArray() : ArrayList의 객체 배열을 반환

• boolean isEmpty() : ArrayList가 비어있으면 true, 아니면 false

• void trimToSize() : 빈 공간을 제거

• int size() : 저장된 객체의 개수를 반환

실습 예제

ArrayList list1 = new ArrayList(10);
list1.add(new Integer(5));
list1.add(4);
list1.add(new Integer(2));
list1.add(new Integer(0));
list1.add(new Integer(1));
list1.add(new Integer(3))

ArrayList list2 = new ArrayList(list1.subList(1,4)); 

list1 = [5, 4, 2, 0, 1, 3] list2 = [4, 2, 0]

• ArrayList list1 = new ArrayList(10); : 기본 길이(용량, Capacity)가 10인 ArrayList 생성

• list1.add(4); : 이렇게 해도 추가가 된다. 컴파일러가 오토 박싱을 통해서 list1.add(new Integer(4)); 이렇게 자동으로 변환해준다.

• list1.subList(1,4) : 인덱스 1부터 4 전까지의 객체를 뽑아 새로운 ArrayList를 만든다. 인덱스 4는 포함x

• ArrayList list2 = new ArrayList(list1.subList(1,4)); : ArrayList(Collection c) 생성자를 통해 list2를 만들어준다.

Collections.sort(list1);
Collections.sort(list2);

list1 = [0, 1, 2, 3, 4, 5] list2 = [0, 2, 4]

• 오름차순으로 정렬
• Collections 는 유틸 클래스이다. 헷갈리지 말자. Collection 이 인터페이스

System.out.println("list1.containsAll(list2) = " 
+ list1.containsAll(list2));

list1.containsAll(list2) = true

• list1이 list2의 모든 요소를 포함하고 있는지

list2.add("B");
list2.add("C");
list2.add(3, "A");

list2 = [0, 2, 4, A, B, C]

• list2.add("B"); : list2의 맨 뒤에 추가된다.
• list2.add(3, "A"); : 인덱스가 3인 위치에 "A"가 추가된다.

list2.set(3, "AA");

list2 = [0, 2, 4, AA, B, C]

• list2.set(3, "AA"); : 인덱스가 3인 위치의 객체가 "AA"로 변경된다.

list1.add(0, "1");
int result1 = list1.indexOf("1");
int result2 = list1.indexOf(1);

list1 = [1, 0, 1, 2, 3, 4, 5] result1 = 0 result2 = 2

• list1에서 인덱스가 0인 첫 번째 1은 String 타입의 "1" 이고 인덱스가 2인 두 번째 1은 Integer 타입의 new Integer(1) 이다.

list1.remove(1);

list1 = [1, 1, 2, 3, 4, 5]

• 왜 0이 없어진걸까? 객체 new Integer(1) 이 아닌 인덱스가 1인 new Integer(0) 객체가 제거됐기 때문이다. 따라서 new Integer(1) 객체를 삭제하고 싶다면 정확하게 list1.remove(new Integer(1)); 라고 해줘야 한다.

System.out.println("list1.retainAll(list2) = " 
+ list1.retainAll(list2));

list1.retainAll(list2) = true list1 = [2, 4] list2 = [0, 2, 4, AA, B, C]

• list1.retainAll(list2) : list1에서 list2와 겹치는 부분만 남기고 나머지는 모두 삭제

for (int i = list2.size() - 1; i >= 0; i--) {
    if (list1.contains(list2.get(i)))
        list2.remove(i);
}

list1 = [2, 4] list2 = [0, AA, B, C]

• list2에서 list1에 포함된 객체들을 삭제

• 1. get(i)로 list2에서 객체를 하나씩 꺼낸다.
  2. contains()로 꺼낸 객체가 list1에 있는지 확인한다.
  3. remove(i)로 해당 객체를 list2에서 삭제한다.

ArrayList에 저장된 객체의 삭제 과정

ArrayList인 alphabet에서 "C"를 삭제하는 과정

ArrayList<String> alphabet = new ArrayList<>(7); // 배열의 길이 7
alphabet.add("A");
alphabet.add("B");
alphabet.add("C");
alphabet.add("D");
alphabet.add("E");

alphabet.remove(2); // 인덱스가 2인 위치의 "C" 삭제

1. 삭제할 데이터의 다음 데이터부터 마지막 데이터까지 한 칸씩 위로 복사해서 삭제할 데이터를 덮어쓴다.

System.arraycopy(alphabet, 3, alphabet, 2, 2);

• alphabet[3] 부터 2(마지막 인자)만큼의 길이를 alphabet[2]에 복사한다는 뜻이다.

2. 데이터가 모두 한 칸씩 이동했으므로 마지막 데이터를 null로 변경한다.

alphabet[size - 1] = null;

3. 데이터가 삭제되어 데이터의 개수가 줄었으므로 size의 값을 감소시킨다.

size--;

[참고] 마지막 데이터를 삭제하는 경우는 1번의 과정(배열 복사)이 필요 없다.

결국, 배열의 복사가 일어나는 1번 과정이 부담이 많이 가는 과정이기 때문에 되도록이면 1번 과정이 없는 것이 좋다.

ArrayList에 저장된 첫 번째 객체부터 삭제하는 경우(배열의 복사 발생)

for(int i = 0; i < alphbet.size(); i++) {
    alphabet.remove(i);
}

• 첫 번째 객체부터 삭제하면 배열의 복사(1번 과정)가 반복되기 때문에 전부 삭제가 되지 않는다.

ArrayList에 저장된 마지막 객체부터 삭제하는 경우(배열의 복사 발생X)

for(int i = alphbet.size() -1; i >= 0; i--) {
    alphabet.remove(i);
}

• 마지막부터 삭제하면 배열의 복사가 발생하지 않기 때문에 제대로 전부 삭제가 된다.
• 배열의 복사가 발생하지 않기 때문에 부담이 안가서 성능도 더 좋다.

📌LinkedList

배열의 장단점 장점 : 배열은 구조가 간단하고 데이터를 읽는데 걸리는 시간(접근 시간, access time)이 짧다.

단점1 : 크기를 변경할 수 없다.

• 크기를 변경해야 하는 경우 새로운 배열을 생성 후 데이터를 복사해야 한다. (더 큰 배열 생성 -> 복사 -> 참조 변경)
• 크기 변경을 피하기 위해 충분히 큰 배열을 생성하면 메모리가 낭비된다.

단점2 : 비순차적인 데이터의 추가, 삭제에 시간이 많이 걸린다.

• 중간 데이터를 추가, 삭제하기 위해 다른 데이터를 옮겨야 한다.
• 순차적인 데이터 추가(끝에 추가), 삭제(끝에 삭제)는 빠르다.

배열의 단점을 복사하기 위해 나온게 LinkedList 이다.

• 배열과 달리 LinkedList는 불연속적으로 존재하는 데이터를 연결(link)한다.

class Node {
    Node next;
    Object data;
}

• next : 다음 노드의 주소

• data : 데이터 값

• 데이터 삭제 : 단 한번의 참조 변경만으로 가능

• 데이터 추가 : 한번의 Node 객체 생성과 두번의 참조 변경만으로 가능

LinkedList - 이중 연결 리스트

LinkedList : 연결리스트. 데이터 접근성이 나쁘다.

더블리 링크드 리스트(doubly linked list) : 이중 연결 리스트. 접근성 향상

더블리 써큘러 링크드 리스트(doubly circular linked list) : 이중 원형 연결 리스트

ArrayList vs. LinkedList 성능 비교

• 순차적으로 데이터 추가/삭제 : ArrayList가 빠르다.

• 비순차적으로 데이터 추가/삭제 : LinkedList가 빠르다.

• 접근 시간(access time) : ArrayList가 빠르다.

  인덱스가 n인 데이터의 주소 = 배열의 주소 + n * 데이터 타입의 크기

ArrayList : 배열의 복사를 줄이기 위해 배열을 크게 설정하게 되면 비효율적인 메모리 사용이 된다.(배열 기반 - 연속적)

LinkedList : 데이터가 많을수록 접근성이 떨어진다.(연결 기반 - 불연속적)

📌스택과 큐(Stack & Queue)

스택(Stack) : LIFO(Last In First Out) 구조. 마지막에 저장된 것을 제일 먼저 꺼낸다. ArrayList로 구현하는게 유리

큐(Queue) : FIFO(First In First Out) 구조. 제일 먼저 저장한 것을 제일 먼저 꺼낸다. LinkedList로 구현하는게 유리

스택(Stack)의 메서드

Stack 클래스가 있기 때문에 Stack st = new Stack(); 사용 가능

큐(Queue)의 메서드

Queue는 인터페이스이기 때문에 Queue를 구현한 클래스로 객체를 생성해야 한다.

• Queue를 구현한 클래스 목록

Queue q = new LinkedList();
q.offer("A");

• 참조변수 타입을 Queue로 하게 되면 나중에 객체를 다른 클래스로 변경해도 그 아래의 코드들을 검토할 필요가 없다. 참조 변수 타입이 Queue라면 Queue에 있는 메서드들만 사용했다는 의미가 되기 때문이다.

스택과 큐의 활용

스택의 활용 예 : 수식 계산, 수식 괄호 검사, 워드프로세서의 undo/redo, 웹브라우저의 뒤로/앞으로

수식 괄호 검사

Stack<String> st = new Stack<>();
String expression = "((2+4)*7)/2";
System.out.println("expression = " + expression);

try {
    for (int i = 0; i < expression.length(); i++) {
       if (expression.charAt(i) == '(')
            st.push(expression.charAt(i) + "");
        else if (expression.charAt(i) == ')')
            st.pop();
    }
    if (st.empty())
        System.out.println("괄호가 일치합니다.");
    else
        System.out.println("괄호가 불일치합니다.");

} catch (EmptyStackException e) {
    System.out.println("괄호가 불일치합니다. 예외 발생");
}

expression = ((2+4)*7)/2 괄호가 일치합니다.

expression = ((2+4)*7/2 괄호가 불일치합니다.

• 스택 안에 '('가 아직 남아있어서 괄호가 불일치합니다 라고 출력된다.

expression = ((2+4)*7))))/2 괄호가 불일치합니다. 예외 발생

• 스택이 비어있는데도 st.pop()이 실행되서 EmptyStackExcpetion 예외가 발생

큐의 활용 예 : 최근 사용 문서, 인쇄 작업 대기 목록, 버퍼(buffer)

최근 사용 명령어 출력

public static void save(String input) {
    if (!"".equals(input))
        q.offer(input);

    if (q.size() > MAX_SIZE)
        q.poll();
}

• if (!"".equals(input)) : 빈 문자열이 입력 받은 것과 같지 않다면 동작. !input.equals("") 이렇게 적어도 되지만 이러면 input이 null 일때 NullPointerException이 발생한다. !"".equals(input) 이렇게 작성해주면 input이 null 이어도 예외가 발생하지 않고 빈 문자열인 "" 도 null이 될수 없기 때문에 이렇게 작성해준다.

final int SIZE = list.size();
for (int i = 0; i < SIZE; i++) {
    System.out.println((i + 1) + ". " + list.get(i));
}

• 범위를 i < list.size() 이렇게 지정해주면 for 문을 돌 때 마다 list.size()를 호출하게 된다. for 문을 돌 때 size()는 바뀌지 않으므로 final int SIZE = list.size(); 로 size()를 한번만 알아내고 for 문을 돌 때는 i < SIZE 이렇게 상수를 이용하는게 좋은 코드이다.

📌Iterator

컬렉션에 저장된 데이터를 접근하는데 사용되는 인터페이스

컬렉션에 저장된 요소들을 읽어오는 방법을 표준화한 것

List list = new ArrayList(); // 다른 컬렉션으로 바꿀 때 이 부분만 고치면 된다.
Iterator it = list.iterator();

while (it.hasNext())
    System.out.println(it.next());

• 컬렉션마다 저장된 객체들을 읽어오는 방법이 다르다. Iterator 인터페이스를 쓰게 되면 다른 컬렉션으로 변경되도 읽어오는 방법은 다 똑같기 때문에 코드의 변경이 줄어든다.

public interface Collection {
    ...
    public Iterator iterator();
    ...
}    

• iterator() 메서드는 Collection 인터페이스 안에 정의되어 있기 때문에 List 인터페이스와 Set 인터페이스에 전부 구현 되어있는 메서드이다.

실습 예제

import java.util.*;

class Ex11_5 {
    public static void main(String[] args) {
        Collection<Integer> c = new ArrayList<>();
//        Collection<Integer> c = new LinkedList<>();
        c.add(1);
        c.add(2);
        c.add(3);
        c.add(4);

        Iterator<Integer> it = c.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

• Collection<Integer> c = new ArrayList<>(); : 참조변수 타입을 Collecion으로 하게 되면 컬렉션을 LinkedList 로 바꿔도 그 다음의 코드를 바꾸거나 검토할 필요가 없게 된다. 참조 변수 타입이 Collecion 이기 때문에 그 다음의 코드는 Collection에 있는 메서드를 사용했음을 의미하고 따라서 객체를 다른 컬렉션으로 바꿔도 동작한다는 의미이기 때문이다.

Map과 Iterator

Map에는 iterator()가 없다.

Set keySet(), Set entrySet(), Collection values()로 키 또는 값을 Set, Collecion 형식으로 바꾼 후에 iterator() 사용

짝수의 값(value)을 전부 더하는 예제

Collection values() 사용

HashMap<Character, Integer> hashMap = new HashMap<Character, Integer>(){{
    put('a', 1);
    put('b', 4);
    put('c', 6);
    put('d', 9);
}};

int sum = 0;
Collection<Integer> c = hashMap.values();
Iterator<Integer> it = c.iterator();

while (it.hasNext()) {
int i = it.next();
if (i % 2 == 0)
    sum += i;
}
System.out.println("sum = " + sum);

sum = 10

Set keySet() 사용

HashMap<Character, Integer> hashMap = new HashMap<Character, Integer>(){{
    put('a', 1);
    put('b', 4);
    put('c', 6);
    put('d', 9);
}};

int sum = 0;
Set<Character> keySet = hashMap.keySet();
Iterator<Character> it = keySet.iterator();

while (it.hasNext()) {
int i = hashMap.get(it.next());
if (i % 2 == 0)
    sum += i;
}
System.out.println("sum = " + sum);

sum = 10

Set entrySet() 사용

HashMap<Character, Integer> hashMap = new HashMap<Character, Integer>(){{
    put('a', 1);
    put('b', 4);
    put('c', 6);
    put('d', 9);
}};

int sum = 0;
Set<Map.Entry<Character, Integer>> entrySet = hashMap.entrySet();
Iterator<Map.Entry<Character, Integer>> it = entrySet.iterator();

while (it.hasNext()) {
int i = it.next().getValue();
if (i % 2 == 0)
    sum += i;
}
System.out.println("sum = " + sum);

sum = 10

• getValue() : Entry 객체의 Value 객체를 반환