포트란 '논리적인 접속장소'를 뜻하며, 인터넷 프로토콜인 TCP/IP를 사용할 때 클라이언트 프로그램이 네트워크 상의 특정 서버 프로그램을 지정하는 방법으로 사용한다.

한 서버 인스턴스에서 여러 개의 서버를 동시 실행할 수 있으므로, 이 경우 IP 주소 만으로는 어느 서버로 요청을 보내는지 특정하기 힘들다. 이 때 포트번호를 통해 receiver를 특정하여 어느 서버로 보내는 요청인지 특정할 수 있다.

포트번호는 0 ~ 65,535 까지 사용할 수 있으며, 이 중에서 0 ~ 1023번 까지의 포트 번호는 주요 통신을 위한 규약에 따라 이미 정해져 있는 포트이다.

• Well-known port : 0 ~ 1023 > 시스템 사용 번호 (슈퍼유저 권한 필요)

• Registered port : 1024 ~ 49151 > 특정 프로토콜이나 어플리케이션에서 사용하는 번호 (슈퍼유저 권한 필요X)
• Dynamic port : 49152 ~ 65535 > 어플리케이션 또는 임시 사용 번호

자주 사용되는 포트 번호

번호 / 프로토콜 / 통신 프로토콜 / 설명

• 80 : HTTP / TCP / 웹 서버 접속
• 443 : HTTPS / TCP / 웹 서버 접속(SSL)
• 110 : POP3 / TCP / 메일 읽기
• 25 : SMTP / TCP / 메일 서버간 메일 전송
• 23 : TENLET
• 53 : DNS / UDP / DNS 질의
• 123 : NTP / TCP / 시간 동기화
• 20 : FTP / TCP / 데이터 전송
• 21 : FTP / TCP / FTP 제어. 서버와 클라이언트 사이의 파일 전송을 위한 프로토콜
• 22 : SSH(Secure Shell) / TCP / 컴퓨터 원격 로그인. 다른 사용자가 세션을 엿듣지 못하도록 세션을 감싸 보안 및 안정성을 높임. 네트워크 상의 다른 컴퓨터에 로그인하거나 원격 시스템에서 명령을 실행하고 다른 시스템으로 파일을 복사할 수 있도록 해주는 프로토콜. Linux 계열에서 사용한다.

참고 https://ittrue.tistory.com/185?category=928607 https://sevendollars.tistory.com/43

애플리케이션 레이어

개발자가 개발한 코드 배치 처리 구축에 사용되는 모든 사용자 코드 및 구성을 포함한다. 업무 로직과 서비스 및 잡 구조화와 관련된 구성까지도 애플리케이션 레이어에 포함된다. 애플리케이션 레이어가 최상위에 있는 것이 아니라, 다른 두 레이어인 코어와 인프라스트럭처를 애플리케이션이 감싸고 있는 것으로 이해해야 한다.

애플리케이션 레이어는 그 다음 레이어인 코어 레이어와 상호작용하는 데 대부분의 시간을 소비한다.

코어 레이어

배치 영역을 구성하는 실제적인 컴포넌트로 구성 배치 도메인을 정의하는 모든 부분이 포함된다. 코어 컴포넌트의 요소에는 Job 및 Step 인터페이스와, 잡 실행에 사용되는 인터페이스, 즉 JobLauncher 및 JobParameters 등이 있다.

인프라스트럭처 레이어

ItemReadr, IremWriter 및 재시작과 관련된 문제 해결 가능한 클래스와 인터페이스 제공 배치 처리를 위해 파일, DB 등으로부터 읽고 쓸 수 있고, 잡 수행에 실패한 이후 재시도될 때 어떤 일을 수행할지 다룰 수 있다.

스프링 배치는 일반적으로 스케줄러이거나, 스케줄링 기능을 갖고 있다고 오해할 수 있으나 그렇지 않다. 프레임워크 내에는 주어진 시간 또는 주어진 이벤트에 따라 잡이 실행되도록 스케줄링 하는 기능이 없다. 크론이나 쿼츠, 컨트롤-M 같은 엔터프라이즈 스케줄러를 이용하는 등 잡을 구동 시키는 여러 방법이 있으나, 프레임워크 내에 존재하지는 않는다.

스프링으로 잡 정의하기

Job

중단이나 상호작용 없이, 처음부터 끝까지 실행되는 처리 여러 개의 스텝이 모여 잡을 이룬다. 각 스텝에는 관련된 입력과 출력이 있을 수 있다.

// 스프링 배치 잡 정의 예제
@Bean
public AccountTasklet accountTasklet() {
    return new AccountTasklet();
}

@Bean
public job accountJob() {
    Step accountStep = 
        this.stepBuilderFactory
            .get("accountStep")
            .tasklet(accountTasklet())
              .build();

return this.jobBuilderFactory
           .get("accountJob")
           .start("accountStep")
           .build();
}

위 소스 내에 두 개의 Bean이 작성되었다.

1) AccountTasklet : 커스텀 컴포넌트. 스텝이 동작하는 동안 비즈니스 로직 수행 스프링 배치는 AccountTasklet이 완료될 때까지 단일 메서드(excute 메서드)를 반복해서 호출하는데, 이때 각각은 새 트랜잭션으로 호출된다.

2) 실제 스프링 배치 잡 : 팩토리가 제공하는 빌더를 사용해, AccountTasklet을 감싸는 스텝 하나를 생성한다. 그 다음 Job Builder를 사용해 스텝을 감싸는 잡을 생성한다. 스프링 부트는 애플리케이션 기동 시 해당 잡을 찾아내 자동으로 실행시킨다.

스프링 배치는 스프링 기반으로 구축되었기 때문에, 의존성 주입 / AOP(Aspect-Oriented Programming) / 트랜잭션 관리 / 일반적인 작업(JDBC, JMS, 전자 메일 등) 을 위한 기능을 제공한다.

책 예제코드 > https://github.com/Apress/def-quide-spring-batch

잡(Job)

자바나 XML을 사용해 구성된 배치 잡은, 상태를 수집하고 이전 상태 -> 다음 상태로 전환된다. 개념적으로 스프링 배치 잡은 상태 기계(State Machine)에 지나지 않는다.

스프링배치에서 가장 일반적으로 상태를 보여주는 단위는 스텝이다.

ex) 업무 시간 이후에 고객의 은행계좌 처리

• 스텝1 : 다른 시스템에서 수신한 거래 정보 파일 읽어와 DB에 저장
• 스텝2 : 모든 입금 정보를 계좌에 반영
• 스텝3 : 모든 출금 정보를 계좌에 반영

스텝

잡을 구성하는 독립된 작업의 단위 Tasklet 기반 스텝과 Chunk 기반 스텝이 있으며, 태스크릿 기반 스텝의 구조가 더 간단하다.

Tasklet 기반 스텝

Tasklet을 구현하여 사용할 수 있으며, 스텝이 중지될 때까지 excute 메소드가 계속 반복해서 수행된다. 이 때 excute 메소드를 호출할 때마다 독립적인 트랜잭션이 얻어진다. 초기화, 저장 프로시저 실행, 알림 전송 등과 같은 잡에서 일반적으로 사용된다.

Chunk 기반 스텝

태스크릿 기반 스텝에 비해 구조가 약간 더 복잡하며, 아이템 기반의 처리에 사용한다. ItemReader / ItemProcesspr / ItemWriter 라는 3개의 주요 부분으로 구성되며, 이 때 ItemProcessor는 필수는 아니다. ItemReader와 ItemWriter 만으로도 스텝 실행이 가능한데, 이와 같은 스텝은 일반적으로 데이터 마이그레이션 잡에 많이 사용된다.

• Tasklet : 트랜잭션 내에서 로직이 실행될 수 있는 기능을 제공하는 전략(Strategy) 인터페이스
• ItemReader : 스텝 내에서 입력을 제공하는 전략 인터페이스
• ItemProcessor : 스텝 내에서 제공받은 개별 아이템에 업무 로직, 검증 등을 적용하는 역할을 수행하는 인터페이스
• ItemWriter : 스텝 내에서 아이템을 저장하는 전략 인터페이스

스프링의 잡 구조화 방법이 갖는 장점 : 각 스텝이 서로 독립적으로 처리될 수 있도록 분리되어 있다. 유연성 / 유지보수성 / 확장성 / 신뢰성 확보 가능

JobRepository

스프링 배치 아키텍처 내에서 공유되는 주요 컴포넌트 가운데 하나. 배치 수행과 관련된 다양한 수치 데이터(시작 시간, 종료 시간, 상태, 읽기/쓰기 횟수 등) 및 잡의 상태를 유지 관리한다. JobRepository는 일반적으로 관계형 데이터베이스를 사용하며, 스프링 배치 내의 대부분의 주요 컴포넌트가 이를 공유한다.

JobLauncher

잡을 실행하는 역할 담당. (Job.excute 메서드 호출) 또한 잡의 재실행 가능여부 확인 / 잡의 실행 방법(현재 스레드에서 수행할지, 스레드 풀을 통해 실행할지 등) / 파라미터 유효성 검증 등의 처리를 수행한다.

잡 실행 -> 해당 잡은 각 스텝 실행 -> 각 스텝이 실행되면 JobRepository는 현재 상태로 갱신된다. 즉 실행된 스텝, 현재 상태, 읽은 아이템 및 처리된 아이템 수 등이 모두 JobRepository에 저장된다.

잡과 스텝의 처리 방식은 매우 유사한데, 잡은 구성된 스텝 목록에 따라 각 스텝을 실행한다. 여러 아이템으로 이뤄진 청크의 처리가 스텝 내에서 완료될 때 -> 스프링 배치는 JobRepository 내에 있는 JobExecution 또는 StepException을 현재 상태로 갱신한다. 스텝은 ItemReader가 읽은 아이템의 목록을 따라간다. 스텝이 각 청크를 처리할 때 마다 JobRepository 내 StepExecution의 스탭 상태가 업데이트 된다. 현재까지의 커밋 수, 시작 및 종료시간, 기다 다른 정보 등이 JobRepository에 저장되며, 잡 또는 스텝이 완료되면 JobExecution 또는 StepExecution이 최종 상태로 업데이트 된다.

JobInstance

스프링 배치 잡의 논리적인 실행(Logical Execution)을 의미.

ex) 거래명세서를 생성하는 statementGenerator 라는 잡이 다른 파라미터로 실행될 때마다 새로운 JobInstance가 생성된다.

Jobexecution

스프링 배치 잡의 실제 실행(execution)을 의미. 잡을 구동할 때마다 새로운 JobExecution을 얻게 된다. 그러나 잡 실행에 실패한 이후 다시 실행하면, 해당 실행은 앞선 것과 동일한 논리적 실행(파라미터가 동일함)이므로 새로운 JobInstance를 얻을 수 없으나, 두 번째 실제 실행을 추적하기 위한 새로운 JobExecution을 얻을 것이다. 즉 JobInstance는 여러 개의 JobExecution을 가질 수 있다.

StepExecution

스텝의 실제 실행(execution)을 의미. 그러나 StepInstance 라는 개념은 존재하지 않는다. JobExecution은 여러 개의 StepExecution과 연관된다.

잡을 병렬화 하는 방법

• 다중 스레드 스텝을 통한 작업 분할
• 전체 스텝의 병렬 실행
• 비동기 ItemProcessor/ItemWriter 구성
• 원격 청킹
• 파티셔닝

(1) 다중 스레드 스텝

스프링 배치에서 잡은 청크라는 블록 단위로 처리되도록 구성되며, 각 청크는 독립적인 트랜잭션으로 처리된다. 일반적으로 각 청크는 연속해서 처리된다.

(2) 병렬 스텝

입력 파일의 데이터를 읽어오는 한 개의 스텝과, DB에 저장하는 일을 하는 한 개의 스텝이 있으나 서로 관련이 없을 경우, 각각 독립 실행되게끔 처리

(3) 비동기 ItemProcessor/ItemWriter

(4) 원격 청킹

마스터 노드에서 표준 ItemReader를 사용해 이뤄진다. 입력은 RabbitMQ와 같은 메시지 브로커를 통해 ItemProcessor로 전송된다. 처리가 완료되면 워커는 업데이트된 아이템을 다시 마스터로 보내거나 직접 기록한다. 이 방식은 네트워크 사용량이 많아질 수 있음에 유의해야 하며, 실제 처리에 비해 I/O 비용이 적은 시나리오에 적합하다.

@EnableBatchProcessing
@SpringBootApplication
public class HelloWorldApplication {

    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    @Bean
    public Step step() {
        return this.stepBuilderFactory.get("step1")
                                .tasklet(new Tasklet() {
                                    @Override
                                    public RepeatStatus execute(StepContribution contribution,
                                    ChunkContext chunkContext) {
                                        System.out.println("Hello, World!");
                                        return RepeatStatus.FINISHED;
                                    }
     }).build();
 }

     @Bean
     public Job job() {
         return this.jobBuilderFactory.get("job")
                                     .start(step())
                                     ,build();
     }

     public static void main(String[] args) {
         SpringApplication.run(HelloWorldApplication.class, args);
     }
 }

@EnableBatchProcessing 애너테이션을 사용함으로써 다음과 같은 컴포넌트를 직접 포함시킬 필요가 없어진다.

• JobRepository : 실행 중인 잡의 상태를 기록하는 데 사용됨
• JobLauncher : 잡을 구동하는 데 사용됨
• JobExplorer : JobRepository를 사용해 읽기 전용 작업을 수행하는 데 사용됨
• JobRegistry : 특정한 런저 구현체를 사용할 때 잡을 찾는 용도로 사용됨
• PlatformTransactionManager : 잡 진행 과정에서 트랜잭션을 다루는 데 사용됨
• JobBuilderFactory : 잡을 생성하는 빌더
• StepBuilderFactory : 스텝을 생성하는 빌더

@SpringBootApplication 애너테이션은 @ComponentScan + @EnableAutoConfiguration 을 결합한 메타 애너테이션이다. 데이터 소스 뿐만 아니라 스프링 부트 기반의 적절한 자동 구성을 만들어 준다.

클래스 정의가 끝난 이후에, 스프링 배치가 제공하는 두 개의 빌더(잡 빌더, 스텝 빌더)를 자동 와이어링 한다. 각 빌더는 @EnableBatchProcessing

추상자료형 추상자료형은 어떠한 데이터와 그 데이터에 대한 연산을 표기하는 것 ex) 세탁기로 옷을 세탁하는 과정 여기서 옷이 '어떠한 데이터'이며, 세탁기에는 이 옷(데이터)을 처리하는 여러 가지 기능(연산)이 있는데 세탁 / 탈수 / 남은시간 / 배수 등이 있다. 이처럼 데이터와 그 데이터를 연산하는 기능을 표기하는 것을 추상자료형이라고 한다.

연결리스트의 추상자료형

• 연결리스트에 필요한 연산을 대충 추리자면 아래와 같다. (1) 모든 데이터 출력 -> printAll() (2) 모든 데이터 제거 -> clear() (3) 인덱스에 데이터 삽입 -> insertAt(index, data); (4) 마지막 데이터 뒤에 데이터 삽입 -> insertLast(data); (5) 원하는 인덱스의 데이터 삭제 -> deleteAt(index); (6) 마지막 데이터 제거 -> deleteLast(); (7) 원하는 인덱스에 있는 데이터 읽기 -> getNodeAt(index);

위와 같은 구조를 연결리스트라고 한다. 연결리스트는 첫 노드의 주소만 알고 있으면 다른 모든 노드에 접근이 가능하다.

연결리스트

연결리스트의 경우, 배열과 달리 빈 메모리 공간 아무 곳에나 데이터를 생성한 뒤, 그것을 연결만 해주면 되기 때문에 배열의 초기 크기를 가늠할 필요가 없다.

배열의 경우 중간에 데이터를 삽입하면, 이후의 값들이 모두 뒤로 밀리기 때문에 오버헤드가 많이 든다. 반면 연결리스트는 중간에 데이터를 삽입하더라도 다음에 가리키는 노드만 바꿔주면 되기 때문에 비교적 간단하다.

배열은 메모리의 연속된 공간에 할당되어 있어 시작 주소만 알고 있다면 그 이후의 데이터에 접근하는 것이 용이하다. O(1)의 성능을 갖는다. 반면 연결리스트의 경우 데이터가 떨어져 있으므로 다음 데이터까지의 접근이 용이하지 않다. 노드를 계속 타며 원하는 데이터에 접근해야 하므로 O(n)의 성능을 갖는다.

배열과 연결리스트 비교

• 크기 : 배열은 크기 고정 / 연결리스트는 필요에 따라 동적인 크기의 배열 사용 가능
• 주소 : 배열은 연속된 메모리 공간에 값 할당 / 연결리스트는 불연속적인 메모리 공간에 값 할당한 후 노드를 이용해 그를 연결
• 데이터 참조 : 배열은 메모리의 연속된 공간에 할당되기 때문에 메모리 접근이 굉장히 빠르다. O(1)의 성능 / 연결리스트는 데이터 참조를 위해 앞에서부터 해당 노드까지 접근해야 하기 때문에 배열에 비해 느리다. O(n)의 성능
• 삽입과 삭제 : 배열에서 데이터를 삽입하려면 기존 모든 데이터를 옮겨야 하므로 O(n)의 성능을 갖는다. / 연결리스트는 데이터의 삽입 혹은 삭제를 위해 원하는 위치까지 노드를 타며 이동해야 하므로 O(n)의 성능을 갖는다.

데이터의 변경은 잘 일어나지 않고, 잦은 참조를 해야 한다면 => 배열 데이터의 삽입 및 삭제가 빈번할 경우 => 연결리스트

모든 프로그래밍 언어에서 제공하는 자료구조.

일반적으로 int arr[10] = {1,2,3,4,5}; 라는 배열을 지정했을 경우, 운영체제는 메모리에서 숫자 10개가 들어갈 수 있는 빈 공간을 찾아서 순서대로 값을 할당한다. 값이 할당되지 않은 빈 공간에는 쓰레기 값이 저장된다. 운영체제는 첫번째 값이 들어간 배열의 시작주소만 기억하는데, 프로그래머가 배열의 세 번째 원소에 접근하고 싶다면 arr[2] 와 같이 인덱스를 이용해 한 번에 접근한다.

배열의 인덱스 참조

배열의 길이와 상관없이 한 번에 가져오기 때문에 O(1) 의 성능을 갖는다. 때문에 배열은 읽기/쓰기, 즉 참조에서 좋은 성능을 보인다. 그러나 데이터의 삽입, 삭제 성능은 좋지 않음.

예를 들어, 프로그래머가 길이가 10인 배열을 생성한 뒤, 이 배열의 길이를 15로 늘리고 싶다면 운영체제는 길이가 15인 배열이 들어갈 수 있는 빈 공간을 다시 탐색하고, 또한 기존의 배열에 저장되어 있던 값을 복사해야 함.

자바스크립트의 경우 초기 배열 생성 당시 길이를 지정하지 않는다. 자바스크립트에서 배열은 상황에 따라서 연속적, 불연속적으로 메모리를 할당하지만, 대부분은 불연속적으로 할당한다. 이를 내부적으로 연결해 사용자에게는 배열인 것 처럼 보이는 것.

배열의 장단점

• 장점 : 읽기, 쓰기와 같은 참조에는 O(1)의 성능을 갖는다.
• 단점 : 크기 예측이 힘들기 때문에 메모리 낭비가 발생할 수 있다.

    데이터의 삽입, 삭제가 비효율적이다.

if [ -f "$FILENAME" ]; then
    echo "file exist"
else 
    echo "file not exist"
fi

옵션

• -b FILE 파일이 존재하고 특별한 파일인지 체크 FILE exists and is block special
• -c FILE 파일이 존재하고 특수문자가 있는지 체크 FILE exists and is character special
• -d FILE ; 디렉토리 여부 확인 파일이 존재하고 그 파일이 폴더인지 체크 FILE exists and is a directory
• -e FILE ; 파일과 폴더 구분 없이 존재하는지 확인 파일이 존재하는지 체크 FILE exists
• -f FILE ; 파일 유무 및 보통 파일 확인 파일이 존재하고 보통 파일인지 체크 FILE exists abd is a reqular file
• -g FILE 파일이 존재하고 group ID로 설정되었는지 체크 FILE exixsts and is set-group-ID
• -G FILE FILE exists and is owned by the effective group ID
• -h FILE 파일이 존재하고 symbolic link 파일인지 확인 FILE exists and is a symbolic link (same as -L)
• -k FILE FILE exists and has its sticky bit set
• -L FILE 파일이 존재하고 symbolic link 파일인지 확인 FILE exists and is a symbolic link (same as -h)
• -O FILE 파일이 존재하고 owner가 유효한지 확인 FILE exists and is owned by the effective user ID
• -p FILE 파일이 존재하고 그 파일이 pipe인지 확인 FILE exists and is a named pipe
• -r FILE 파일이 존재하고 read 가능한 파일인지 확인 FILE exists and read permission is granted
• -s FILE 파일이 존재하고 0 size 파일이 아닌지 체크 FILE is exists and has a size greater than zero
• -S FILE 파일이 존재하고 그 파일이 소켓인지 확인 FILE eixsts and is a socket
• -t FD file descriptor FD is opened on a ternimal
• -u FILE FILE exists and its set-user-ID bit is set
• -w FILE 파일이 존재하고 쓰기 가능한 파일인지 확인 FILE exists and write permission is granted
• -x FILE 파일이 존재하고 실행 가능한 파일인지 확인 FILE exists and execute (or search) permission is granted

참고: https://foris.tistory.com/256

한 개의 문자열 s와 문자 t가 주어졌을 때, 문자열 s의 각 문자가 문자 t와 떨어진 최소거리를 출력하는 프로그램을 작성하세요.

제한사항

• 첫 번째 줄에 문자열 s와 문자 t가 주어진다. 문자열과 문자는 소문자로만 주어진다. 문자열의 길이는 100을 넘지 않는다.

입출력 예

입력

teachermode e

출력

1 0 1 2 1 0 1 2 2 1 0

풀이

|--- s --|>|0|1|2|3|4|5|6|7|8|9|10| |:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:| |||t|e|a|c|h|e|r|m|o|d|e|

|answer|>|0|1|2|3|4|5|6|7|8|9|10| |:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:| |||t|e|a|c|h|e|r|m|o|d|e|

구현

 import java.util.*;
 class Main {





    public static void main(String[] args) {
        Main T = new Main();
        Scanner kb = new Scanner(System.in);
        String str = kb.next();
        System.out.print(T.solution(str));
    }
 }

문자와 숫자가 섞여있는 문자열이 주어지면 그 중 숫자만 추출하여 그 순서대로 자연수를 만듭니다. 만약 "tgeDa1h205er"에서 숫자만 추출한다면 0, 1, 2, 0, 5 이고, 이것을 자연수로 만들면 1205가 됩니다. 추출하여 만들어지는 자연수는 100,000,000을 넘지 않습니다.

제한사항

• 첫 줄에 숫자가 섞인 문자열이 주어집니다. 문자열의 길이는 100을 넘지 않습니다.

입출력 예

입력

g0en2T0s8eSoft

출력

208

풀이

숫자만 골라내야 하는데, 0~9의 아스키 코드 값은 48 ~ 57임. x >= 48 && x <= 57 을 만족하는 경우, 숫자로 판단.

"tge0Da1h205er"

• 0 (Ascii 48) answer 의 초기값이 0일 때, x는 48이므로 answer = answer * 10 + (x-48); 0 = 0 x 10 + (48-48); ====> 0

• 1 (Ascii 49) 1 = 0 x 10 + (49-48); ====> 1

• 2 (Ascii 49) 12 = 1 x 10 + (50-48); ====> 2

• 0 (Ascii 48) 120 = 12 x 10 + (48-48); ====> 120

• 5 (Ascii 49) 1205 = 120 x 10 + (53-48); ====> 1205

구현

 import java.util.*;
 class Main {

     // (1)
     public int solution(String s) {
        int answer = 0;

        for(char x : s.toCharArray()) {
            if (x>= 48 && x <= 57) answer = answer * 10 + (x-48);
        }

        return answer;
    }

    // (2)
     public int solution(String s) {
        String answer = "";

        for(char x : s.toCharArray()) {
            // isDigit() : 숫자 판별 함수
            if (Character.isDigit(x)) answer += x;
        } // 여기까지만 하면 answer는 String이므로 "0208" 출력됨.

        return Integer.parseInt(answer); // int로 파싱.
    }


    public static void main(String[] args) {
        Main T = new Main();
        Scanner kb = new Scanner(System.in);
        String str = kb.next();
        System.out.print(T.solution(str));
    }
 }

앞에서 읽을 때나 뒤에서 읽을 때나 같은 문자열을 팰린드롬이라고 합니다. 문자열이 입력되었을 때, 해당 문자열이 팰린드롬이면 "YES", 아니면 "NO"를 출력하는 프로그램을 작성하세요. 단 회문을 검사할 때 알파벳만 가지고 회문을 검사하며, 대소문자를 구분하지 않습니다. 알파벳 이외의 문자는 무시합니다.

제한사항

• 첫 줄에 길이 100을 넘지 않는 공백이 없는 문자열이 주어집니다.

입출력 예

입력

found7, time: study; Yduts; emit, 7Dnuof

출력

YES

구현

 import java.util.*;
 class Main {
     public String solution(String s) {
        String answer = "NO";
        // replace()는 정규식 사용불가, replaceAll()은 정규식 사용 가능
        s = s.toUpperCase().replaceAll("[^A-Z]", ""); //A-Z를 제외한 나머지 문자 처리
        String tmp = new StringBuilder(s).reverse().toString();

        if ( s.equals(tmp) ) answer = "YES";

        return answer;
    }


    public static void main(String[] args) {
        Main T = new Main();
        Scanner kb = new Scanner(System.in);
        String str = kb.next();
        System.out.print(T.solution(str));
    }
 }

앞에서 읽을 때나 뒤에서 읽을 때나 같은 문자열을 회문 문자열이라고 합니다. 문자열이 입력될 때, 해당 문자열이 회문 문자열이면 "YES", 회문 문자열이 아니면 "NO"를 출력하는 프로그램을 작성하세요. 단, 회문을 검사할 때 대소문자를 구분하지 않습니다.

제한사항

• 첫 줄에 길이 100을 넘지 않는 공백이 없는 문자열이 주어집니다.

입출력 예

입력

gooG

출력

YES

풀이

문자열의 절반까지 돌면서 같은 문자열 찾기. len/2 ---> i < len/2 대소문자 구분 없으므로 대문자 혹은 소문자로 통일 후 비교

구현

 import java.util.*;
 class Main {
     /// (1)
     public String solution(String str) {
        String answer = "YES";
        str = str.toUpperCase();
        int len = str.length();

        for (int i=0; i < len/2; i++) {
            if(str.charAt(i) != str.charAt(len-i-1)) return "NO";
        }

        return answer;
    }

    /// (2)
    public String solution(String str) {
        String answer = "NO";
        String tmp = new StringBuilder(str).reverse().toString();

        // equals는 대소문자 구분하므로 IgnoreCase 추가해야 함.
        if ( str.equalsIgnoreCase(tmp) ) answer = "YES";

        return answer;
    }

    public static void main(String[] args) {
        Main T = new Main();
        Scanner kb = new Scanner(System.in);
        String str = kb.next();
        System.out.print(T.solution(str));
    }
 }

소문자로 된 한 개의 문자열이 입력되면 중복된 문자를 제거하고 출력하는 프로그램을 작성하세요. 중복이 제거된 문자열의 각 문자는 원래 문자열의 순서를 유지합니다.

제한사항

• 첫 줄에 문자열이 입력됩니다. 문자열의 길이는 100을 넘지 않습니다.

입출력 예

입력

ksekkset

출력

kset

구현

import java.util.*;
class Main {
    public String solution(String str) {
        String answer = "";

        for (int i=0; i < str.length(); i++) {
            //System.out.println(str.charAt(i) + " " + i + " " + str.indexOf(str.charAt(i)));
            if (str.indexOf(str.charAt(i)) == i) answer += str.charAt(i);
        }
        return answer;
    }

    public static void main(String[] args) {
        Main T = new Main();
        Scanner kb = new Scanner(System.in);
        String str = kb.next();
        System.out.println(T.solution(str));
    }
}

영어 알파벳과 특수문자로 구성된 문자열이 주어지면 영어 알파벳만 뒤집고, 특수문자는 자기 자리에 그대로 있는 문자열을 만들어 출력하는 프로그램을 작성하세요.

제한사항

• 첫 줄에 길이가 100을 넘지 않는 문자열이 주어집니다.

입출력 예

입력

a#b!GE*T@S

출력

S#T!EF*b@a

구현

import java.util.*;
class Main {
    public String solution(String str) {
        String answer;
        char[] s = str.toCharArray();
        int lt = 0, rt = str.length()-1;
        while(lt<rt) {
            if ( !Character.isAlphabetic(s[lt]) ) lt++;
            else if ( !Character.isAlphabetic(s[rt]) ) rt--;
            else {
                char tmp = s[lt];
                s[lt] = s[rt];
                s[rt] = tmp;
                lt++;
                rt--;
            }
        }
        answer = String.valueOf(s);

        return answer;
    }

    public static void main(String[] args) {
        Main T = new Main();
        Scanner kb = new Scanner(System.in);
        String str = kb.next();
        System.out.println(T.solution(str));
    }
}

package org.apache.commons.vfs2 does not exist

pom.xml 우클릭 > Maven > Reload project 하니 해결되었다. 이는 pom.xml을 프로젝트 유형으로 여는 것과 완전히 동일한 기능이라고 함. 그래서 해당 기능 실행한 이후에는 "Web Resource Directory" 경로 재설정 필요하다고 한다.

위와 같이 해결이 된 상황 이후에도 Project Structure > Library 가면 해당 패키지 항목이 보이지 않는다. 여기서도 보이려면 인텔리제이 재시작이 필요함.

참고 : https://www.sysnet.pe.kr/2/0/12761

Enum이란 Enumeration의 앞 글자를 딴 약어로, 열거라는 의미이다. 서로 관련있는 상수들을 모아서 대표 이름으로 클래스를 정의하고 활용하는 데에 사용된다.

내부구현

가장 기본적이고 간단한 Enum 타입을 통해 내부 구현 형태를 알아보자. Direction이라는 Enum 클래스가 아래와 같이 정의되어 있다고 하자.

enum Direction { EAST, WEST, SOUTH, NORTH }

동서남북을 값으로 갖는 이 클래스는, 내부적으로 아래와 같이 구현된다.

enum Direction {

    static final Direction EAST = new Direction("EAST");
    static final Direction WEST = new Direction("WEST");
    static final Direction SOUTH = new Direction("SOUTH");
    static final Direction NORTH = new Direction("NORTH");

    private String name;

    private Direction(String name) { this.name = name; }   
}

Default 필드로 name이 생성되고, Default 생성자로는 name을 할당하는 생성자가 구현된다.

Default 생성자의 접근제어자는 묵시적으로 private이며, public일 수 없다. 외부에서 Enum 상수에 접근하려면 생성자가 아니라, Direction.EAST와 같은 형식으로 접근해야 한다.

API

Enum 클래스는 기본적으로 몇 가지 메서드를 제공한다.

Instance Method

• int ordinal() Enum 클래스 안에서 상수의 Index를 반환한다. Index는 선언된 순서대로 0부터 시작한다.
• String name(), String toString() Enum 클래스 안에서 상수의 이름을 반환한다.

Static Method

• Enum<T>[] values() Enum 클래스에 있는 모든 상수값을 배열로 반환한다. String[]이 아니라, Enum 클래스 타입의 객체로 반환하는 것이다.

• Enum<T> valueOf(String name) Enum 클래스 안에서 인자로 들어온 name과 같은 상수가 있으면, 그 상수 객체를 반환한다.

활용

두 Enum 객체의 값을 비교하여 Index 비교 결과를 반환하는 메서드가 내부적으로 구현되어 있다.

• int compareTo(E o)
• boolean equals(Object other)

두 메서드 모두 기본적으로 Enum 클래스 안에서 선언된 순서를 비교하여 결과를 산출한다.

💡 같은 Enum Type 객체들 간 비교는 == 연산자로도 가능하다. equals()를 사용해도 내부적으로 == 연산자를 호출하기 때문에, == 를 사용해서 비교하는 것이 더 효율적이다. 하지만 >, <와 같은 연산자 비교는 불가능하다.

Additional Field

Enum 상수들은 name 말고도 다른 값들을 필드로 가질 수 있다.

enum Direction {

    EAST(1, ">");
    WEST(5, "V");
    SOUTH(-1, "<");
    NORTH(10, "^");

    private final int value;
    private final String symbol;

    Direction(int value, String symbol) {
        this.value = value;
        this.symbol = symbol;
    }

    private int getValue() { return value; }
    private String getSymbol() { return symbol; }
}

다형성

Enum 클래스에 추상 메서드를 선언하고, 상수마다 추상 메서드를 구현하여 다형성을 구현할 수 있다.

Abstract Method

Enum 클래스 안에 추상 메서드를 선언하면, 각 상수들은 그 메서드를 오버라이딩 해야 한다. 이를 통해 같은 기능을 상수마다 다르게 구현할 수 있다.

enum Transportation {

    BUS(100) { int fare(int distance) { return distance * basicFare; }},
    TRAIN(150) { int fare(int distance) { return distance * basicFare; }},
    AIRPLAIN(300) { int fare(int distance) { return distance * basicFare; }};  

    abstract int fare(int distance);

    protected final int basicFare;

    Transportation(int basicFare) { basicFARE; }

    pubic int getBasicFare() { return basicFare; }
}

근데 Body 자체를 다 적어줘야 하다보니 코드가 지저분해진다. 그럴 때 사용할 수 있는 것이 아래의 Lamda다.

Lamda

아래는 Functional Interface와 Lamda를 활용해 Enum 클래스에서 기능을 구현한 것이다.

import java.util.function.DoubleBinaryOperator;

enum Operator {

    PLUS((a, b) -> a * b),
    MINUS((a, b) -> (a - b)),
    MULTIPLY((a, b) -> ( a * b)),
    DIVIDE((a, b) -> ( a / b));

    private final DoubleBinaryOperator doubleBinaryOperator;

    Operator(DoubleBinaryOperator doubleBinaryOperator) {
        this.doubleBinaryOperator = doubleBinaryOperator;
    }

    public Double caculate(double a, double b) {
        return this.doubleBinaryOperator.applyAsDouble(a, b);
    }
}

이 Operator 클래스는 외부에서 아래와 같이 사용할 수 있다.

Operator.PLUS.calculate(1, 2);      // 3.0
Operator.MINUS.calculate(1, 2);     // -1.0
Operator.MULTIPLY.calculate(1, 2);  // 2.0
Operator.DIVIDE.calculate(1, 2);    // 0.5

기능구현

Enum 클래스 내부에 상수들과 연관 있는 기능들을 구현하여 효율적으로 관리할 수 있다.

enum Statistic {

    THREE(3, 5000),
    FOUR(4, 50_000),
    FIVE(5, 1_500_000),
    BONUS(5, 3_000_000),
    SIX(6, 2_000_000_000);

    private final int matchingNumbers;
    private final int prize;

    Statistic(int matchingNumbers, int prize) {
        this.matchingNumbers = matchingNumbers;
        this.prize = prize;
    }

    public static Statistic getRank(int numberOfMatch) {
        return Arrays.stream(values())
                .filter(statistic -> statistic.matchingNumbers == numberOfMatch)
                .findFirst()
                .orElseThrow();
    }
}

참고 : Enum 정의와 활용

함수 내에서 자기 자신(함수)을 계속적으로 호출 하면서 풀어가는 방식. 함수가 호출 되면서 최근에 자신을 불렀던 기존 함수가 스택에 차곡차곡 쌓이게 된다.

처음 호출된 함수(스택 맨 밑에 있는 메소드)에서 return 되는 값이 최종 return 값이 된다.

팩토리얼이란?

3! = 3*2*1 = 6 4! = 4*3*2*1 = 24 5! = 5*4*3*2*1 = 120

문제

재귀를 이용한 특정 숫자의 팩토리얼 연산

public class Factorial {

    public static void main(String[] args) {
        int input = 4;   // 4!

        System.out.println(fact(input));
    }

    public static int fact(int n) {
        if ( n <= 1 ) 
             return n;
        else 
             return fact(n-1)*n;  
    }
}

결과

24

설명

1) 처음 fact 메소드가 호출된 것은 main 함수에서이다. fact(4)가 실행된다.

2) fact(4) n은 현재 4이다. n은 1보다 크므로 else를 타고, fact(3)이 호출된다.

3) 여기서 처음 호출된 fact(4)는 종료되지 않고 Stack에 쌓인 상태로, fact(4)가 호출한 fact(3)이 실행된다.

Stack fact(4)

4) fact(3) n은 현재 3이다. n은 1보다 크므로 else를 타고, fact(2)가 호출된다.

Stack fact(3) fact(4)

5) 이 때 호출된 fact(3) 또한 종료되지 않은 상태로 Stack에 쌓이고, fact(3)이 호출한 fact(2)이 실행된다.

6) fact(2) n은 현재 2이다. n은 1보다 크므로 else를 타고, fact(1)이 호출된다.

7) 세번째로 호출된 fact(2)는 종료되지 않은 상태로 Stack에 쌓이고 fact(2)가 호출한 fact(1)이 실행된다.

Stack fact(2) fact(3) fact(4)

8) fact(1) n은 현재 1이다. n이 1과 같으므로 if문을 타고 n, 즉 1을 return 한다.

9) fact(1)이 종료되면서, Stack의 가장 위에 있는 fact(2)가 실행된다. 8번에서 리턴 받은 값과 n을 곱하며 return 하고 fact(2)가 종료될 것이다.

fact(2) 에서는 n이 2이다. 8) 에서 fact(1)은 1을 리턴했었다.

그래서 fact(2)에서는 1*2 한 값을 return 한다. fact(2-1) x n → 1 x 2

Stack은 이제 아래와 같은 상태가 된다.

Stack fact(3) fact(4)

이후 같은 과정을 반복하면 1*2*3*4를 연산해 24의 결과값이 나오게 된다.

참고: https://marobiana.tistory.com/79

N개의 단어가 주어지면 각 단어를 뒤집어 출력하는 프로그램을 작성하세요.

제한사항

• 첫 줄에 자연수 N (3 ≤ N ≤ 20) 이 주어집니다.
• 두 번째 줄 부터 N개의 단어가 각 줄에 하나씩 주어집니다. 단어는 영어 알파벳으로만 구성되어 있습니다.

입출력 예

입력

3 good Time Big

출력

doog emiT giB

구현

 // (1) StringBuilder 사용
import java.util.Scanner;

public class Main {

    public ArrayList<String> solution5(int n, String[] str) {
       ArrayList<String> answer = new ArrayList<>();

       for (String x : str) {
           String temp = new StringBuilder(x).reverse().toString();
        answer.add(temp);
       }

        return answer;
    }

    public static void main(String[] args) {
        Main T = new Main();
        Scanner kb = new Scanner(System.in);
        int n = kb.nextInt();

        String[] str = new String[n];
        for (int i=0; i < n; i++) {
            str[i] = kb.next();
        }
        for (String x : T.solution(n, str)) {
            System.out.println(x);
        }
    }
}

------------------------------------------------------------

 // (2) IndexOf(), substring() 사용
public class Main {

    public ArrayList<String> solution5(int n, String[] str) {
         ArrayList<String> answer = new ArrayList<>();

         for (String x : str) {
             char[] s = x.toCharArray();
            int lt = 0;
            int rt = x.length() - 1;
            while (lt < rt) {
                char temp = s[lt];
                s[lt] = s[rt];
                lt++;
                rt--;
            }
            String temp = String.valueOf(s);
            answer.add(temp);
         }
        return answer;
    }

한 개의 문장이 주어지면 그 문장 속에서 가장 긴 단어를 출력하는 프로그램을 작성하세요. 문장 속의 각 단어는 공백으로 구분됩니다.

제한사항

• 첫 줄에 길이가 100을 넘지 않는 한 개의 문장이 주어집니다. 문장은 영어 알파벳으로만 구성되어 있습니다.
• 첫 줄에 가장 긴 단어를 출력합니다. 가장 길이가 긴 단어가 여러 개일 경우, 가장 앞쪽에 위치한 단어를 출력합니다.

입출력 예

입력

it is time to study

출력

study

구현

 // (1)
import java.util.Scanner;

public class Main {

    public String solution(String str) {
        String answer = "";
        int max = Integer.MIN_VALUE;

        String[] s = str.split(" ");
        for (String x : s) {
            int len = x.length();
            if (len > max) {
                max = len;
                answer = x;
            }
        }
        return answer;
    }

    public static void main(String[] args){
      Main T = new Main();
      Scanner kb = new Scanner(System.in);
      String str = kb.next();
      System.out.println(T.solution("it is time to study"));
    }
}

------------------------------------------------------------

 // (2) IndexOf(), substring() 사용
public class Main {

    public String solution(String str) {
        String answer = "";
        int max = Integer.MIN_VALUE;
        int pos; 

        while ((pos = str.indexOF('')) != -1) {
            String temp = str.substring(0, pos);
            int len = temp.length();
            if (len > max) {
                 max = len;
                 answer = temp;
            }
            str = str.substring(pos+1);
        }

        if(str.length() > max) answer = str;

        return answer;
    }

대문자와 소문자가 같이 존재하는 문자열을 입력 받아, 대문자는 소문자로 소문자는 대문자로 변환하여 출력하는 프로그램 작성

제한사항

• 첫 줄에 문자열이 입력된다. 문자열의 길이는 100을 넘지 않는다.
• 문자열은 영어 알파벳으로만 구성되어 있다.

입출력 예

입력

StuDY

출력

sTUdy

구현

import java.util.Scanner;

public class Main {

    public String solution(String str) {
        String answer = "";

        // (1)
        for( char x : str.toCharArray() ) {
            if (Character.isLowerCase(x)) answer += Character.toUpperCase(x);
            else answer += Character.toLowerCase(x);
        }

        // (2) 아스키코드 사용
        // 대문자 : 65 ~ 90
        // 소문자 : 97 ~ 122
        // 대소문자의 차이는 97-65 = 32로, 소문자에서 32를 빼면 대문자가 된다.
        for( char x : str.toCharArray() ) {
           if( x>= 97 && x <= 122) answer += (char)(x-32);
           else answer += (char)(x+32);
        }

        return answer;
    }

    public static void main(String[] args){
      Main T = new Main();
      Scanner kb = new Scanner(System.in);
      String str = kb.next();
      System.out.println(T.solution("StuDY"));
    }
}

첫 줄에 문자열이 주어지고, 두 번째 줄에 문자가 주어진다. 문자열은 영어 알파벳으로만 구성되어 있다.

입출력 예

입력

Computercooler c

출력

2

구현

 import java.util.*;
 class Main {
     public int solution(String str, char t) {
         int answer = 0;
        str = str.toUpperCase();       //대소문자 통일 후 비교
        t = Character.toUpperCase(t); 

        // (1)
        for(int i=0; i < str.length(); i++) {
            if (str.charAt(i) == t) answer++;
        }

        // (2) 향상된 for문
        for(char x : str.toCharArray()) {
            if (x==t) answer++;
        }

        return answer;
    }

     public static void main(String[] args) {
         Main T = new Main();
            Scanner kb = new Scanner(System.in);
            String str = =kb.next();
         char c = kb.next().charAt(0);

         System.out.println(T.solution(str, c));
    }  
 }

임의의 양의 정수 n에 대해, n이 어떤 양의 정수 x의 제곱인지 아닌지 판단하려 합니다. n이 양의 정수 x의 제곱이라면 x+1의 제곱을 리턴하고, n이 양의 정수 x의 제곱이 아니라면 -1을 리턴하는 함수를 완성하세요.

제한 사항

• n은 1이상, 50000000000000 이하인 양의 정수입니다.

입출력 예

입출력 예 설명

입출력 예 #1

121은 양의 정수 11의 제곱이므로, (11+1)를 제곱한 144를 리턴합니다.

입출력 예 #2

3은 양의 정수의 제곱이 아니므로, -1을 리턴합니다.

풀이

class Solution {
   public long solution(long n) {
        long answer = 0;
        Double x = Math.sqrt(n);

        if ( x == x.intValue() ) {
            answer = (long)Math.pow(x+1, 2);
        } else {
            answer = -1;
        }

        return answer;
    }
}

다른 풀이

// (1)
class Solution {
    public long solution(long n) {
       if (Math.pow((int)Math.sqrt(n), 2) == n) {
               return (long)Math.pow(Math.sqrt(n) + 1,2);
       }

       return -1;
    }
}

// (2)
class Solution {
    public long solution(long n) {

      double i = Math.sqrt(n);

      return Math.floor(i) == i ? (long)Math.pow(i+1, 2) : -1;
    }
}