슬라이딩 윈도우란 고정된 사이즈의 윈도우가 이동하면서 윈도우 내에 있는 데이터를 이용해 문제를 풀이하는 알고리즘이다. 투 포인터와 유사하지만 일반적으로 고정 사이즈 윈도우를 사용하는 경우 슬라이딩 윈도우를 구분한다. 또한, 투포인터는 주로 정렬된 리스트를 대상으로 하지만 슬라이딩 윈도우는 정렬 여부에 관계 없이 사용 가능하다.

예시

[1, 5, -3, 6, 10, -14, -2] 라는 배열이 있는데 연속적인 4개의 숫자의 합이 최대인 값을 찾는 경우를 들 수 있다.

구현

array=[1, 5, -3, 6, 10, -14, -2]
n = len(array)
size=5
window=sum(array[:size])
answer=window

for i in range(size, n) :
        window += array[i] - array[i-size]
        answer=max(answer, window)

print(answer)

JPA n+1 문제

n+1문제

연관관계가 설정된 엔티티를 조회할 경우에 조회된 데이터의 개수(n)만큼 연관관계 조회 쿼리가 추가로 발생하여 데이터를 읽어오는 현상을 말한다.

테이블 간의 관계

챌린지에 대한 정보가 들어있는 챌린지 테이블과 해시태그의 정보가 있는 해시태그 테이블이 있고 챌린지와 해시태그를 매핑해주는 중간테이블이 존재한다.

상황 설명

챌린지를 조회하면 해당 챌린지의 해시태그도 가져와서 보여주어야한다. 또한, 검색 keyword가 챌린지 제목에 포함된 경우와 keyword와 일치하는 해시태그가 존재하는 챌린지를 검색해서 보여준다.

해결

application.yml 추가 설정

쿼리를 좀 더 편하게 관리하기 위해 추가 설정을 했다.

spring:
    jpa:
        show-sql: true //퀴리 출력
        properties:
          hibernate:
            format_sql: true //출력되는 쿼리의 포맷 예쁘게
            generate_statistics: true

만약 application.properties의 경우

spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.generate_statistics=true

수정 전

@Override
public List<Challenge> findSearchTitleSortById(String keyword) {
    QChallengeHashTag challengehashtag=QChallengeHashTag.challengeHashTag;
    QChallenge challenge=QChallenge.challenge;
    QHashTag hashTag= QHashTag.hashTag;
    return queryFactory.selectFrom(challenge)
            .leftJoin(challengehashtag).on(challengehashtag.challenge.id.eq(challenge.id))
            .leftJoin(hashTag).on(challengehashtag.hashTag.id.eq(hashTag.id))
            .where(challenge.title.contains(keyword).or(hashTag.contents.eq(keyword)), challenge.vigibility.eq(true), challenge.startDate.after(LocalDate.now()))
            .orderBy(challenge.id.desc())
            .fetch();

}

Hibernate: 
    select
        c1_0.id,
        c1_0.authentication_type,
        c1_0.created_at,
        c1_0.deleted_at,
        c1_0.description,
        c1_0.end_date,
        c1_0.modified_at,
        c1_0.start_date,
        c1_0.title,
        c1_0.user_id,
        c1_0.vigibility 
    from
        challenge c1_0 
    left join
        challenge_hashtag c2_0 
            on c2_0.challenge_id=c1_0.id 
    left join
        hashtag h1_0 
            on c2_0.hash_tag_id=h1_0.id 
    where
        (
            c1_0.deleted_at is NULL
        ) 
        and (
            c1_0.title like ? escape '!' 
            or h1_0.contents=?
        ) 
        and c1_0.vigibility=? 
        and c1_0.start_date>? 
    order by
        c1_0.id desc
Hibernate: 
    select
        h1_0.id,
        h1_0.contents 
    from
        hashtag h1_0 
    where
        h1_0.id=?
Hibernate: 
    select
        h1_0.id,
        h1_0.contents 
    from
        hashtag h1_0 
    where
        h1_0.id=?
2023-04-23T18:02:58.662+09:00  WARN 78053 --- [nio-8080-exec-1] actStandardFragmentInsertionTagProcessor : [THYMELEAF][http-nio-8080-exec-1][challenges/list] Deprecated unwrapped fragment expression "fragments/head :: frag-header" found in template challenges/list, line 5, col 15. Please use the complete syntax of fragment expressions instead ("~{fragments/head :: frag-header}"). The old, unwrapped syntax for fragment expressions will be removed in future versions of Thymeleaf.
2023-04-23T18:02:58.714+09:00  WARN 78053 --- [nio-8080-exec-1] actStandardFragmentInsertionTagProcessor : [THYMELEAF][http-nio-8080-exec-1][challenges/list] Deprecated unwrapped fragment expression "fragments/nav :: menu" found in template challenges/list, line 9, col 72. Please use the complete syntax of fragment expressions instead ("~{fragments/nav :: menu}"). The old, unwrapped syntax for fragment expressions will be removed in future versions of Thymeleaf.
2023-04-23T18:02:58.737+09:00  WARN 78053 --- [nio-8080-exec-1] actStandardFragmentInsertionTagProcessor : [THYMELEAF][http-nio-8080-exec-1][challenges/list] Deprecated unwrapped fragment expression "fragments/footer :: frag-footer" found in template challenges/list, line 52, col 19. Please use the complete syntax of fragment expressions instead ("~{fragments/footer :: frag-footer}"). The old, unwrapped syntax for fragment expressions will be removed in future versions of Thymeleaf.
2023-04-23T18:02:58.740+09:00  INFO 78053 --- [nio-8080-exec-1] i.StatisticalLoggingSessionEventListener : Session Metrics {
    7215250 nanoseconds spent acquiring 1 JDBC connections;
    0 nanoseconds spent releasing 0 JDBC connections;
    440875 nanoseconds spent preparing 5 JDBC statements;
    39466042 nanoseconds spent executing 5 JDBC statements;
    0 nanoseconds spent executing 0 JDBC batches;
    0 nanoseconds spent performing 0 L2C puts;
    0 nanoseconds spent performing 0 L2C hits;
    0 nanoseconds spent performing 0 L2C misses;
    0 nanoseconds spent executing 0 flushes (flushing a total of 0 entities and 0 collections);
    82166 nanoseconds spent executing 3 partial-flushes (flushing a total of 0 entities and 0 collections)
}

select문이 여러개가 나오는걸 확인할 수 있다. 이경우 query dsl의 fetch join을 사용하여 해결할 수 있다.

fetch join

조인하는 대상 데이터를 즉시 로딩해서 가져온다.

첫번째 시도

@Override
public List<Challenge> findSearchTitleSortById(String keyword) {
    QChallengeHashTag challengehashtag=QChallengeHashTag.challengeHashTag;
    QChallenge challenge=QChallenge.challenge;
    QHashTag hashTag= QHashTag.hashTag;
    return queryFactory.selectFrom(challenge)
            .leftJoin(challengehashtag).on(challengehashtag.challenge.id.eq(challenge.id))
            .fetchJoin()
            .leftJoin(hashTag).on(challengehashtag.hashTag.id.eq(hashTag.id))
            .fetchJoin()
            .where(challenge.title.contains(keyword).or(hashTag.contents.eq(keyword)), challenge.vigibility.eq(true), challenge.startDate.after(LocalDate.now()))
            .orderBy(challenge.id.desc())
            .fetch();

}

fetchJoin()을 사용했는데도 똑같았다... 그래서 찾아본 결과 querydsl에서 on()절로 매핑하면 두 엔티티가 연관관계라는 것을 인식하지 못한다. 그렇기 때문에 leftJoin대신 join으로 수정해서 해결했다.

두번째 시도

@Override
public List<Challenge> findSearchTitleSortById(String keyword) {
    QChallengeHashTag challengehashtag=QChallengeHashTag.challengeHashTag;
    QChallenge challenge=QChallenge.challenge;
    QHashTag hashTag= QHashTag.hashTag;
    return queryFactory.selectFrom(challenge)
            .leftJoin(challengehashtag).on(challengehashtag.challenge.id.eq(challenge.id))
            .fetchJoin()
            .leftJoin(hashTag).on(challengehashtag.hashTag.id.eq(hashTag.id))
            .fetchJoin()
            .where(challenge.title.contains(keyword).or(hashTag.contents.eq(keyword)), challenge.vigibility.eq(true), challenge.startDate.after(LocalDate.now()))
            .orderBy(challenge.id.desc())
            .fetch();

}

Hibernate: 
    select
        c1_0.id,
        c1_0.authentication_type,
        c2_0.challenge_id,
        c2_0.id,
        h1_0.id,
        h1_0.contents,
        c1_0.created_at,
        c1_0.deleted_at,
        c1_0.description,
        c1_0.end_date,
        c1_0.modified_at,
        c1_0.start_date,
        c1_0.title,
        c1_0.user_id,
        c1_0.vigibility 
    from
        challenge c1_0 
    join
        challenge_hashtag c2_0 
            on c1_0.id=c2_0.challenge_id 
    join
        hashtag h1_0 
            on h1_0.id=c2_0.hash_tag_id 
    where
        (
            c1_0.deleted_at is NULL
        ) 
        and (
            c1_0.title like ? escape '!' 
            or h1_0.contents=?
        ) 
        and c1_0.vigibility=? 
        and c1_0.start_date>? 
    order by
        c1_0.id desc
2023-04-23T17:56:46.808+09:00  WARN 77804 --- [nio-8080-exec-6] actStandardFragmentInsertionTagProcessor : [THYMELEAF][http-nio-8080-exec-6][challenges/list] Deprecated unwrapped fragment expression "fragments/head :: frag-header" found in template challenges/list, line 5, col 15. Please use the complete syntax of fragment expressions instead ("~{fragments/head :: frag-header}"). The old, unwrapped syntax for fragment expressions will be removed in future versions of Thymeleaf.
2023-04-23T17:56:46.808+09:00  WARN 77804 --- [nio-8080-exec-6] actStandardFragmentInsertionTagProcessor : [THYMELEAF][http-nio-8080-exec-6][challenges/list] Deprecated unwrapped fragment expression "fragments/nav :: menu" found in template challenges/list, line 9, col 72. Please use the complete syntax of fragment expressions instead ("~{fragments/nav :: menu}"). The old, unwrapped syntax for fragment expressions will be removed in future versions of Thymeleaf.
2023-04-23T17:56:46.819+09:00  WARN 77804 --- [nio-8080-exec-6] actStandardFragmentInsertionTagProcessor : [THYMELEAF][http-nio-8080-exec-6][challenges/list] Deprecated unwrapped fragment expression "fragments/footer :: frag-footer" found in template challenges/list, line 52, col 19. Please use the complete syntax of fragment expressions instead ("~{fragments/footer :: frag-footer}"). The old, unwrapped syntax for fragment expressions will be removed in future versions of Thymeleaf.
2023-04-23T17:56:46.844+09:00  INFO 77804 --- [nio-8080-exec-6] i.StatisticalLoggingSessionEventListener : Session Metrics {
    9087750 nanoseconds spent acquiring 1 JDBC connections;
    0 nanoseconds spent releasing 0 JDBC connections;
    447209 nanoseconds spent preparing 3 JDBC statements;
    26491625 nanoseconds spent executing 3 JDBC statements;
    0 nanoseconds spent executing 0 JDBC batches;
    0 nanoseconds spent performing 0 L2C puts;
    0 nanoseconds spent performing 0 L2C hits;
    0 nanoseconds spent performing 0 L2C misses;
    0 nanoseconds spent executing 0 flushes (flushing a total of 0 entities and 0 collections);
    12667 nanoseconds spent executing 3 partial-flushes (flushing a total of 0 entities and 0 collections)
}

URL

URL은 Uniform Resouce Locator의 약자로 흔히 웹 주소라고도 하며, 컴퓨터 네트워크 상에서 리소스가 어디 있는지 알려주기 위한 규약이다. URL은 웹 사이트 주소뿐만 아니라 컴퓨터 네트워크상의 자원을 모두 나타내는 표기법이다.

URI

URI는 Uniform Resource Identifier의 약자로 특정 리소스를 식별하는 통합 자원 식별자를 의미한다. 웹 기술에서 사용하는 논리적 또는 물리적 리소스를 식별하는 고유한 문자열 시퀀스다.

➡️ URL은 URI에 포함된다

예시

1) http://example.com

위의 경우 URL이면서 URI이다.

2) http://example.com/index 이 경우는 example.com 서버의 index라는 네트워크 상의 자원의 위치를 의미하기 때문에 URL이면서 URI이다.

3) http://example.com/user/1 이 경우는 user 정보에 식별자 1을 포함하기 때문에 URId이다. 즉, URI이지만 URL은 아니다.

4) http://example.com/user?id=1 이 경우에 http://example.com/user까지는 자원의 실제 위치를 나타내기 때문에 URL이라고 할 수 있지만, 뒤는 쿼리 스트링 식별자를 포함하기 때문에 URI이다,.

QueryDsl은 정적 타입을 이용해서 SQL과 같은 쿼리를 생성할 수 있도록 해주는 프레임워크이다.

JPA가 기본적으로 제공해주는 기능을 사용하더라도, 원하는 조건의 데이터를 수집하기 위해서는 필연적으로 JPQL을 작성하게 된다. 간단한 로직을 구현할 때는 상관없지만 복잡한 로직의 경우 쿼리가 길어진다. 또한 쿼리를 실행하기 전까지 에러를 발견할 수 없다.

QueryDSL장점

1. 문자가 아닌 코드로 쿼리를 작성함으로써, 컴파일 시점에 문법 오류를 쉽게 확인할 수 있다.
2. 자동 완성 등 IDE의 도움을 받을 수 있다.
3. 동적인 쿼리 작성이 편리하다.
4. 쿼리 작성 시 제약 조건 등을 메서드 추출을 통해 재사용할 수 있다.

QueryDsl 설정

💡 버전 springboot 3.0.1 java 17

래퍼런스를 참조해서 querydsl denpendency를 추가하려 하는데 springboot 3.0 이상 버전에서는 기존과는 다르게 설정해주어야했다.

build.gradle

dependencies {
    //...
    //querydsl dependencies 추가(스프링부트 3.0 이상)
    implementation 'com.querydsl:querydsl-jpa:5.0.0:jakarta'
    annotationProcessor "com.querydsl:querydsl-apt:${dependencyManagement.importedProperties['querydsl.version']}:jakarta"

    annotationProcessor "jakarta.annotation:jakarta.annotation-api"
    annotationProcessor "jakarta.persistence:jakarta.persistence-api"
}

QueryDslConfig

dependencies {
    //...
    //querydsl dependencies 추가(스프링부트 3.0 이상)
    implementation 'com.querydsl:querydsl-jpa:5.0.0:jakarta'
    annotationProcessor "com.querydsl:querydsl-apt:${dependencyManagement.importedProperties['querydsl.version']}:jakarta"

    annotationProcessor "jakarta.annotation:jakarta.annotation-api"
    annotationProcessor "jakarta.persistence:jakarta.persistence-api"
}

RequestBody로 boolean 타입을 true로 보냈는데 false로 DB에 저장되는 것을 발견했다.

원인

@Getter, @Setter 어노테이션을 사용하는 경우 boolean 타입에 붙는 prefix는 get이 아니라 is이기 때문에 @RequestBody에서 찾을 수가 없어 바인딩이 되지 않아 false로 저장된다.

해결 방법

1. Boolean타입 사용하기

   //...
   Boolean isVigibility;

2. getIsXXX() getter 메소드 직접 작성하기

   public boolean getIsVigilibity(){
    return this.isVigility;
   }

동기부여를 위한 챌린지 서비스에서 사용자가 챌린지를 생성하기도 하고 이미 존재하는 챌린지에 참여를 할 수도 있다. 이 때 유저와 챌린지 테이블간의 다대다 관계가 발생했다. 다대다 관계는 서로가 서로를 맵핑하기 때문에 단순하게 서로가 서로를 갖도록 구현하면 JPA에서 여러가지 에러가 발생하게 된다.

해결

중간 테이블을 생성해서 N:M 관계를 1:N, M:1로 분리시켰다. 즉, 유저와 챌린지의 관계를 중간에 참여 테이블을 생성해서 유저와 참여, 참여와 챌린지 테이블로 나누게 된다. 챌린지 테이블에서는 챌린지의 정보만 갖게 되고 참여테이블에서는 어떤 유저가 어떤 챌린지를 참여하고 있는지를 관리하도록 했다.

Challenge

@Entity
@Getter
@Builder
@AllArgsConstructor
@NoArgsConstructor
@EntityListeners(AuditingEntityListener.class)
@Where(clause="deleted_at is NULL")
public class Challenge {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String title;
    private String description;
    private boolean vigibility;
    @Enumerated(EnumType.STRING)
    private AuthenticationType authenticationType;

    private Long userId;

    private LocalDate startDate;
    private LocalDate endDate;

    @CreatedDate
    private LocalDateTime createdAt;

    @LastModifiedDate
    private LocalDateTime modifiedAt;

    private LocalDateTime deletedAt;

    //...
}

User

@Builder
@AllArgsConstructor
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Getter
@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String name;

    @Column(nullable = false)
    private String email;

    private String picture;

    private String oauthId;

    @Enumerated(EnumType.STRING)
    @Column(nullable = false)
    private UserRole role;

    //...
}

Participation

@Entity
@Builder
@Getter
@AllArgsConstructor
@NoArgsConstructor
public class Participation {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name="user_id")
    private User user;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name="challenge_id")
    private Challenge challenge;

    //...
}

• commit 목록 확인

  git log

• 방법 1 : commit을 취소하고 해당 파일들은 staged 상태로 Working Directory에 보존

  git reset --soft HEAD^

• 방법 2 : commit을 취소하고 해당 파일들은 unstaged 상태로 Working Directory에 보존

  git reset --mixed HEAD^
  git reset HEAD^

• 방법 3 : commit을 취소하고 해당 파일들은 unstaged 상태로 Working Directory에 삭제

  git reset --hard HAED^

💡 reset 옵션

• soft : index 보존(add한 상태, staged 상태), 워킹 디렉터리의 파일 보존.
• mixed : index 취소(add하기 전 상태, unstaged 상태). 워킹 디렉터리의 파일 보존
• hard : index 취소(add하기 전 상태, unstaged 상태). 워킹 디렉터리의 파일 삭제

git push 취소하기

이 경우는 자신의 local 내용을 remote에 강제로 덮어쓰기 하는 것이기 때문에 주의해야한다.

가장 최근의 commit을 취소하고 Working Directory를 되돌리는 경우

git reset HEAD^

원하는 시점으로 Working Directory를 되돌리는 경우

• reflog(브랜치와 HEAD가 가리켰었던 커밋) 목록 확인

  git reflog
  //or
  git log -g

• 원하는 시점으로 Working Directory 되돌리기

  git reset HEAD@{number}
  //or
  git reset [commit id]

• 되돌린 시점으로 remote 변경하는 경우

  git push -f origin main
  git push -force 브랜치 이름

https://www.acmicpc.net/problem/1516

📝문제

숌 회사에서 이번에 새로운 전략 시뮬레이션 게임 세준 크래프트를 개발하기로 하였다. 핵심적인 부분은 개발이 끝난 상태고, 종족별 균형과 전체 게임 시간 등을 조절하는 부분만 남아 있었다.

게임 플레이에 들어가는 시간은 상황에 따라 다를 수 있기 때문에, 모든 건물을 짓는데 걸리는 최소의 시간을 이용하여 근사하기로 하였다. 물론, 어떤 건물을 짓기 위해서 다른 건물을 먼저 지어야 할 수도 있기 때문에 문제가 단순하지만은 않을 수도 있다. 예를 들면 스타크래프트에서 벙커를 짓기 위해서는 배럭을 먼저 지어야 하기 때문에, 배럭을 먼저 지은 뒤 벙커를 지어야 한다. 여러 개의 건물을 동시에 지을 수 있다.

편의상 자원은 무한히 많이 가지고 있고, 건물을 짓는 명령을 내리기까지는 시간이 걸리지 않는다고 가정하자.

입력

첫째 줄에 건물의 종류 수 N(1 ≤ N ≤ 500)이 주어진다. 다음 N개의 줄에는 각 건물을 짓는데 걸리는 시간과 그 건물을 짓기 위해 먼저 지어져야 하는 건물들의 번호가 주어진다. 건물의 번호는 1부터 N까지로 하고, 각 줄은 -1로 끝난다고 하자. 각 건물을 짓는데 걸리는 시간은 100,000보다 작거나 같은 자연수이다. 모든 건물을 짓는 것이 가능한 입력만 주어진다.

출력

N개의 각 건물이 완성되기까지 걸리는 최소 시간을 출력한다. 예제입력1

5
10 -1
10 1 -1
4 1 -1
4 3 1 -1
3 3 -1

예제출력

10
20
14
18
17

풀이

이 문제는 어떤 건물을 짓기 위해서 다른 건물을 먼저 지어야 할 수도 있기 때문에 순서가 정해져 있는 작업이다. 이런 순서가 정해져 있는 작업을 차례로 수행해야할 때 그 순서를 결정해주기 위한 알고리즘이 위상정렬이다.

위상정렬

위상 정렬은 순서가 정해져 있는 작업을 차례로 수행해야 할 때 그 순서를 결정해주기 위해 사용하는 알고리즘이다. 위의 문제를 예시로 순서를 확인해보면 아래 그림과 같다.이때, 만약 사이클이 발생한다면 위상 정렬을 수행할 수 없다. 위상 정렬 : 1번 집->2번, 3번 집->4번, 5번 집 위상 정렬 알고리즘을 구현하는 방법에는 스택을 이용하는 방법과 큐를 이용하는 방법이 있다.

과정

과정

1. 진입차수가 0인 정점을 큐/스택에 삽입한다.
2. 큐/스택에서 원소를 꺼내고 해당 원소와 연결된 모든 간선을 제거한다.
3. 간선 제거 이후 진입차수가 0인 정점을 큐/스택에 삽입한다.
4. 2번~3번 과정을 큐/스택에 더 이상 원소가 없을 때까지 반복한다.
5. 모든 원소를 방문하기 전에 큐/스택가 빈다면 사이클이 존재하는 것이고 모든 원소를 방문했다면 큐/스택에서 꺼낸 순서가 위상 정렬 결과이다.

그래프에서 1번 집이 진입차수가 0이기 때문에 큐에 해당 정점을 삽입한다. queue = [1] 큐에서 원소를 꺼내고 해당 원소와 연결된 모든 간선을 제거한다. 즉, 1번집에서 2, 3번집으로 연결된 간선을 제거한다. 진입차수가 0인 2, 3번 정점을 큐에 삽입한다.

queue=[2, 3] answer=[1] 큐에서 2번 원소를 꺼내고 2번 원소와 연결된 모든 간선을 제거한다. queue=[3] answer=[1, 2] 이 예시에는 2번과 연결된 간선이 없기 때문에 생략하고 3번 원소를 꺼낸다. 4, 5번 정점과 연결된 간선을 제거하고 진입차수가 0인 정점을 큐에 삽입한다.

queue=[4, 5] answer=[1, 2, 3] 위 처럼 2, 3번 과정을 반복하면 큐가 비어있게 되고 answer=[1, 2, 3, 4, 5]가 된다. 이 결과값이 위상정렬 값이다.

🖥문제 구현

import sys
from collections import deque
input=sys.stdin.readline

n=int(input())
building=[[] for _ in range(n+1)]
degree=[0]*(n+1) #진입차수
cost=[0]*(n+1)
answer=[0]*(n+1)
q=deque()
for i in range(1, n+1) :
    data=list(map(int, input().split()))
    cost[i]=data[0]
    for data in data[1:-1] :
        building[data].append(i)
        degree[i]+=1

for i in range(1, n+1):
    if degree[i]==0:
        q.append(i)
        answer[i]=cost[i]

while q :
    x=q.popleft()
    for i in building[x] :
        degree[i]-=1
        answer[i]=max(answer[i], answer[x]+cost[i])
        if degree[i]==0:
            q.append(i)
for i in range(1, n+1):
    print(answer[i])

가장 최근 commit 수정

  git commit --amend

명령어를 입력하면 다음과 같은 화면을 볼 수 있다.

i를 입력해서 INSERT 모드로 바꾼 후 커밋 메시지를 수정하면 된다. 저장을 할 때는 esc->:wq를 입력해주면 된다. 수정하지 않고 종료할 때는 :q를 입력해주면 된다.

여러 commit 수정

• commit 목록

  git log

  

  로그에서 지금까지 커밋들을 확인 후 어떤 커밋을 수정할 것인지 확인을 한다. 두번째 커밋을 수정하고 싶다면 아래 명령어를 입력한다.

  • 수정할 commit 선택

    git rebase -i HEAD~3 

    

  가장 최근 commit 2개를 보여준다. 수정하고 싶은 커밋 옆의 pick을 reword로 바꾼 후(i를 입력해 수정모드로 변경) esc->:wq로 저장해준다. 이러면 수정할 커밋 창이 순서대로 띄워진다. 커밋 메시지를 수정하고 저장을 한다. git log를 통해 수정이 된 것을 확인할 수 있다.

💡 commit 하지 않은 파일이 있는 경우

error: cannot rebase: You have unstaged changes.
error: Please commit or stash them.

커밋을 하지 않은 파일이 있는 경우 위와 같은 error가 발생한다. 이 경우는 저장을 해야하는 경우는 commit을 하거나 git stash로 변경사항을 임시저장하면 된다.

• git stash 아직 마무리하지 않은 작업을 스택에 잠시 저장할 수 있도록 하는 명령어이다. 아직 완료하지 않은 일을 commit 하지 않고 나중에 다시 꺼내와 마무리할 수 있다.

  git stash
  git stash save

  위의 명령어 중 하나를 실행하면 새로운 stash가 만들어지고 working directory가 깨끗해진다. 이제 다시 새로운 브랜치를 생성할 수 있고 commit 메시지를 수정할 수 있다.
• git stash 목록

  git stash list

• 임시저장한 내용을 다시 가져오기

  //가장 최근의 stash를 가져와서 적용
  git stash apply
  //stash 이름에 해당하는 stash를 적용
  git stash apply [stash 이름]

• stash 제거하기

  //가장 최근 stash 제거
  git stash drop
  //stash 이름에 해당하는 stash 제거
  git stash drop [stash 이름]

  push 후 commit 메시지 변경

  커밋을 이미 push 해 remote에 올린 상황인 경우는 push하기 전과 동일하게 commit 메시지를 수정한 후 force를 통해 수정된 커밋을 강제로 push 해 주어야한다.

  git push -force 브랜치 이름
  git push -f origin main

  하지만 이런 상황을 최대한 자제해야한다. push된 커밋 로그를 갖고 있던 다른 팀원들이 로그를 수동으로 수정해주어야하는 상황이 발생하기 때문이다. 그렇기 때문에 push를 하기 전에는 신중해야한다.

과정

1. csv 파일 불러와서 parsing
2. parsing한 데이터 DB insert

CSV 파일 불러와서 Parsing

ReadLineContext.java 파일에서 한줄씩 읽어와서 parse 메서드를 통해 파싱을 한 결과를 result 리스트에 추가한다.

package com.springboot.hospitalsearchapi.parser;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class ReadLineContext<T> {
    Parser<T> parser;

    public ReadLineContext(Parser<T> parser) {
        this.parser = parser;
    }

    public List<T> readByLine(String filename) throws IOException {
        // 삽
        List<T> result = new ArrayList<>();
        BufferedReader reader = new BufferedReader(
                new FileReader(filename)
        );
        String str;
        while ((str = reader.readLine()) != null) {
            try {
                result.add(parser.parse(str));
            }catch(Exception e){
                System.out.printf("파싱 중 문제가 생겨 이 라인은 넘어갑니다. 파일내용 : %s\n", str.substring(0, 20));
            }
        }
        reader.close();
        return result;
    }

}

Parser.java Parser 인터페이스이다.

package com.springboot.hospitalsearchapi.parser;

public interface Parser<T> {
    T parse(String str);
}

ParserFactory.java

package com.springboot.hospitalsearchapi.parser;

import com.springboot.hospitalsearchapi.domain.Hospital;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ParserFactory {
    @Bean
    public ReadLineContext<Hospital> hospitalReadLineContextest(){
        return new ReadLineContext<Hospital>(new HospitalParser());
    }
}

HospitalParser.java 병원정보 한줄을 파싱하고 Hospital 객체를 생성해서 반환한다.

package com.springboot.hospitalsearchapi.parser;

import com.springboot.hospitalsearchapi.domain.Hospital;

import java.time.LocalDate;
import java.time.LocalDateTime;

public class HospitalParser implements Parser<Hospital>{

    @Override
    public Hospital parse(String str) {
        String[] splitted = str.split("\",\"");
        Hospital hospital = new Hospital();
        hospital.setId(Integer.parseInt(splitted[0].replace("\"","")));
        hospital.setOpenServiceName(splitted[1]);
        hospital.setOpenLocalGovernmentCode(Integer.parseInt(splitted[3]));
        hospital.setManagementNumber(splitted[4]);

        int year=Integer.parseInt(splitted[5].substring(0, 4));
        int month=Integer.parseInt(splitted[5].substring(4, 6));
        int day=Integer.parseInt(splitted[5].substring(6, 8));
        hospital.setLicenseDate(LocalDateTime.of(year, month, day, 0, 0, 0));

        hospital.setBusinessStatus(Integer.parseInt(splitted[7]));
        hospital.setBusinessStatusCode(Integer.parseInt(splitted[9]));
        hospital.setPhone(splitted[15]);
        hospital.setFullAddress(splitted[18]);
        hospital.setRoadNameAddress(splitted[19]);
        hospital.setHospitalName(splitted[21]);
        hospital.setBusinessTypeName(splitted[25]);
        hospital.setHealthcareProviderCount(Integer.parseInt(splitted[29]));
        hospital.setPatientRoomCount(Integer.parseInt(splitted[30]));
        hospital.setTotalNumberOfBeds(Integer.parseInt(splitted[31]));
        hospital.setTotalAreaSize(Float.parseFloat(splitted[32]));
        return hospital;
    }
}

Parsing한 데이터 DB insert

데이터가 십만건이상이라 많은 시간이 걸린다. HospitalDao.java JdbcTemplate를 이용해 DB에 Insert하고 Delete해주는 메서드를 구현했다.

package com.springboot.hospitalsearchapi.dao;

import com.springboot.hospitalsearchapi.domain.Hospital;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;

@Component
@Slf4j
public class HospitalDao {
    private final DataSource dataSource;
    private final JdbcTemplate jdbcTemplate;

    public HospitalDao(DataSource dataSource, JdbcTemplate jdbcTemplate){
        this.dataSource=dataSource;
        this.jdbcTemplate=jdbcTemplate;
    }

    public void add(final Hospital hospital){
        String sql = "Insert into nation_wide_hospitals values " +
                "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
        this.jdbcTemplate.update(sql, hospital.getId(), hospital.getOpenServiceName(),
                hospital.getOpenLocalGovernmentCode(), hospital.getManagementNumber(),
                hospital.getLicenseDate(), hospital.getBusinessStatus(),
                hospital.getBusinessStatusCode(), hospital.getPhone(),
                hospital.getFullAddress(), hospital.getRoadNameAddress(),
                hospital.getHospitalName(), hospital.getBusinessTypeName(),
                hospital.getHealthcareProviderCount(), hospital.getPatientRoomCount(),
                hospital.getTotalNumberOfBeds(), hospital.getTotalAreaSize());
    }

    public int deleteAll(){
        return this.jdbcTemplate.update("delete from nation_wide_hospitals");
    }

    public int getCount(){
        return this.jdbcTemplate.queryForObject(
                "select count(*) from nation_wide_hospitals", Integer.class);
    }
}

HospitalParserTest.java 데이터가 잘 들어가는지 Test하는 코드입니다.

package com.springboot.hospitalsearchapi.parser;

import com.springboot.hospitalsearchapi.dao.HospitalDao;
import com.springboot.hospitalsearchapi.domain.Hospital;
import com.springboot.hospitalsearchapi.service.HospitalService;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;
import java.time.LocalDateTime;
import java.util.List;

import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest
class HospitalParserTest {

    @Autowired
    ReadLineContext<Hospital> hospitalReadLineContext;

    @Autowired
    HospitalDao hospitalDao;

    @Autowired
    HospitalService hospitalService;

    @Test
    @DisplayName("병원정보 전체 add 잘되는지")
    void addAllTest() throws IOException {
        String filename="/Users/minji/Documents/likelion/file/fulldata_01_01_02_P_의원.csv";
        hospitalDao.deleteAll();
        int cnt=hospitalService.insertLargeVolumHospitalData(filename);
        assertEquals(cnt, hospitalDao.getCount());
    }

    @Test
    @DisplayName("Hospital deleteAll, getCount 잘 되는지")
    void deleteAllTest(){
        hospitalDao.deleteAll();
        assertEquals(0, hospitalDao.getCount());
    }

}

병렬처리

데이터가 다 들어가는데 한시간 걸리던 작업이 병렬처리를 하고 나서는 10분 이내로 끝난다. HospitalService.java 추가

package com.springboot.hospitalsearchapi.service;

import com.springboot.hospitalsearchapi.dao.HospitalDao;
import com.springboot.hospitalsearchapi.domain.Hospital;
import com.springboot.hospitalsearchapi.parser.ReadLineContext;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.IOException;
import java.util.List;
import java.util.Optional;

@Service
public class HospitalService {

    private final ReadLineContext<Hospital> hospitalReadLineContext;

    private final HospitalDao hospitalDao;

    public HospitalService(ReadLineContext<Hospital> hospitalReadLineContext, HospitalDao hospitalDao) {
        this.hospitalReadLineContext = hospitalReadLineContext;
        this.hospitalDao = hospitalDao;
    }

    @Transactional
    public int insertLargeVolumeHospitalData(String filename) {
        List<Hospital> hospitalList;
        try {
            hospitalList = hospitalReadLineContext.readByLine(filename);
            System.out.println("파싱이 끝났습니다.");
            hospitalList.stream()
                    .parallel()
                    .forEach(hospital -> {
                        try {
                            this.hospitalDao.add(hospital); // db에 insert하는 구간
                        } catch (Exception e) {
                            System.out.printf("id:%d 레코드에 문제가 있습니다.\n",hospital.getId());
                            throw new RuntimeException(e);
                        }
                    });
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        if (!Optional.of(hospitalList).isEmpty()) {
            return hospitalList.size();
        } else {
            return 0;
        }
    }
}

HospitalParserTest.java 수정

package com.springboot.hospitalsearchapi.parser;

import com.springboot.hospitalsearchapi.dao.HospitalDao;
import com.springboot.hospitalsearchapi.domain.Hospital;
import com.springboot.hospitalsearchapi.service.HospitalService;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;
import java.time.LocalDateTime;
import java.util.List;

import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest
class HospitalParserTest {

    @Autowired
    ReadLineContext<Hospital> hospitalReadLineContext;

    @Autowired
    HospitalDao hospitalDao;

    @Autowired
    HospitalService hospitalService;

    @Test
    @DisplayName("병원정보 전체 add 잘되는지")
    void addAllTest() throws IOException {
        String filename="/Users/minji/Documents/likelion/file/fulldata_01_01_02_P_의원.csv";
        hospitalDao.deleteAll();
        int cnt=hospitalService.insertLargeVolumHospitalData(filename);
        assertEquals(cnt, hospitalDao.getCount());
    }

    @Test
    @DisplayName("Hospital deleteAll, getCount 잘 되는지")
    void deleteAllTest(){
        hospitalDao.deleteAll();
        assertEquals(0, hospitalDao.getCount());
    }

}

https://www.acmicpc.net/problem/2589

📝 문제

보물섬 지도를 발견한 후크 선장은 보물을 찾아나섰다. 보물섬 지도는 아래 그림과 같이 직사각형 모양이며 여러 칸으로 나뉘어져 있다. 각 칸은 육지(L)나 바다(W)로 표시되어 있다. 이 지도에서 이동은 상하좌우로 이웃한 육지로만 가능하며, 한 칸 이동하는데 한 시간이 걸린다. 보물은 서로 간에 최단 거리로 이동하는데 있어 가장 긴 시간이 걸리는 육지 두 곳에 나뉘어 묻혀있다. 육지를 나타내는 두 곳 사이를 최단 거리로 이동하려면 같은 곳을 두 번 이상 지나가거나, 멀리 돌아가서는 안 된다.

입력

첫째 줄에는 보물 지도의 세로의 크기와 가로의 크기가 빈칸을 사이에 두고 주어진다. 이어 L과 W로 표시된 보물 지도가 아래의 예와 같이 주어지며, 각 문자 사이에는 빈 칸이 없다. 보물 지도의 가로, 세로의 크기는 각각 50이하이다.

출력

첫째 줄에 보물이 묻혀 있는 두 곳 사이를 최단 거리로 이동하는 시간을 출력한다.

예제 입력 1

5 7
WLLWWWL
LLLWLLL
LWLWLWW
LWLWLLL
WLLWLWW

예제 출력 1

8

구현

입력받은 maps을 돌면서 해당 위치가 육지인 경우는 bfs로 최단거리를 탐색한다. 첫시도

import sys
from collections import deque
input=sys.stdin.readline

n, m=map(int, input().split())
maps=[list(map(str, input().strip())) for _ in range(n)]

dx=[0, 0, -1, 1]
dy=[-1, 1, 0, 0]

def bfs(a, b):
    q=deque()
    q.append([a, b])
    visit=[[0]*m for _ in range(n)]
    visit[a][b]=1
    time=0
    while q:
        x, y=q.popleft()
        for i in range(4):
            nx, ny=x+dx[i], y+dy[i]
            if 0<=nx<n and 0<=ny<m :
                if maps[nx][ny]=='L' and visit[nx][ny]==0:
                    q.append([nx, ny])
                    # 보물은 서로 간에 최단 거리로 이동하는데 있어 가장 긴 시간이 걸리는 육지 두 곳에 있음
                    visit[nx][ny] = visit[x][y] + 1
                    time=max(visit[nx][ny], time)

    return time-1


time=0

for i in range(n) :
    for j in range(m) :
        if(maps[i][j]=='L'):
            time=max(bfs(i, j), time)

print(time)

python은 시간초과가 발생해서 pypy로 제출해서 통과했다.

두번째 시도 보물은 이동하는데 있어서 가장 긴 시간이 걸리는 육지 두곳에 나뉘어 묻혀있다. 그렇기 때문에 maps[i][j]가 다른 두 육지 사이에 있는 경우는 가장 긴 시간이 걸리는 경우가 아니기 때문에 탐색을 할 필요가 없다. 이 부분을 추가해주니까 python으로 제출해도 통과를 했다.

import sys
from collections import deque
input=sys.stdin.readline

n, m=map(int, input().split())
maps=[list(map(str, input().strip())) for _ in range(n)]

dx=[0, 0, -1, 1]
dy=[-1, 1, 0, 0]

def bfs(a, b):
    q=deque()
    q.append([a, b])
    visit=[[0]*m for _ in range(n)]
    visit[a][b]=1
    time=0
    while q:
        x, y=q.popleft()
        for i in range(4):
            nx, ny=x+dx[i], y+dy[i]
            if 0<=nx<n and 0<=ny<m :
                if maps[nx][ny]=='L' and visit[nx][ny]==0:
                    q.append([nx, ny])
                    # 보물은 서로 간에 최단 거리로 이동하는데 있어 가장 긴 시간이 걸리는 육지 두 곳에 있음
                    visit[nx][ny] = visit[x][y] + 1
                    time=max(visit[nx][ny], time)

    return time-1


time=0

for i in range(n) :
    for j in range(m) :
        #다른 육지 사이에 있는 경우
        if i>0 and i+1<n :
            if maps[i-1][j]=='L'and maps[i+1][j]=='L':
                continue
        if j>0 and j+1<m :
            if maps[i][j-1]=='L' and maps[i][j+1]=='L':
                continue
        if(maps[i][j]=='L'):
            time=max(bfs(i, j), time)

print(time)

해결방법

프로젝트 폴더 우클릭 ➡️ [Mark Directory as] ➡️ [Sources Root] 를 클릭하면 해결이 된다.

N-Queen 문제는 크기가 N × N인 체스판 위에 퀸 N개를 서로 공격할 수 없게 놓는 문제이다. N이 주어졌을 때, 퀸을 놓는 방법의 수를 구하는 프로그램을 작성하시오.

입력 첫째 줄에 N이 주어진다. (1 ≤ N < 15)

출력 첫째 줄에 퀸 N개를 서로 공격할 수 없게 놓는 경우의 수를 출력한다.

예제 입력

8

예제 출력

92

풀이

백트레킹으로 푸는 문제이다. 첫번째 행에 퀸을 놓고 두번째 줄로 내려간다. 두번째 줄 가능한 자리에 놓고 세번째 자리로 내려간다. 그러다 안되는 경우가 발생하면 다시 두번째 줄로 올라가 그 다음 가능한 자리로 가서 확인을 한다.

퀸의 같은 경우 같은 행이나 열에 있으면 서로 공격이 가능하므로 1차원 배열을 사용해서 같은 행에 존재하는 경우를 배제한다.

boards[x]=y의 의미는 (x+1)행의 (y+1)열에 퀸이 존재한다는 의미이다.

구현

python pypy로 제출해야 통과한다.

n=int(input())
boards=[0]*n
ans=0
def check(x):
    for i in range(x) :
        if boards[x]==boards[i] :
            return False
        elif abs(boards[x]-boards[i])==abs : # 같은 열에 존재하는지 확인
            return False
    return True
def dfs(x):
    global ans
    if x==n :
        ans+=1
        return
    else :
        for i in range(n) :
            boards[x]=i
            if check(x)==True:
                dfs(x+1)

dfs(0)
print(ans)

java

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class BOJ_9663 {
    static int n;
    static int ans;
    static List<Integer> boards=new ArrayList<>();

    public static boolean check(int x){
        for(int i=0; i<x; i++){
            if(boards.get(x) == boards.get(i)){
                return false;
            }else if(Math.abs(boards.get(x) - boards.get(i))==x-i){
                return false;
            }
        }
        return true;
    }
    public static void dfs(int x){
        if(x==n){
            ans+=1;
            return;
        }
        for(int i=0; i<n; i++){
            boards.set(x, i);
            if(check(x)==true){
                dfs(x+1);
            }
        }
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        for(int i=0; i<n; i++){
            boards.add(0);
        }
        ans=0;
        dfs(0);
        System.out.println(ans);
    }
}

테스트를 먼저 만들고 테스트를 통과하기 위한 것을 짜는 것 즉, 만드는 과정에서 우선 테스트를 작성하고 그걸 통과하는 코드를 만들고를 반복하면서 제대로 동작하는지에 대한 피드백을 적극적으로 받는 것이다.

단위테스트 vs 통합테스트

단위 테스트(Unit Test)

하나의 모듈을 기준으로 독립적으로 진행되는 가장 작은 단위의 테스트이다. 여기서 모듈은 애플리케이션에서 작동하는 하나의 기능 또는 메소드이다.

통합 테스트(Integration Test)

모듈을 통합하는 과정에서 모듈 간의 호환성을 확인하기 위해 수행되는 테스트이다. 일반적으로 애플리케이션은 여러 개의 모듈들로 구성이 되고, 모듈들끼리 메시지를 주고 받으면서 기능을 수행한다.

단위 테스트 작성의 필요성

통합테스트는 실제 여러 컴포넌트들 간의 상호작용을 테스트하기 때문에 모든 컴포넌트들이 구동된 상태에서 테스트를 하게 된다. 그렇기 때문에 시스템을 구성하는 컴포넌트들이 많아질수록 테스트를 위한 비용(시간)이 상당히 커진다. 반면에 단위 테스트는 해당 부분만 독립적으로 테스트하기 때문에 어떤 코드를 리팩토링하여도 빠르게 문제 여부를 확인할 수 있다.

IntelliJ에서 Test 파일 만드는 방법

1. 클래스 이름 블럭 지정 후 마우스 오른쪽 버튼 또는 cmd+n
2. [Generate]-[Test…]

1. Test Annotation 사용

@Test 는 해당 메소드가 단위 테스트임을 명시하는 어노테이션이다. JUnit은 테스트 패키지 하위의 @Test 어노테이션이 붙은 메소드를 단위 테스트로 인식하여 실행시킨다. 이 상태로 실행하면 테스트 이름이 함수이름으로 default 되는데 @DisplayName 어노테이션을 사용하면 읽기 좋은 다른 이름을 부여할 수 있다.

@DisplayName("이름테스트")
@Test
void name() {
            ...
}

컬렉션(다수의 객체)를 다루기 위한 표준화된 프로그래밍 방식으로 컬렉션을 쉽고 편리하게 다룰 수 있는 다양한 클래스를 제공한다. 컬렉션 프레임워크에는 List, Set, Map 인터페이스가 있다.

Collection 인터페이스의 메서드

List

• 순서가 있는 데이터의 집합으로 데이터의 중복을 허용한다.
• 구현 클래스로는 ArrayList, LinkedList, Stack, Vector 등이 있다.

  List인터페이스 메서드

  메서드	설명
  void add(int index, Object element) boolean addAll(int index, Collection c)	지정된 위치에 객체 또는 컬렉션에 포함된 객체들을 추가
  Object get(int index)	지정된 위치에 있는 객체 반환
  int indexOf(Object o)	지정된 객체의 위치를 반환(첫번째 요소부터 순방향으로)
  int lastIndexOf(Object o)	지정된 객체의 위치를 반환(마지막요소부터 역방향으로
  Object remove(int index)	지정된 위치에 있는 객체를 삭제하고 삭제된 객체를 반환
  Object set(int index, Object element)	지정된 위치에 객체를 저장
  void sort(Comparator c)	지정된 비교자로 List 정렬
  List subList(int fromIndex, int toIndex)	지정된 범위에 있는 객체를 반환

ArrayList

저장순서가 유지되고 중복을 허용하며 데이터 저장공간으로 배열을 사용한다.

• 추가 : add와 addAll 메서드
• 삭제 : remove와 clear 메서드(clear는 전체 삭제)
• 검색
  • int indexOf(Object o), int lastIndexOf(Object o) : 존재하면 index 반환, 없으면 -1 반환(lastIndexOf는 제일 뒤부터 검색)
  • boolean contains(Object o) : 객체가 존재하면 true, 존재하지 않으면 false 반환
  • Object get(int index) : 특정 위치에 있는 객체 반환
  • Object set(int index, Object element) : 특정 위치에 있는 객체 변경
• ArrayList 생성*

  ArrayList<Integer> integers1 = new ArrayList<Integer>(); // 타입 지정
  ArrayList<Integer> integers2 = new ArrayList<>(); // 타입 생략 가능
  ArrayList<Integer> integers3 = new ArrayList<>(10); // 초기 용량 설정
  ArrayList<String> colors = new ArrayList<>(Arrays.asList("Blue", "Black", "White", "Red"));

• ArrayList element 추가/변경*

  ArrayList<String> colors = new ArrayList<>();
  

//추가 colors.add("Black"); colors.add("White"); colors.add(0, "Green"); //0번째에 Green 추가 colors.add("Red");

// 변경 colors.set(0, "Blue"); //0번째 Blue로 변경

System.out.println(colors);

[Blue, Black, White, Red]

**ArrayList elements 제거**
```java
ArrayList<String> colors = new ArrayList<>(Arrays.asList("Blue", "Black", "White", "Red"));
colors.remove(0); //0번째 인덱스 값 제거
System.out.println(colors);

colors.remove("Black");//Black 제거
System.out.println(colors);

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

[Black, White, Red]
[White, Red]

ArrayList elements 존재 유무

ArrayList<String> colors = new ArrayList<>(Arrays.asList("Black", "White", "Green", "Red", "Black"));

boolean contains = colors.contains("Black"); //존재하면 true, 존재하지 않으면 false
System.out.println(contains);

int index = colors.indexOf("Green"); //존재하는 인덱스 값 반환, 존재하지 않으면 -1
System.out.println(index);

index = colors.lastIndexOf("Black");//뒤에서부터 역방향으로 찾아보며 존재하는 인덱스 값 반환, 존재하지 않으면 -1
System.out.println(index);
index = colors.lastIndexOf("Blue");
System.out.println(index);

true
2
4
-1

Set

• 순서를 유지하지 않는 데이터의 집합으로 데이터의 중복을 허용하지 않는다. - 구현 클래스로는 HashSet, TreeSet 등이 있다.
• Set 인터페이스의 메서드는 Collection 인터페이스와 동일하다

  집합과 관련된 메서드

  Collection에 변화가 있으면 true, 아니면 false를 반환한다.

HashSet

Set 인터페이스를 구현한 대표적인 컬렉션 클래스이고 순서를 유지하려면 LinkedHashSet클래스를 사용하면 된다.

• 추가 : add, addAll(합집합)
• 삭제 : remove, removeAll(교집합), clear, retainAll(차집합)
• 포함 : contains, containsAll
• HashSet 생성*

  HashSet<String> colors1 = new HashSet<String>(); // 타입 지정
  HashSet<String> colors2 = new HashSet<>(); // 타입 생략 가능
  HashSet<String> colors3 = new HashSet<>(10); // 초기 용량 설정
  HashSet<String> colors4 = new HashSet<>(Arrays.asList("Blue", "Black", "White"));

• HashSet element 추가*

  HashSet<String> colors = new HashSet<>();
  colors.add("Black");
  colors.add("White");
  colors.add("Green");
  colors.add("Red");
  colors.add("White");
  

System.out.println(colors);

[Red, White, Black, Green]

중복되는 값은 제거 되기 때문에 White가 하나만 들어가 있는 것을 확인할 수 있다.
**HashSet element 삭제**
```java
HashSet<String> colors = new HashSet<>(Arrays.asList("Blue", "Black", "White", "Red", "Green"));

colors.remove("Red"); //[White, Blue, Black, Green]
color.removeAll(Arrays.asList("White", "Blue")); //[Black, Green]

HashSet element 전체 출력

HashSet<String> colors = new HashSet<>(Arrays.asList("Blue", "Black", "White", "Red", "Green"));

for (String color : colors) {
    System.out.print(color + "  ");
}
System.out.println();

//Iterator 이용
Iterator it = colors.iterator();
while(it.hasNext()) {
    System.out.print(it.next());
}

Red  White  Blue  Black  Green  
Red White Blue Black Green 

값 존재 유무

HashSet<String> colors = new HashSet<>(Arrays.asList("Blue", "Black", "White", "Red", "Green"));
System.out.println(colors.contains("Green")); // true
System.out.println(colors.contains("Yellow")); // false

Map

• 키(key)와 값(value)의 쌍으로 이루어진 데이터의 집합
• 순서는 유지되지 않으며, 키는 중복을 허용하지 않고, 값은 중복을 허용한다. - 구현클래스로는 HashMap, TreeMap, Hashtable, Properties 등이 있다.

  Map 인터페이스 메서드

HashMap

HashMap은 키와 값으로 구성된 Entry객체를 저장하는 구조를 가지고 있는 자료구조인 Map의 성질을 그대로 갖고 있다. 여기서 키와 값은 모두 객체이고, 값은 중복 저장될 수 있지만 키는 중복 저장될 수 없다. 만약 기존에 저장된 키와 동일한 키로 값을 저장하면 기존의 값은 없어지고 새로운 값으로 대치된다 HashMap 생성

HashMap<String,String> map1 = new HashMap<String,String>();//HashMap생성
HashMap<String,String> map2 = new HashMap<>();//new에서 타입 파라미터 생략가능
HashMap<String,String> map3 = new HashMap<>(map1);//map1의 모든 값을 가진 HashMap생성
HashMap<String,String> map4 = new HashMap<>(10);//초기 용량(capacity)지정
HashMap<String,String> map5 = new HashMap<>(10, 0.7f);//초기 capacity,load factor지정
HashMap<String,String> map6 = new HashMap<String,String>(){{//초기값 지정
    put("a","b");
}};

HashMap element 추가

HashMap<Integer,String> colors = new HashMap<>();//new에서 타입 파라미터 생략가능
colors.put(1,"Black"); //값 추가
colors.put(2,"Blue");
colors.put(3,"Green");

HashMap element 삭제

HashMap<Integer,String> colors = new HashMap<Integer,String>(){{//초기값 지정
    put(1,"Black");
    put(2,"Blue");
    put(3,"Green");
    put(4, "Red");
}};
map.remove(1); //key값 1 제거(Black 제거)
map.clear(); //모든 값 제거

HashMap element 출력

HashMap<Integer,String> colors = new HashMap<Integer,String>(){{//초기값 지정
            put(1,"Black");
            put(2,"Blue");
            put(3,"Green");
            put(4, "Red");
        }};

System.out.println(colors); //{1=Black, 2=Blue, 3=Green, 4=Red}
System.out.println(colors.get(3)); //Green

for(Map.Entry<Integer, String> entry : colors.entrySet()){
    System.out.println("key : "+entry.getKey()+" value : "+entry.getValue());
}
 /*결과 
key : 1 value : Black
key : 2 value : Blue
key : 3 value : Green
key : 4 value : Red
*/

HashMap iterator

HashMap<Integer,String> colors = new HashMap<Integer,String>(){{//초기값 지정
            put(1,"Black");
            put(2,"Blue");
            put(3,"Green");
            put(4, "Red");
}};

Iterator<Map.Entry<Integer, String>> entries = colors.entrySet().iterator();
while(entries.hasNext()){
    Map.Entry<Integer, String> entry = entries.next();
    System.out.println("[Key]:" + entry.getKey() + " [Value]:" +  entry.getValue());
}

//keySet().iterator()
Iterator<Integer> keys = colors.keySet().iterator();
while(keys.hasNext()){
    int key = keys.next();
    System.out.println("[Key]:" + key + " [Value]:" +  colors.get(key));
}
/* 둘다 결과 동일
[Key]:1 [Value]:Black
[Key]:2 [Value]:Blue
[Key]:3 [Value]:Green
[Key]:4 [Value]:Red
*/

JAVA에서는 Arrays.sort()를 이용하면 배열을 쉽게 정렬할 수 있다. sort()는 Comparable에 의해 리턴되는 값을 비교하여 오름차순 또는 내림차순으로 정렬한다.

1차원 배열

오름차순 정렬

int[] arr = {1, 10, 4, 17, 9, 25, 3};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));

[1, 3, 4, 9, 10, 17, 25]

내림차순 정렬

Integer[] arr = {1, 10, 4, 17, 9, 25, 3};
Arrays.sort(arr, Collections.reverseOrder());
System.out.println(Arrays.toString(arr));

//Comparator 구현
Integer[] arr2 = {1, 10, 4, 17, 9, 25, 3};
Arrays.sort(arr2, new Comparator<Integer>(){
    @Override
    public int compare(Integer i1, Integer i2) {
        return i2 - i1;
    }
});
System.out.println(Arrays.toString(arr2));

//lambda 이용
Integer[] arr3 = {1, 10, 4, 17, 9, 25, 3};
Arrays.sort(arr3, (i1, i2) -> i2 - i1);
System.out.println(Arrays.toString(arr3));

[25, 17, 10, 9, 4, 3, 1]

배열 부분 정렬

정렬할 범위인 처음 index와 마지막 index를 전달하여 해당 범위만 정렬할 수 있다.

int[] arr = {1, 10, 4, 17, 9, 25, 3};
Arrays.sort(arr, 0, 4);
System.out.println(Arrays.toString(arr));

[1, 4, 10, 17, 9, 25, 3]

String 길이로 정렬

String[] arr = {"Apple", "Kiwi", "Orange", "Banana", "Watermelon", "Cherry"};

Arrays.sort(arr, new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        return s1.length() - s2.length();
    }
});

System.out.println("Sorted arr[] : " + Arrays.toString(arr));

//lambda 이용
String[] arr2 = {"Apple", "Kiwi", "Orange", "Banana", "Watermelon", "Cherry"};

Arrays.sort(arr2, (s1, s2) -> s1.length() - s2.length());

System.out.println(Arrays.toString(arr2));

[Kiwi, Apple, Orange, Banana, Cherry, Watermelon]

2차원 배열

오름차순

int [][] arr = {{3,5}, {4,2}, {3,4}};
Arrays.sort(arr, new Comparator<int[]>() {
    @Override
    public int compare(int[] o1, int[] o2) {
        if(o1[0] == o2[0]) {
            return o1[1] - o2[1];
        }else {
            return o1[0] - o2[0]; 
        }
    }
});

3 5 
4 2 
5 4 

내림차순

int [][] arr = {{3,5}, {4,2}, {3,4}};
Arrays.sort(arr, new Comparator<int[]>() {
    @Override
    public int compare(int[] o1, int[] o2) {
        if(o1[0] == o2[0]) {
            return o2[1] - o1[1];
        }else {
            return o2[0] - o1[0]; 
        }
    }
});

5 4 
4 2 
3 5 

Generics

컴파일시 타입을 체크해주는 기능으로 객체의 타입 안정성을 높이고, 형변환의 번거로움을 줄여준다.

//Tv 객체만 저장할 수 있는 ArrayList 생성
ArrayList<Tv> tvList = new ArrayList<Tv>();

tvList.add(new Tv());
tvList.add(new Audio()); //컴파일 에러

위의 예제와 같이 지정된 객체 외 다른 객체가 들어오면 컴파일러가 막아준다. 런타임에러(실행 시 발생하는 에러)를 컴파일 에러로 변경해 사전에 예방할 수 있다.

ArrayList tvList = new ArrayList();
tvList.add(new Tv());
Tv t = (Tv)tvList.get(0); //get()의 반환 타입이 Object이기 때문에 형변환 필요

ArrayList<Tv> tvList = new ArrayList<Tv>();
tvList.add(new Tv());
Tv t = tvList.get(0); //형변환 불필요

지네릭스를 사용하지 않은 경우 get()의 반환 타입은 Object이기 t의 타입은 Tv이기 때문에 형변환이 빌표한 반면, 지네릭스를 사용하는 경우는 반환타입도 Tv이기 때문에 형변환이 필요없다.

지네릭스의 장점

• 타입의 안정성을 제공한다.
• 타입체크의 형변환을 생략할 수 있으므로 코드가 간결해 진다.

지네릭스 용어

Box<T> : 지네릭 클래스, 'T의 Box' 또는 'T Box'라고 읽는다. T : 타입 변수 또는 타입 매개변수(T는 타입문자) Box : 원시 타입

class Box<T> { }

타입변수

Generics 클래스를 작성할 때, Object 타입 대신 타입 변수(E)를 선언해서 사용한다.

public class ArrayList<E> extends AbstractList<E> {
    private transient E[] elementData;
    public boolean add(E o) { ... }
    public E get(int index) { ... }
    ...
}

객체를 생성할 때, 타입 변수(E) 대신 실제 타입을 지정(대입)하면 된다.

ArrayList<Tv> tvList = new ArrayList<Tv>();

지네릭스 다형성

참조 변수와 생성자의 대입된 타입은 일치해야 한다.

class Product { }
class Tv extends Product { }

ArrayList<Product> list = new ArrayList<Tv>(); //에러

위와 같이 Product 클래스가 Tv 클래스의 조상 클래스여도 에러가 발생한다. 참조 변수와 생성자의 대입된 타입은 일치해야한다. 단, 지네릭 클래스간의 다형성은 성립한다.

List<Tv> list = new ArrayList<Tv>();

매개변수의 다형성도 성립한다.

ArrayList<Product> list = new ArrayList<Product>();
list.add(new Product());
list.add(new Tv()); //Ok

위와 같이 매개변수의 경우 Product의 자손들이 와도 성립한다.

제네릭 클래스

Iterator <E>

클래스를 작성할 때, Object 타입 대신 T와 같은 타입 변수 사용

//지네릭스 사용 전
public interface Iterator {
    boolean hasNext();
    Object next();
    void remove();
}
//지네릭스 사용 후 
public interface Iterator<E> {
    boolean hasNext();
    E next();
    void remove();
}

//지네릭스 사용 전
Iterator it = list.iterator();
while(it.hasNext()) {
    Student s = (Student)it.next();
    ...
}
//지네릭스 사용 후
Iterator<Student> it = list.iterator();
while(it.hasNext()) {
    Student s = it.next();
    ...
}

Oject 타입이 E로 바뀌었기 때문에 형변환을 해주지 않아도 된다.

HashMap<K, V>

여러 개의 타입 변수가 필요한 경우, 콤마(,)로 구분자 선언

public class HashMap<K, V> extends AbstractMap<K, V> {
    ...
    public V get(Object key) { ... }
    public V put(K key, V value) { ... }
    public V remove(Object key) { ... }
    ...
}

• 예시

  HashMap<String, Student> map = new HashMap<String, Student>(); //생성
  map.put("자바", new Student("자바", 1, 1, 100, 100, 100)); //데이터 저장

  public class HashMap extends AbstractMap {
    ...
    public Student get(Object key) { ... }
    public Student put(String key, Student value) { ... }
    public Student remove(Object key) { ... }
       ...
  }

제한된 지네릭 클래스

extends로 대입할 수 있는 타입을 제한한다(인터페이스인 경우에도 extends를 사용한다)

class FruitBox<T extends Fruit> {
    ArrayList<T> list = new ArrayList<T>();
}

위의 예제는 Fruit의 자손만 T의 타입으로 지정가능하게 제한 것과 같다.

지네릭스의 제약

• 타입 변수에 대입은 인스턴스 별로 다르게 가능하다. 그러므로 static 멤버(모든 인스턴스에 공통)에는 타입 변수를 사용할 수 없다.

  class Box<T> {
    static T item; //error
    static int compare(T t1, T t2) { ... } //error
  }

• 타입 변수로 배열 선언은 가능하지만 배열 생성할 때 타입 변수를 사용할 수 없다. new 연산자는 뒤에 타입이 확정되어 있어야하는데 T는 어떤 타입이 올지 모르기 때문에 에러가 발생한다.

  class Box<T> {
    T[] itemArr; // 선언할 때 ok
    T[] temArr = new T[10]; //생성할 때 error
  }

와일드 카드< ? >

하나의 참조 변수로 대입된 타입이 다른 객체를 참조 가능하다.

ArrayList<? extends Product> list = new ArrayList<Tv>();
ARrayList<? extends Product> list = new ArrayList<Audio>();

종류

< ? extends T > : 와일드 카드의 상한 제한. T와 그 자손들만 가능 < ? super T > : 와일드 카드의 하한 제한. T와 그 조상들만 가능 < ? > : 제한 없음. 모든 타입이 가능 < ? extends Object >와 동일

• 메서드의 매개변수에도 와일드 카드를 사용할 수 있다.

  static Juice makeJuice(FruitBox<? extends Fruit> box) {
    String tmp = "";
    for(Fruit f : box.getList()) tmp += f + " ";
    return new Juice(tmp);
  }

  System.out.println(Juicer.makeJuice(new FruitBox<Apple>()));

  지네릭 메서드

  지네릭 타입이 선언된 메서드(타입 변수는 메서드 내에서만 유효)이다. 이때 클래스 타입 매개변수 <T>와 메서드의 타입 매개변수 <T>는 별개이다. 지네릭 메서드 내에서는 지네릭 메서드의 타입 변수가 우선이 된다.

  static <T> void sort(List<T> list, Comparator<? super T> c)

  메서드를 호출하라 때마다 타입을 대입해야하지만 대부분 생략 가능하다. 메서드를 호출할 때 타입을 생략하지 않을 때는 클래스 이름 생략이 불가능하다.

  static <T extends Fruit> Juice makeJuice(FruitBox<T> box) {
    ...
  }

  System.out.println(Juicer.<Fruit>makeJuice(fruitBox));
  System.out.println(Juicer.<Apple>makeJuice(appleBox));
  System.out.println(<Fruit>makeJuice(fruitBox)); //error

수학관련 static 메서드들의 집합이다.

Math클래스의 메서드

round() 예제

double d = 90.7552
double d2 = Math.round(d*100)/100.0; //소수점 셋째자리에서 반올림

// d=90.7552
// d2=90.76

Wrapper 클래스

8개의 기본형(객체 X)을 객체로 다뤄야할 때 사용하는 클래스이다.

[Chapter 10] Calendar 클래스

Calendar 클래스

추상클래스이므로 객체를 생성할 수 없고 getInstance()를 통해 구현된 객체를 얻어야한다.

Calendar cal = Calendar.getInstance();

Calendar cal = Calendar.getInstance(); //현재 날짜와 시간으로 생성
int thisYear = cal.get(Calendar.YEAR); //올해가 몇년인지
int lastDayOfMonth = cal.getActualMaximum(Calendar.DATE); //이 달의 마지막날

Calendar에 정의된 필드

Object 클래스는 모든 클래스의 최고 조상으로 오직 11개의 메서드만 가지고 있다. 11개의 메서드 중 wait(), notify() 등은 쓰레드 관련 메서드이다.

equals(Object obj)

객체 자신(this)과 주어진 객체(obj)를 비교해서 같으면 true, 다르면 false를 반환한다. Object 클래스의 equals()는 객체의 주소를 비교(참조변수 값 비교)하기 때문에 주소가 같아야 true가 반환된다.

class Value {
    int value;

    Value(int value) {
        this.value = value;
    }
}
class EqualsTest {
    public static void main(String[] args) {
        Value v1 = new Value(10);
        Value v2 = new Value(10);

        System.out.println(v1.equals(v2));
    }
}

위의 예제를 실행시켜보면 서로 다른 두 객체는 항상 주소가 다르기때문에 false가 출력된다. 인스턴스 변수의 값들을 비교하고 싶다면 equals 메서드를 오바라이딩 해야한다.

equals(Ojbect obj)의 오버라이딩

class Value {
    private int value;

    Value(int value) {
        this.value = value;
    }

    void int getValue(){
        return value;
    }

    @Override
    public boolean equals(Object obj) {
        if(obj instanceof Value) {
            Value v = (Value)obj;
              if(this.value==obj.getValue()){
                retrun true;
            }
        }
        return false;
    }
}

위와 같이 해주면 인스턴스 변수의 값을 비교할 수 있다. 이때 형변환을 하는 이유는 obj는 Object 타입이므로 Value 타입 변환해야하기 때문이다.

💡 주의 형변환을 하기 전에 instanceof 연산자로 형변환이 가능한지 확인을 해주어야한다.

toString()

객체를 문자열(String)으로 변환하기 위한 메서드이다.

public String toString() {
    return getClass().getName()+"@"+Integer.toHexString(hashCode());
}

클래스이름과 주소를 반환하는 함수이다.

toString()의 오버라이딩

public String toString() {
    return "kind : " + kind + ", number: " + number;
}

원래는 클래스이름과 주소를 반환하는 함수를 오버라이딩을 통해 인스턴스 변수를 출력하도록 오버라이딩할 수 있다.

String strl = new String("abc"); 
String str2 = new String("abc"); 
System.out.println(strl.equals(str2)); // true 
System.out.println(strl.hashCode()); // 96354 
System.out.println(str2.hashCode()); // 96354

hashCode()

객체의 해시코드를 반환하는 메서드로 객체의 주소를 int로 변환해서 반환한다. equals()의 결과가 true인 두 객체의 해시코드는 같아야하기 때문에 equals()를 오버라이딩하면, hashCode()도 오버라이딩해야한다.

String strl = new String("abc"); 
String str2 = new String("abc"); 
System.out.println(strl.equals(str2)); // true 
System.out.println(strl.hashCode()); // 96354 
System.out.println(str2.hashCode()); // 96354

String클래스

String클래스의 특징

• 문자형 배열(char[])과 그에 관련된 메서드가 정의되어 있다.

문자형 배열, 관련메서드가 정의된 부분

public final class String implements java.io.Serializable. comparable{
    /** The value is used for character storage. */
    private char[] value;
    ...

• String인스턴스의 내용은 변경이 불가능하다.

String인스턴스 내용변경 불가능 예시

String a = "a";
String b = "b";
String a = a + b;

String a에 “a”를 저장 후, String a에 다시 a+b를 저장할 시 기존의 “a”값은

변경되지 않고 그대로 메모리에 남아있게 된다.

String형 변수에 “abc”와 new String(”abc”)의 차이

String str1 = "abc";
String str2 = "abc";
String str3 = new String("abc");
String str4 = new String("abc");

System.out.println(str1==str2);//true
System.out.println(str3==str4);//false
System.out.println(str1.equals(str2));//true
System.out.println(str3.equals(str4));//true

str1와 str2는 “abc”가 저장된 하나의 메모리주소를 공유한다

str3와 str4는 각각의 객체를 생성하여 “abc”가 저장된 서로 다른

메모리주소를 가진다.

빈 문자열(””, empty string)

내용이 없는 문자열, 크키가 0인 char형 배열을 저장하는 문자열이다.

크기가 0인 배열을 생성하는 것은 어느 타입이나 가능하다

크기가 0인 배열 생성 예시

char[] cArr = new char[0]; // 크기가 0인 char배열
int[] iArr = (); // 크기가 0인 int배열

String str = “”;는 가능하나 char c = “”;는 불가능하다.

String은 참조형의 기본값인 null보다 빈 문자열로 초기화하고 char형은 기본값인 \u0000보다는 공백으로 초기화는 게 좋다.

String과 char형의 기본값 예시

String s = null;
char c = '\u0000';

String과 char형의 공백초기화 예시

String s = ""; // 빈 문자열로 초기화
char c = ' '; // 공백으로 초기화

String클래스의 생성자, 메서드

String클래스에는 많은 생성자와 메서드가 존재한다.

문자열과 기본형간의 변환

• 기본형 값을 문자열로 변환하는 방법은 두 가지가 있다.

기본형 값의 문자열 변환방법 예시

int i = 100;
String str1 = i + ""; // 100을  "100"으로, 변환 방법1
String str2 = String.valueOf(i); // 100을 "100"으로, 변환 방법2

문자열 값의 기본형 변환방법 예시

int i = Integer.parseInt("100"); // "100"을 100으로, 변환 방법1
int i2 = Integer.valueOf("100"); // "100"을 100으로, 변환 방법2
char c = "A".charAt(0); // 문자열 "A"를 문자 'A'로, 변환

기본형과 문자열 간 변환함수

프로그램 오류

• 컴파일 에러 : 컴파일 할 때 발생하는 에러
• 런타임 에러 : 실행할 때 발생하는 에러
• 논리적 에러 : 작성 의도와 다르게 동작

  Java의 런타임 에러

• 에러(error) : 프로그램 코드에 의해서 수습될 수 없는 심각한 오류
• 예외(exception) : 프로그램 코드에 의해서 수습될 수 있는 다소 미약한 오류 ➡️ 에러는 어쩔 수 없지만, 예외는 처리하자.

예외처리

예외처리는 프로그램 실행 시 발생할 수 있는 예외의 발생에 대비한 코드를 작성하는 것으로 프로그램의 비정상 종료를 막고, 정상적인 실행상태를 유지하기 위해 예외처리가 필요하다.

Exception과 RuntimeException

• Exception 클래스 : 사용자의 실수와 같은 외적인 요인에 의해 발생하는 예외 IOException(입출력 예외), ClassNotFoundException(클래스가 존재하지 않을 때) ...
• RuntimeException 클래스 : 프로그래머의 실수로 발생하는 예외 ArithmeticException(산술계산 예외), ClassCastException(형변환 예외), NullPointerException(널 포인터), IndexOutOfBoundsException(배열 범위 벗어남) ...

  예외 처리하기(try-catch 문)

  try{
    //예외가 발생할 가능성이 있는 문장
  }catch(Exception1 e1){
    //Exception1이 발생했을 경우, 이를 처리하기 위한 문장
  }catch(Exception2 e2){
    //Exception2가 발생했을 경우 이를 처리하기 위한 문장
  }finally{
    //예외 발생여부에 관계없이 항상 수행되어야하는 문장
    //try-catch문의 맨 마지막에 위치
  }

• try블럭 내에서 예외가 발생한 경우, 발생한 예외와 일치하는 catch 블럭이 있는지 확인한다. 일치하는 catch블럭을 찾게 되면, 그 catch 블럭 내의 문장들을 수행하고 전체 try-catch문을 빠져나가서 그 다음 문장을 계속해서 수행한다. 일치하는 catch블럭을 찾지 못하면 예외 처리가 되지 않는다.
• try블럭 내에서 예외가 발생하지 않은 경우는 catch블럭을 거치지 않고 전체 try-catch문을 빠져나가서 수행된다.
• finally 블럭 : 예외 발생여부와 관계없이 수행되는 블럭으로 try 블럭 안에 return 문이 있어서 try 블럭을 벗어날 때도 finally 블럭이 실행된다.

💡 Exception e 모든 예외의 최고조상이기 때문에 모든 예외를 처리할 수 있다. 그렇기 때문에 Exception e가 선언된 catch 블럭은 제일 마지막에 와야한다. (위에 있으면 아래 예외블럭을 처리하지 못한다)

Exception 에러 출력

try 블럭에서 예외가 발생하면 예외 객체가 생성된다. 이 객체에 발생한 예외에 대한 정보가 들어있고 printStackTrace(), getMessage() 등의 메서드를 갖는다.

• printStackTrace() : 예외발생 당시의 호출스택에 있었던 메서드의 정보와 예외 메시지를 화면에 출력한다.
• getMessage() : 발생한 예외클래스의 인스턴스에 저장된 메시지를 얻을 수 있다.

예외 발생시키기

연산자 new를 이용해서 발생시키려는 예외 클래스의 객체를 만든 다음 키워드 throw를 이용해서 예외를 발생시키면 된다.

public static void main(String args[]) {
    try {
        Exception e = new Exception("에러 발생");
        throw e;
    } catch (Exception e) {
        System.out.println("에러 메시지 : " + e.getMessage());
        e.printStackTrace();
    }
}

checked예외와 unchecked 예외

• checked예외 : 컴파일러가 예외 처리 여부를 체크(예외 처리 필수) Exception과 그 자손들

  public static void main(String[] args) {
      throw new Exception();
  }

  try-catch문을 이용해 예외처리를 해주어야하는데 하지 않았기 때문에 컴파일 오류가 발생한다. 즉, Exception 예외는 예외 처리를 필수로 해야하기 때문에 checked 예외라는 의미이다.
• unchecked예외 : 컴파일러가 예외 처리 여부를 체크 안함(예외 처리 선택) RuntimeException과 그 자손들

  public static void main(String [] args) {
      throw new RuntimeException();
  }

  RuntimeExcepton은 unchecked 예외이기 때문에 예외 처리가 선택적이므로 try-catch문이 없어도 컴파일 에러가 발생하지 않고 예외가 발생했다는 결과가 출력된다.

throws

예외 선언하기는 throws키워드를 사용하고 메서드가 호출 시 발생가능한 예외를 호출하는 쪽에 알리는 것이다.

void method() throws Exception1, Exception2, ... ExceptionN }
    //메서드의 내용
}
void method() throws Exception {
    //메서드의 내용
}

💡 main 함수에 throws 를 사용한 경우 main함수에서 예외처리가 발생하면 try-catch문 없어서 비정상종된다. 그리고 JVM에게 예외를 맡기게 된다.

사용자 정의 예외 만들기

직접 예외 클래스를 정의할 수 있다. 조상은 Exception과 RuntimeException 중에서 선택하고 생성자를 작성해주어야한다.

class MyException extends Exception{
    MyException(String msg) { //문자열을 매개변수로 받는 생성자
        super(msg); //조상인 Exception클래스의 생성자를 호출
    }
}

💡 Exception은 필수 처리 예외이기 때문에 반드시 try-catch문을 써야하고 RuntimeException은 선택 처리 예외이기 때문에 try-catch문을 사용하지 않아도 된다. 그렇기 때문에 가능하면 선택처리가 가능한 RuntimeException을 사용하는게 좋다.

예외 되던지기

예외 되던지기는 예외를 처리한 후에 다시 예외를 발생시키는 것을 의미한다. 즉, 호출한 메서드와 호출된 메서드 양쪽 모두에서 예외를 처리하게 된다.

public static void main(String[] args) {
    try {
        method1();
    } catch (Exception e) {
        System.out.println("main 메서드에서 예외가 처리되었습니다.");
    }
}
static void method1() throws Exception {
    try {
        throw new Exception();
    } catch (Exception e) {
        System.out.println("method1메서드에서 예외가 처리되었습니다.);
        throw e; //다시 예외를 발생시킨다.
    }
}
/*결과
method1메서드에서 예외가 처리되었니다.
main 메서드에서 예외가 처리되었습니다.
*/

method1()에서 try-catch문으로 예외를 처리하고 난 다음에 throw e를 통해 다시 예외를 발생시킨다. 그렇게 되면 method1()을 호출한 main함수로 예외가 전달된다. 이렇게 호출한 메서드와 호출된 메서드 양쪽에서 모두 예외 처리하게 된다.

[출처] 자바의 정석 - https://www.youtube.com/playlist?list=PLW2UjW795-f6xWA2_MUhEVgPauhGl3xIp