항상 만들기 실패했었는데, 이번에 성공했다. 글도 다 옮겼고.. 이제 포스팅을 더 열심히 해야지!

한 달차의 목표를 실천했는가?

지난 달에 1달차 회고록을 썼었다. 그때의 목표에서 필요한 부분에 맞게 수정해서 실천하고 있다

• 당일 복습
• 연습 문제 미리 풀기
• 개발 관련 서적 읽기 (동기부여를 위해)
• 백준 하루 3문제 매일 풀기 -> 개수 상관없이 백준 매일 풀기
• 주 3회 이상 자전거 타기

당일 복습과 연습문제 미리 풀기보다는 백준 문제를 더 풀면서 매일 다른 문제르 적용하는 게 더 중요하다고 판단했다. 그래서 이 부분은 목표에서 제외했다.

그리고 자전거 타기는......한동안 주 2~3회는 꼬박 꼬박 나갔는데.. 요즘엔 좀 귀찮아졌다.. 운동을 소홀히 하지 말아야지...

처음 자바를 배웠을 때는 많이 막막하고 무슨 말인지도 몰라 낯설어 힘들었던 기억이 난다.

그래서 스터디도 하고 개인적으로도 매일 백준 문제를 풀면서 자바에 익숙해지도록 노력했다.

역시 자주 쓰다보니 한결 수월해졌고 지금은 자바라는 언어가 이해가 안 가서 스트레스 받는 일은 없어졌다.

역시 새로운 것을 배울 때는 많이 접해야 된다.

새로운 목표

저번달에는 자바와 친해지는 것에 중점을 뒀었다. 이제부터는 본격적으로 스프링을 시작한다.

스프링을 처음 봤을 때 당연히 막막함이 들었지만, 자바를 공부했던 것처럼 계속해서 사용하다보면 괜찮아지리라 믿는다.

스프링 스터디에서 교재 9월까지 끝내기

김영한 기초 강의 듣고 뉴렉쳐 강의 듣기

백준 하루에 최소 한 문제는 풀기

1일 1커밋

개발 관련 서적 하루에 30페이지 읽기

운동...하기..

문제

영어 대소문자와 공백으로 이루어진 문자열이 주어진다. 이 문자열에는 몇 개의 단어가 있을까? 이를 구하는 프로그램을 작성하시오. 단, 한 단어가 여러 번 등장하면 등장한 횟수만큼 모두 세어야 한다.

입력

첫 줄에 영어 대소문자와 공백으로 이루어진 문자열이 주어진다. 이 문자열의 길이는 1,000,000을 넘지 않는다. 단어는 공백 한 개로 구분되며, 공백이 연속해서 나오는 경우는 없다. 또한 문자열은 공백으로 시작하거나 끝날 수 있다.

출력

첫째 줄에 단어의 개수를 출력한다.

예제

입력: The Curious Case of Benjamin Button      출력: 6

### 처음 설계
>
1. BR을 사용해 문자 입력을 받는다
2. split를 사용해 공백을 기준으로 str을 자른다
3. count에 str의 길이를 담는다
4. count을 출력한다

### 문제점
>
split를 사용하면 문자열의 처음과 마지막에 공백이 있다면 그것 또한 문자열에 포함시킨다.
그래서 StringTokenizer를 사용하여 자르는 방법을 바꿨다.

### StringTokenizer를 사용하는 방법
>
공백을 기준으로 지정하면 나누어진 문자열을 토큰에 저장해준다.
문자열의 처음과 마지막에 예외처리를 해줄 필요가 없다.

### 구현
```java
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        String str = br.readLine();
        br.close();

        StringTokenizer st = new StringTokenizer(str," ");

        int count = st.countTokens();

        System.out.print(count);
    }
}

AOP

AOP가 필요한 이유?

Aspect는 여러 유형과 객체 간에 발생하는 문제 (ex - 트랜잭션)의 모듈화를 가능하게 함!

AOP 용어

애스팩트(Aspect)

어드바이스 + 포인트컷을 모듈화하여 애플리케이션에 포함되는 횡단 기능

조인 포인트(join point)

클래스 초기화, 객체 인스턴스화, 메소드 호출, 필드 접근, 예외 발생과 같은 애플리케이션 실행 흐름에서의 특정 포인트를 의미

어드바이스(Advice)

조인포인트에서 수행되는 코드

포인트컷(Pointcut)

조인 포인트 중에서 어드바이스가 적용될 위치를 선별하는 기능

위빙(Weaving)

포인트컷으로 결정한 타겟의 조인 포인트에 어드바이스를 적용하는 것

AOP 프록시(proxy)

AOP 기능을 구현하기 위해 만든 프록시 객체

타겟 (Target)

핵심 기능을 담고 있는 모듈로 타겟은 부가기능을 부여할 대상이 됨

어드바이저(Advisor)

하나의 어드바이스와 하나의 포인트 컷으로 구성

타입별 Advice

어드바이스(Advice)?

Aspect를 언제 핵심 코드에 적용할지를 정의

Advice 순서

어드바이스는 기본적으로 순서를 보장하지 않음

순서를 지정하고 싶으면 @Aspect 적용 단위로 org.springframework.core.annotation.@Order 애너테이션을 적용

Advice 종류

Before

조인 포인트 실행 이전에 실행

After returning

조인 포인트가 정상 완료 후 실행

After throwing

메서드가 예외를 던지는 경우에 실행

After (finally)

조인 포인트의 동작(정상 또는 예외)과는 상관없이 실행

Around

메서드 실행 전 & 후, 예외 발생 시점에 공통 기능을 실행

문자열에서 숫자를 모두 찾아 더한 뒤에 해당 값을 문자열의 길이로 나눈 값을 반올림하여 리턴

설계

1. 변수 선언 (숫자를 찾아낼 String digit, 총합을 구할 double sum, 숫자를 뺀 문자열 pure str)
2. for문을 사용하여 문자열 순회 2-1. if (str에 숫자가 있다면)

        str을 int로 바꾸고 sum에 더해줌

   2-2 else if (str이 공백이 아니라면)

            pure_str에 해당 문자열을 더해줌

3. result에 총합 나누기 문자열의 길이를 넣음
4. math.round를 사용해서 반올림을 해준다

구현

public class Main {
    public static void main(String[] args) {
        System.out.print(numberSearch("Hello6 9World 2,"));
    }
    public static int numberSearch(String str) {
        if (str.length() == 0) return 0;

        String digit = "0123456789";
        double sum = 0;
        String pure_str = "";

        for(int i = 0; i < str.length(); i++) {
            if (digit.indexOf(str.charAt(i)) != -1) {
                sum = sum + Character.getNumericValue(str.charAt(i));
            }
            else if (str.charAt(i) != ' ') {
                pure_str = pure_str + str.charAt(i);
            }
        }
        double result = sum / pure_str.length();
        return (int) Math.round((result * 10) /10);
    }
}

사용 메서드

• indefxOf(): 값이 존재하면 해당 인덱스를 리턴, 값이 없다면 -1을 리턴
• str -> char -> int: Character.getNumericValue(str.charAt(i))
• Math.round((result * 10) /10): 소수점 첫번째 자리에서 반올림 해줌. 두번째 자리에서 하려면 10을 100으로 바꿔주면 됨

문제

0보다 크거나 같고, 99보다 작거나 같은 정수가 주어질 때 다음과 같은 연산을 할 수 있다. 먼저 주어진 수가 10보다 작다면 앞에 0을 붙여 두 자리 수로 만들고, 각 자리의 숫자를 더한다. 그 다음, 주어진 수의 가장 오른쪽 자리 수와 앞에서 구한 합의 가장 오른쪽 자리 수를 이어 붙이면 새로운 수를 만들 수 있다. N이 주어졌을 때, N의 사이클의 길이를 구하는 프로그램을 작성하시오.

예시 26부터 시작한다. 2+6 = 8이다. 새로운 수는 68이다. 6+8 = 14이다. 새로운 수는 84이다. 8+4 = 12이다. 새로운 수는 42이다. 4+2 = 6이다. 새로운 수는 26이다. 위의 예는 4번만에 원래 수로 돌아올 수 있다. 따라서 26의 사이클의 길이는 4이다.

입력: 첫째 줄에 N이 주어진다. N은 0보다 크거나 같고, 99보다 작거나 같은 정수이다. 출력: 첫째 줄에 N의 사이클 길이를 출력한다.

문제 이해

숫자 n을 입력받고 n의 왼쪽과 오른쪽을 더한 숫자와 원래 n의 오른쪽 숫자를 이어준다 반복해서 이어주다가 원래의 숫자 n이 나오면 반복한 회수를 출력한다

처음 설계

1. x와 y를 아래와 같이 n의 왼쪽과 오른쪽으로 선언했다.
    int x = n / 10;
    int y = n % 10;
2. 그리고 수정된 알고리즘과 식은 똑같지만 x,y로 표현만 바꾼 식을 실행시켰다
        do {
             n = (10 * y) + ((x + y) % 10);
             count++;
        } while (result != n);
3. 이와 같이 x와 y로 반복문을 돌리면 결과값이 나오지 않고 백준에서는 시간초과로 나온다

문제해결

간단하게 x와 y를 n으로 풀어서 알고리즘을 수정했다.

최종 설계

1. BR을 사용해서 숫자 n을 입력받는다
2. do {
       더하기 사이클을 한 번 돈다
       count를 1씩 증가시킨다
       } while (result와 n의 값이 다를때까지)
3. count값 출력

구현

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        br.close();

        int result = n;
        int count = 0;

        do {
            n = ((n % 10) * 10) + (((n / 10) + (n % 10)) % 10);
            count++;
        } while (result != n);

        System.out.print(count);
    }
}

스프링의 핵심개념 중 하나인 DI를 공부한다!

DI

스프링 컨테이너

스프링 컨테이너는 스프링 프레임워크의 핵심 컴포넌트

스프링 컨테이너?

Bean 생성, 관리, 제거 등의 역할을 담당

컨테이너를 사용하는 이유?

객체간의 의존성을 낮추기 위해서

-> 구현 클래스에 있는 의존을 제거하고 인터페이스에만 의존하도록 설계

Spring Container 생성

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);

>### ApplicationContext 인터페이스 구현체 확인법
##### Windows에서 Ctrn + N → 클래스에서 ApplicationContext로 검색

### 컨테이너의 종류

>### BeanFactory
##### 스프링 컨테이너의 최상위 인터페이스
##### 빈을 등록, 생성, 조회, 돌려줌 -> 빈을 관리하는 역할
```java
- getBean(): 빈을 인스턴스화
- @Bean: 스프링 빈의 이름으로 사용해 빈 등록

>### ApplicationContext
##### BeanFactory의 기능을 상속받아 제공
```java
- MessageSource: 메세지 다국화를 위한 인터페이스
- EnvironmentCapable: 개발, 운영 등 환경변수 등으로 나눠 처리
애플리케이션 구동 시 필요한 정보들을 관리하기 위한 인터페이스
- ApplicationEventPublisher: 이벤트 관련 기능을 제공하는 인터페이스
- ResourceLoader: 파일, 클래스 패스, 외부 등 리소스를 편리하게 조회

>### 컨테이너 인스턴스화
##### 다양한 외부 리소스로부터 구성 메타데이터를 로드할 수 있도록 하는 리소스 문자열
```java
- Annotation
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
- XML
ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml");

빈

스프링 컨테이너에 의해 관리되는 재사용 소프트웨어 컴포넌트

빈?

빈(bean)은 인스턴스화된 객체

@Bean이 적힌 메서드를 모두 호출해서 반환된 객체를 스프링 컨테이너에 등록

빈 접근방법

- create and configure beans
ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml");
- retrieve configured instance
PetStoreService service = context.getBean("cmarket", cmarketService.class);
- use configured instance
List<String> userList = service.getUsernameList();

BeanDefinition (빈 설정 메타정보)

속성에 따라 컨테이너가 Bean을 어떻게 생성하고 관리할지 결정

@Bean or <bean> 당 각 1개씩 메타 정보가 생성

빈 스코프

레시피

bean definition에 의해 정의된 클래스의 실제 인스턴스를 만들기 위한 레시피를 만듦

-> 빈이 존재할 수 있는 범위를 의미

싱글톤(singleton) 스코프

클래스의 인스턴스가 딱 1개만 생성되는 것을 보장하는디자인 패턴

컨테이너의 시작과 함께 생성되어 컨테이너가 종료될 때 까지 유지
컨테이너 종료시 소멸 메서드도 자동으로 실행

> ### 싱글톤 패턴의 문제점
```java
- 구현하는 코드가 많음
- 클라이언트가 구체 클래스에 의존
- 유연성이 떨어짐

>### 싱글톤 컨테이너로 문제 해결!
```java
- 스프링 컨테이너는 싱글톤 컨테이너 역할을 함
- 싱글톤 레지스트리: 싱글톤 객체로 생성하고 관리

>### 싱글톤 방식의 주의점
##### -> 여러 클라이언트가 하나의 객체 인스턴스를 공유하기 때문에 싱글톤 객체는 무상태로 설계
```java
- 특정 클라이언트가 값을 변경할 수 있으면 안됨
- 읽기만 가능해야 됨
- 스프링 빈의 공유 값을 설정하면 장애가 발생할 수 밖에 없음

## Java 기반 컨테이너(Container) 설정
>@Configuration와 @Bean이 가장 중요한 애너테이션
>>Spring 컨테이너에서 관리할 새 객체를 인스턴스화, 구성 및 초기화한다는 것을 표기할 때 사용

### @Bean 애너테이션을 사용하기
> 메서드-레벨 애너테이션이며, <bean />에서 제공하는 일부 속성을 지원

빈 선언 @Bean 애너테이션을 메서드에 추가해서 Bean으로 정의(선언) 빈의존성 @Bean 애너테이션이 추가된(@Bean-annotated) 메서드 -> 빈을 구축하는데 필요한 의존성을 나타내는데 매개 변수를 사용가능

### @Configuration 애너테이션을 사용하기
>해당 객체가 bean definitions의 소스임을 나타내는 애너테이션


## Component 스캔
>설정 정보 없이 자동으로 스프링 빈을 등록

문제

문자열을 입력받아 아이소그램인지 여부를 리턴해야 합니다. 아이소그램(isogram)은 각 알파벳을 한번씩만 이용해서 만든 단어나 문구를 말합니다.

원래 하려고 했던 방법 1

str = str.toLowerCase();

String[] new_str = new String[str.length()];

for (int i = 0; i < str.length(); i++) {
    new_str [i] = str.toLowerCase();
    for (int j = i + 1; j < str.length(); j++) {
        if (new_str [i] == new_str[j]) {
            return false;
        }
    }
} return true;

문제점

charAt를 사용해 변환해주는 대신 new_str이라는 새로운 배열을 선언했다 str배열 자체를 가지고 비교하려고 했는데 정상적으로 돌아가는 것도 있었지만, 일부 단어들이 T/F가 제대로 나오지 않았다.

수정한 방법 1

str을 char형태로 받고, 이중 for문을 사용해 str의 i번째와 j번째가 같으면 false를 반환

수도코드

for (i는 0부터 str의 길이보다 작게)
    str을 소문자로 바꿈

    for (j는 i+1부터 str의 길이보다 작게)
    -> i와 j를 비교해줘야 되기 때문에 j는 i보다 1크게 시작한다
         if(str.charAt i와 j가 같다면)
             false를 반환

방법1 구현

public class Main {
    public static void main(String[] args) {
        System.out.print(isIsogram("isogram"));
    }
    public static boolean isIsogram(String str) {
    if (str.length() == 0) return true;

        str = str.toLowerCase();
        char[] arr = str.toCharArray();

        for (char ch : arr) {
            if (str.indexOf(ch) != str.lastIndexOf(ch)) {
                return false;
            }
        }
        return true;
    }
}

방법 2

향상된 for문을 사용해 str을 비교

수도코드

1. str을 소문자로 바꿔줌
2. char배열 arr에 str을 char형태로 변환한 걸 넣어줌
3. 향상된 for (ch에 arr 배열의 길이만큼 반복)

          if (str의 indexOf(ch)가 lastIndexOf(ch)와 다르다면)
                false를 반환

방법2 구현

public class Main {
    public static void main(String[] args) {
        System.out.print(isIsogram("isogram"));
    }
    public static boolean isIsogram(String str) {

        if (str.length() == 0) return true;

        str = str.toLowerCase();
        char[] arr = str.toCharArray();

        for (char ch : arr) {
            if (str.indexOf(ch) != str.lastIndexOf(ch)) {
                return false;
            }
        }
        return true;
    }
}

사용한 메서드

>향상된 for문
for (타입 변수이름 : 배열변수)
    배열의 길이만큼 반복하고자 하는 명령문;

>toCharArray(): 문자열을 char형 배열로 바꿔줌

>indexOf(): 앞에서부터 검색할 값을 찾음
lastIndexOf(): 끝에서부터 검색할 값을 찾음

문제

오늘은 2007년 1월 1일 월요일이다. 그렇다면 2007년 x월 y일은 무슨 요일일까? 이를 알아내는 프로그램을 작성하시오.

입력: 첫째 줄에 빈 칸을 사이에 두고 x(1 ≤ x ≤ 12)와 y(1 ≤ y ≤ 31)이 주어진다. 참고로 2007년에는 1, 3, 5, 7, 8, 10, 12월은 31일까지, 4, 6, 9, 11월은 30일까지, 2월은 28일까지 있다.

출력: 첫째 줄에 x월 y일이 무슨 요일인지에 따라 SUN, MON, TUE, WED, THU, FRI, SAT중 하나를 출력한다.

예제 입력: 3 14         예제 출력: WED

문제 이해

2007년에 날짜를 입력하고 어떤 요일인지 출력하는 문제이다

해결

1. 스캐너를 사용해 M(월) D(일) 값을 입력받는다
2. Month 값에 1월~12월까지 한달에 며칠이 있는지 선언한다
2. Day 배열에는 일요일부터 월요일까지 값을 넣는다
    -> 일요일부터 시작해야 순서가 밀리지 않는다
3. for (0부터 입력받은 달까지 반복)
       result에 1월부터 입력받은 달까지의 모든 날짜를 누적합 시킴
4.Day배열[result를 7로 나눈 나머지] 구함
    -> 1월 1일부터 입력받은 달까지 누적으로 합을 구했기 때문에 일주일로 나눈 나머지는 M D의 요일을 찾는다

구현

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int M = sc.nextInt();
        int D = sc.nextInt();
        sc.close();

        int[] Month = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
        String[] Day = {"SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"};

        int result = D;
        for (int i = 0; i < M - 1; i++) {
            result += Month[i];
        }
        System.out.print(Day[result % 7]);
    }
}

나누기와 나머지 연산자를 사용하지 않고 num1를 num2로 나눈 나머지를 리턴

방법

1. 나눗셈과 나머지 연산자는 사용할 수 없다
2. 그렇다면 지금 사용할 수 있는 연산자는 덧셈과 뺄셈
3. num1에서 num2를 계속 빼준다면 결국 나머지가 나오기 때문에 반복문과 뺄셈을 사용해 나머지를 구현

구현

public class Main {
    public Integer modulo(int num1, int num2) {
        if (num2 == 0) return null;

        while (num1 >= num2) {
            num1 = num1 - num2;
        }
        return num1;
    }
}

수도코드 -while을 사용해 num1의 값이 num2보다 같거나작아질 때까지 반복해서 빼줌 => 나머지

문제: 예제를 보고 규칙을 유추한 뒤에 별을 찍어 보세요.

입력: 첫째 줄에 N(1 ≤ N ≤ 100)이 주어진다. 출력: 첫째 줄부터 2×N-1번째 줄까지 차례대로 별을 출력한다.

예제입력 : 5           예제출력
                    *********
                     *******
                      *****
                       ***
                        *
                       ***
                      *****
                     *******
                    *********

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int num = Integer.parseInt(br.readLine());
        br.close();

        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < num; i++) {
            for (int j = 0; j < i; j++) {
                sb.append(" ");
            }
            for (int k = 0; k < 2 * num -(2 * i + 1); k++) {
                sb.append("*");
            }
            sb.append("\n");
        }
        for (int i = 0; i < num - 1; i++) {
            for (int j = 1; j < num - 1 - i; j++) {
                sb.append(" ");
            }
            for (int k = 0; k < 3 + (2 * i); k++) {
                sb.append("*");
            }
            sb.append("\n");
        }
        System.out.print(sb);
    }
}

흐름 -`빈칸, 별'을 상부, 하부로 나눠서 for문을 돌림

빈칸 0 - 1 - 2 - 3 - 4 0부터 시작해서 n-1까지 증가했다가 3 - 2 - 1 - 0 다시 0으로 감소

별 9 - 7 - 5 - 3 - 1 k는 0부터 2n -(2i +1)까지 반복 3 - 5 - 7 - 9 k는 0부터 3+2i까지 반복

수도코드

1. br로 입력값 받아옴
2.상부 for (0부터 시작해서 n보다 작게)
    빈칸 for (0부터 i보다 작게)
    별 for (0부터 2n -(2i +1)보다 작게)
   하부 for (0부터 n-1보다 작게)
     빈칸 for (1부터 n-1-i보다 작게)
     별 for (0부터 3+2i보다 작게)

드디어 스프링을 시작한다!!

Framework? 기본적으로 프로그래밍을 하기 위한 어떠한 틀이나 구조를 제공

스프링의 특징

POJO

(Plain Old Java Object)

규칙 1 Java나 Java의 스펙(사양)에 정의된 것 이외에는 다른 기술이나 규약에 얽매이지 않아야 한다

규칙 2 특정환경에 종속적이지 않아야 한다

POJO 프로그래밍 코드를 작성하기 위해 Spring에서는 세가지 기술을 지원 -> IoC/DI, AOP, PSA

IoC

(Inversion of Control)

IoC? 애플리케이션 흐름의 주도권을 Spring이 갖는 것

cf) 라이브러리: 애플리케이션 흐름의 주도권이 개발자에게 있음

DI

(Dependency Injection)

의존성 주입? 생성자를 통해서 어떤 클래스의 객체를 전달 받는 것

AOP

(Aspect Oriented Programming)

AOP? 애플리케이션의 핵심 업무 로직에서 로깅이나 보안, 트랜잭션 같은 공통 기능 로직들을 분리하는 것

PSA

(Portable Service Abstraction)

추상화? 어떤 클래스의 본질적인 특성만을 추출해서 ‘일반화’ 하는것

PSA 서비스의 기능을 접근하는 방식 자체를 일관되게 유지하면서 기술 자체를 유연하게 사용할 수 있도록 하는 것

스프링 모듈 구성

스프링 모듈 아키텍쳐

문제: 수를 요소로 갖는 배열을 입력받아 각 요소들이 그 이전의 요소들의 합보다 큰지 여부를 리턴

public class Main {
    public static boolean superIncreasing(int[] arr) {
        if(arr.length == 0) return false;
        int sum = arr[0];

        for (int i = 1; i < arr.length; i++) {
            if (arr[i] <= sum) {
                return false;
            }
            sum = sum + arr[i];
        }
        return true;
    }
}

흐름

1. 빈배열일 때는 false를 받음
2. sum을 선언하면서 arr[0]이라고 바로 받음
3. for문안에 if문을 사용해 arr[i]가 sum보다 작은 경우는 바로 false를 반환
4. 하지만 크다면 sum에 arr[i]를 계속 더해줌
5. 따라서 for문이 끝나고 나서 true를 받으면 됨

문제: 알파벳 소문자와 대문자로만 이루어진 길이가 N인 단어가 주어진다. 한 줄에 10글자씩 끊어서 출력하는 프로그램을 작성하시오.

입력: 첫째 줄에 단어가 주어진다. 단어는 알파벳 소문자와 대문자로만 이루어져 있으며, 길이는 100을 넘지 않는다. 길이가 0인 단어는 주어지지 않는다.

출력: 입력으로 주어진 단어를 열 개씩 끊어서 한 줄에 하나씩 출력한다. 단어의 길이가 10의 배수가 아닌 경우에는 마지막 줄에는 10개 미만의 글자만 출력할 수도 있다.

예제입력
BaekjoonOnlineJudge

예제출력
BaekjoonOn
lineJudge

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str = br.readLine();

        StringBuilder sb = new StringBuilder();

        int n = str.length() / 10;

        if (str.length() <= 10) {
            sb.append(str);
        }
        else {
            for (int i = 0; i < n; i++) {
                sb.append(str.substring(i*10, i*10+10)).append("\n");
            }
            if (str.length() % 10 != 0) {
                sb.append(str.substring(n*10, str.length())).append("\n");
            }
        }
        System.out.print(sb);
    }
}

처음 생각한 수도코드

1. BR 사용해서 string str에 입력받음 -> br.close();
2. 줄바꿈을 해 줄 for문
3. 10의 배수가 아닌 경우 줄바꿈을 한 번 더 해주는 if문

substring의 범위를 구하기 위해 i부터 10i+i까지 끊어줄 수 있는 식을 구함 시작: 10i + 1 끝: 10(i+1)

문제점

생각해보니까 저런식으로 하면 for문 조건식을 제대로 만들기 힘들다 그래서 if문을 사용해 글자수가 1~10이면 줄바꿈 없이 바로 출력할 수 있도록 수정했다.

문제점 보안한 수도코드

1. 변수선언: n은 str길이의 몫을 나타내는데, 
   이걸 str의 길이가 10의 배수가 아닌 경우 범위를 지정해주기 위해서 사용한다
2. if (str의 길이가 10보다 같거나 작은 경우는) 그대로 넣어줌
3. else
    for (0부터 n(str길이의 몫)까지 반복)
        substring를 사용해 10의배수~다음 10의배수까지 잘라준다. 
        그리고 append를 사용해 줄바꿈도 넣어준다.

        if (str의 길이가 10의 배수가 아니라면) 
        뒤에 남은 애들을 잘라주고, 줄바꿈도 넣어준다.

substring(): str.substring(인덱스 시작, 인덱스 끝)

문제: 예제를 보고 규칙을 유추한 뒤에 별을 찍어 보세요.

입력: 첫째 줄에 N(1 ≤ N ≤ 100)이 주어진다. 출력: 첫째 줄부터 2×N-1번째 줄까지 차례대로 별을 출력한다.

예제입력: 5     예제출력:
                                *
                               ***
                              *****
                             *******
                            *********
                             *******
                              *****
                               ***
                                *

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int num = Integer.parseInt(br.readLine());
        br.close();

        StringBuilder sb = new StringBuilder();

        for (int i = 1; i <= num; i++) {
            for (int j = 1; j <= num-i; j++) {
                sb.append(" ");
            }
            for (int k = 1; k <= 2*i-1; k++) {
                sb.append("*");
            }
            sb.append("\n");
        }
        for (int i = num-1; i >= 1; i--) {
            for (int j = 1; j <= num-i; j++) {
                sb.append(" ");
            }
            for (int k = 1; k <= 2*i-1; k++) {
                sb.append("*");
            }
            sb.append("\n");
        }
        System.out.print(sb);
    }
}

빈칸 n-1개부터 시작해서 n-2.. 0이 됐다가 다시 n-1개가 됨 => n-i 별 2n-1로 늘어났다가 줄어듦

흐름

1. Bufferedreader를 사용하여 수(num)을 입력받음
2. 상단별 반복 for문 (1부터 num까지 반복) 빈칸 for (1부터 num-i까지 반복) 별 for (1부터 2i-1까지 반복)
3. 하단별 반복 for문 (num-1부터 1까지 반복) 빈칸 for (1부터 num-i까지 반복) 별 for (1부터 2i-1까지 반복)

문제: 예제를 보고 규칙을 유추한 뒤에 별을 찍어 보세요.

입력: 첫째 줄에 N(1 ≤ N ≤ 100)이 주어진다. 출력: 첫째 줄부터 2×N-1번째 줄까지 차례대로 별을 출력한다.

예제입력: 5            예제 출력
                    *        *
                    **      **
                    ***    ***
                    ****  ****
                    **********
                    ****  ****
                    ***    ***
                    **      **
                    *        *

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int num = Integer.parseInt(br.readLine());

        StringBuilder sb =new StringBuilder();

        for (int i = 1; i <= num; i++) {
            for (int j = 1; j <= i; j++) {
                sb.append("*");
            }
            for (int k = 1; k <= 2*(num-i); k++) {
                sb.append(" ");
            }
            for (int j = 1; j <= i; j++) {
                sb.append("*");
            }
            sb.append("\n");
        }
        for (int i = num - 1; i >= 1; i--) {
            for (int j = 1; j <= i; j++) {
                sb.append("*");
            }
            for (int k = 1; k <= 2*(num-i); k++) {
                sb.append(" ");
            }
            for (int j = 1; j <= i; j++) {
                sb.append("*");
            }
            sb.append("\n");
        }
        System.out.print(sb);
    }
}

수도코드 -'왼쪽 별 / 공백 / 오른쪽 별'을 상부와 하부로 나눠서 for문을 만든다

별 1부터 n까지 증가했다가 1로 감소 공백 8 -> 6 -> 4 -> 2 -> 0 => 2n-2i

1. BR를 사용해 숫자를 입력받음(num)
2. 상층부 전체 for
    별 for
    빈칸 for
    별 for

   하층부 전체 for
    별 for
    빈칸 for
    별 for

End of File 더이상의 읽을 수 있는 데이터가 존재하지 않을 때 반복문을 종료

백준 10951번 while (sc.hasNextInt()) -> 입력값이 정수가 아니면 더이상 입력받지 않고 false를 반환하면 반복문을 종료시킴

아스키코드

백준 11654번

char ch = sc.nextLine().charAt(0);
        int num = (int)ch;

-> char형으로 scanner를 이용해 입력을 받고 int형태로 바꿈

문자 그대로 입력받기

백준 11718번

while ((str = br.readLine()) != null) {
            System.out.println(str);

-> br을 통해 입력받는 str이 비어있을 때까지 반복

readLine vs read

nextLine(): 엔터값을 입력받을 때까지 기준으로 한 줄 Line(): 공백을 기준으로 하나의 문자열

arraycopy()

System.arraycopy
(원본, 원본에서 어디부터 가져올지, 복사할 대상, 복사본에서 어디부터 받을 지, 원본에서 복사본으로 데이터를 읽어서 쓸 데이터 길이)

문제: 세 정수 A, B, C가 주어진다. 이때, 두 번째로 큰 정수를 출력하는 프로그램을 작성하시오.

입력: 첫째 줄에 세 정수 A, B, C가 공백으로 구분되어 주어진다. (1 ≤ A, B, C ≤ 100) 출력: 두 번째로 큰 정수를 출력한다.

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int [] arr = {sc.nextInt(), sc.nextInt(), sc.nextInt()};

        Arrays.sort(arr);
        System.out.print(arr[1]);
    }
}

원래 생각했던 수도코드

-for문으로 a,b,c를 비교

1. Scanner 사용
2. a,b,c를 비교할 for문 (1~3까지 반복)

    for (1~3)
        if ( a>b || a>c || b>a || b>c || c>a || c>b )
            if ( b>c || c>b || a>c || c>a || a>b || b>a )

문제점

1. 이렇게 돌리면 숫자는 비교가 되겠지만, 결과값을 받을 수가 없다
2. 그래서 숫자를 따로 비교하는 방식을 쓰려면 아래의 방식으로 비교해야 된다 if (a가 가장 크거나 모두 같은 경우) else (b가 가장 큰 수일 경우)

        if (a >= b) {
            if (a >= c) {
                if (b >= c)
                    System.out.print(b);
                else
                    System.out.print(c);
            } else
                System.out.print(a);
        } else {
            if (c <= b) {
                if (c <= a)
                    System.out.print(a);
                else
                    System.out.print(c);
            } else
                System.out.print(b);

쉬운 방법으로 바꾼 수도코드

Array.sort()를 사용

1. scanner를 사용해 배열에 값을 받아온다
2. 배열을 오름차순으로 정렬한다
3. print로 배열의 두번째를 받아오면 끝!

명령어 정리

Array.sort(): 오름차순 정렬 Arrays.sort(arr, Collections.reverseOrder()): 내림차순 정렬

오늘의 교훈

너무 복잡하게 생각하지 말자.......잘 안 풀릴 수록 단순하게 문제의 핵심만 생각하자

SQL? SQL은 구조화된 쿼리 언어

쿼리란 ? '질의문' 이라는 뜻 검색을 할 때 입력하는 검색어가 일종의 쿼리

기본 쿼리문

SQL을 사용에 필요한 기본 문법

Select
Where
And, Or, Not
Order By
Insert Into
Null Values
Update
Delete
Count
Like
Wildcards
Aliases
Joins
    Inner Join
    Left Join
    Right Join
Group By

데이터베이스 관련 용어

SQL Create DB
SQL Drop DB
SQL Create Table
SQL Drop Table
SQL Alter Table
SQL Not Null
SQL Unique
SQL Primary Key
SQL Foreign Key
SQL Default
SQL Auto Increment
SQL Dates

데이터베이스 관련 명령어

데이터베이스 생성 CREATE DATABASE [데이터베이스_이름];

데이터베이스 사용 USE 데이터베이스_이름;

테이블 생성

CREATE TABLE user (
  id int PRIMARY KEY AUTO_INCREMENT,
  name varchar(255),
  email varchar(255)
);

테이블 정보 확인 DESCRIBE user;

SQL 명령어

SELECT: 데이터셋에 포함될 특성을 정함 FROM: FROM 뒤에는 결과를 도출해낼 데이터베이스 테이블을 명시 WHERE: 필터 역할을 하는 쿼리문 ORDER BY: 돌려받는 데이터 결과를 어떤 기준으로 정렬하여 출력할지 결정 LIMIT: 결과로 출력할 데이터의 갯수를 정함 DISTINCT: 유니크한 값을 받을 때 사용 INNER JOIN: 둘 이상의 테이블을 서로 공통된 부분을 기준으로 연결

ACID

안전성을 보장하기 위한 성절

Atomicity(원자성) 모든 작업이 전부 성공하거나 전부 실패해서 결과를 예측할 수 있어야 됨

Consistency(일관성) 트랜잭션이 일어난 이후의 데이터베이스는 데이터베이스의 제약이나 규칙을 만족해야 됨

Isolation(격리성, 고립성) 다른 트랜잭션으로부터 독립되어야 함

Durability(지속성) 기록이 영구적으로 남아야 됨

문제: 가장 짧은 문자열과 가장 긴 문자열을 제거한 배열을 리턴

주의: 가장 짧은 문자열의 길이와 가장 긴 문자열의 길이는 같을 수 없다/ 길이가 가장 길거나 짧은 게 여러개라면 나중에 위치한 문자열을 제거

public class Main {
    public String[] removeExtremes(String[] arr) {

        if (arr.length == 0) return null;

        int shortestLen = 20;
        int longestLen = 0;

        int shortestIdx = 0;
        int longestIdx = 0;

        for (int i = 0; i < arr.length; i++) {
            if (arr[i].length() <= shortestLen) {
                shortestLen = arr[i].length();
                shortestIdx = i;
            }
            if (arr[i].length() >= longestLen) {
                longestLen = arr[i].length();
                longestIdx = i;
            }
        }
        String[] result = new String[arr.length - 2];
        int curIndex = 0;

        for (int i = 0; i < arr.length; i++) {
            if (i != shortestIdx && i != longestIdx) {
                result[curIndex] = arr[i];
                curIndex++;
            }
        }
        return result;
    }
}

흐름

1. 빈 배열일 때 null 리턴
2. 최단,최장 길이를 담을 변수와 최단, 최장의 인덱스를 담을 변수 선언
3. for (arr의 길이만큼 반복) {
     if (arr[i]의 길이가 최단길이보다 같거나 작다면)
        최단길이 변수에 arr[i]의 길이를 넣음
        최단길이 인덱스에 i를 넣음
     if (arr[i]의 길이가 최장길이보다 같거나 크다면)
        최장길이 변수에 arr[i]의 길이를 넣음
        최장길이 인덱스에 i를 넣음
   }
4. 결과 값을 받을 문자열 result선언. 최소,최대를 제외하고 받기 때문에 -2 해줌
5. 배열을 순회하며 result에 최장,최단을 제거한 나머지 문자열을 넣어줌