[코딩테스트] Java 첫 코딩 테스트 시작 시 문법 정리

2023.12.18 Updated

 

 

 

자바 코딩 테스트를 준비하면서 필수적으로 알아야할 문법을 정리하고 있습니다.

 

최대한 간략하게 예시와 함께 설명하는 형태로 정리중이며, 속도 등 같은 기능을 수행하는 기술 간 차이점에 대한 증명 자료는 따로 첨부하지 않았습니다. 

 

 

 

 

참고문헌

https://devdocs.programmers.co.kr/references/java/docs/api/index.html

Overview (Java SE 11 & JDK 11 )

코딩 테스트를 보실 때 대부분 환경에서 document 사용을 지원합니다.

 

그래서 사용법을 잊어먹었을 때는 간단하게 찾아서 읽어볼 수 있는 정도는 할 줄 알면 좋습니다.

 

 

 

 

기본 & 입출력

코딩테스트 클래스 명명법

백준은 Main을 클래스 이름으로 사용합니다.

SWEA는 Solution을 클래스 이름으로 사용합니다.

public class Main { psvn } // 백준

public class Solution { psvn } // SWEA

 

 

 

필수 입력

Scanner 등 필요한 패키지 import 용으로 작성합니다.

시작 시 아래 코드를 직접 입력, 또는 ctrl + shift +o를 통해서 필요한 import문을 자동 입력합니다.

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

 

 

 

입력 받기 1 : Scanner

$ sc.next~()

 

Scanner를 이용한 가장 기본적인 입력 받는 방법입니다.

Scanner sc = new Scanner(System.in);

int i = sc.nextInt();
long l = scanner.nextLong();
double d = scanner.nextDouble();
String s = scanner.nextLine();

 

 

 

입력 받기 2 : BufferedReader

$ br.readLine()

 

공백 등으로 분리되어 많은 입력이 일어나는 경우 BufferedReader를 이용한 입력을 사용하면 속도면에서 효율적입니다.

Integer.parseInt(), split() 등을 함께 사용합니다.

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

int n = Integer.parseInt(br.readLine()); // br을 통해서 숫자 하나를 입력받는 경우

String[] a = br.readLine().split(" "); // 공백으로 나뉜 값 입력 받는 경우

 

 

 

입력 받기 3 : BufferedReader + StringTokenizer

$ st = new StringTokenizer(br.readLine(), " ");

 

StringTokenizer를 이용한 입력 방법입니다.

2번과 같이 공백 등으로 입력을 분리하여 쓰는 경우 유용하며, 가장 속도가 빠르다고 알려져 있습니다.st.nextToken()을 사용하여 다음 값을 불러올 수 있습니다.

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
// 첫 번째 줄 입력 예시 = 3 5
StringTokenizer st = new StringTokenizer(br.readLine()); // 첫 번째 줄 읽어옴

int N = Integer.parseInt(st.nextToken()); // 3
int M = Integer.parseInt(st.nextToken()); // 5

int[] cardArray = new int[N];

// 두 번째 줄 입력 예시 = 1 2 3
st = new StringTokenizer(br.readLine()); // 두 번째 줄 읽어옴

for (int i = 0; i < N; i++) {
    cardArray[i] = Integer.parseInt(st.nextToken()); // 1, 2, 3
}

// 두 번째 줄 입력 예시 = 1 2 3
st = new StringTokenizer(br.readLine()); // 두 번째 줄 읽어옴

// Tokenizer가 빌때까지 반복
while(st.hasMoreTokens()) {
    System.out.println(st.nextToken());
}

 

 

 

문자 입력 받기

$ .charAt(인덱스)

 

인덱스는 문자열에서 몇 번째 문자를 char로 변환할지를 정합니다. 하나의 문자만 받는 경우 0을 지정하시면 됩니다.

숫자를 입력받는 경우 인덱스를 생략합니다.

char c = br.readLine().charAt(0);

 

 

 

테스트 케이스 input 적용하기

$ System.setIn(new FileInputStream("파일_경로"));

 

테스트 케이스를 텍스트 파일에 입력한 후 실행 시 자동으로 입력되도록 할 때 사용합니다.

이클립스 기준 src 폴더와 동일 선상에 파일을 저장하면 됩니다.

System.setIn(new FileInputStream("res/1986/input.txt"));

 

 

 

 

문자 & 문자열

문자를 숫자로 변환

숫자를 문자로 변환

// 문자 -> 숫자 (char -> int)
// $ 숫자 - '0'
char c = '8';
int i = c - '0';

// 숫자 -> 문자 (int -> char)
// $ (char)(숫자 + '0')
int i = 8;
char c = (char)(i + '0');

 

 

 

대(소)문자 문자 -> 소(대)문자 문자

$ Character.toUpperCase(문자)

char c = 'A';
// 대 -> 소
c = Character.toLowerCase(c);

// 소 -> 대
c = Character.toUpperCase(c);

 

 

 

문자 대소문자 체크

$ Character.isUpperCase(문자)

char c = 'A';
boolean b = Character.isLowerCase(c); // false

b = Character.isUpperCase(c); // true

 

 

 

문자 대소문자 체크 (ASCII)

65 <= 대문자 <= 90

97 <= 소문자 <= 122

 

대문자 = 소문자 - 32 

소문자 = 대문자 + 32

if (c >= 65 && x <= 90) {
	// 대문자
} else {
	// 소문자
}

 

 

 

 

문자 알파벳 여부 체크

Character.isAlphabetic('A');

문자가 알파벳이면 true, 그밖에 특수문자이면 false를 반환합니다.

 

 

 

문자 숫자 여부 체크

char c = '999';

Character.isDigit(c); // true

 

 

 

문자 첫 번째 등장 위치 확인

String s = "Angel";

s.indexOf('A'); // 0

indexOf()는 찾고자 하는 요소나 부분 문자열이 처음으로 등장하는 인덱스를 반환합니다.

 

 

 

문자열 -> 대문자 문자열

문자열 -> 소문자 문자열

$ 문자열.toUpperCase()

String s = "AngelPlayer";

String upper = s.toUpperCase();
System.out.println(upper); // ANGELPLAYER

String lower = s.toLowerCase();
System.out.println(lower); // angelplayer

 

 

 

문자열을 숫자로 변환 (String to int)  

$ Integer.parseInt(문자열)

 

여러 방법이 있지만 숫자를 문자열과 함께 외울 수 있기 때문에 저는 Integer.parseInt()를 통한 방법을 사용합니다.

int num = Integer.parseInt("100");

 

 

 

숫자를 문자열으로 변환 (int to String)

$ Integer.toString(문자열)

 

Integer.toString()을 통해서 숫자를 문자열로 변환할 수 있습니다.

String string = Integer.toString(100);

 

 

 

문자열을 여러 번 합쳐야 할 때 String 대용

문자열의 더하기 연산이 계속되면 시간 초과가 발생할 수 있는데, 이때 StringBuilder를 사용하면 해결할 수 있습니다.

 

-> 대표 예제 문제 : 백준 17413

StringBuilder sb = new StringBuilder();

sb.append("Angel");
sb.append('8');
sb.append("Player");
sb.apppend(8);

System.out.println(sb); // Angel8Player8

 

 

 

문자열 자르기

$ 문자열.substring(시작인덱스, 끝인덱스);

$ 문자열.substring(시작인덱스);

String s = "AngelPlayer";
System.out.println(s.substring(5, 9)); // Play

System.out.println(s.substring(5)); // Player

두 개의 파라미터를 가지는 경우 시작 인덱스부터 끝 인덱스까지를 출력합니다.

 

이 때, 끝 인덱스 번호의 문자는 포함 되지 않습니다.

(위 예시에서 9는 e인데, e는 포함되지 않고 play 까지만 출력됩니다.)

 

반대로 하나의 파라미터를 가지는 경우, 시작 인덱스부터 마지막까지를 출력합니다.

 

 

 

문자열 -> 문자 배열

문자 배열 -> 문자열

String s = "Angel";
char[] arr = s.toCharArray(); // 문자열 -> 캐릭터 배열
String newS = String.valueOf(arr); // 배열 -> 문자열

System.out.println(newS);

문자열을 쪼개서 문자 배열로 만들거나, 반대로 문자 배열을 합쳐서 문자열로 만들어야 하는 경우 사용합니다.

 

 

 

문자 치환

$ 문자열.replaceAll('바꿀_문자', '바뀔_문자')

 

 

 

정규식

$ 문자열.replaceAll("[정규식]", 변환)

String s = " A!N@G#E$L";

// A에서 Z까지가 아닌 문자는 모두 ""로 치환 
s = s.replaceAll("[^A-Z]", ""); // ANGEL

 

 

 

문자열 뒤집기

String s = "Angel";

String temp = new StringBuilder(s).reverse().toString(); // legnA

 

 

 

n진수 -> 10진수

String s = "1000001";

int num = Integer.parseInt(s, 2); // 2진수를 10진수로 바꿈
System.out.println(num); // 65

자바에서 진수 변환은 Integer.parseInt()를 사용해서 할 수 있습니다.

 

 

 

ASCII -> int

int -> ASCII

char c = 'A';

int charToInt = (int) c;
System.out.println(charToInt); // 65

char intToChar = (char) charToInt;
System.out.println(intToChar); // A

 

코딩테스트에서 간간히 ascii 코드와 관련한 문제가 나오곤 합니다.

 

형변환을 통해서 숫자를 ascii 문자로, ascii 문자를 해당 하는 숫자로 바꿀 수 있습니다.

 

 

 

 

배열

배열 출력하기

$ Arrays.toString(배열명)

 

자바에서 배열명을 sout()으로 출력한다면 배열의 주소가 나오는 것을 확인할 수 있습니다.

따라서 Arrays.toString()을 사용해서 해당 결과를 출력해야 배열의 값을 확인할 수 있습니다.

 

 

 

배열 복사 / 크기 늘리기

$Arrays.copyOf(배열, 크기)

 

배열은 크기를 늘릴 수 없으므로 새로운 배열을 생성 후 할당해주는 방식으로 늘릴 수 있습니다.

다른 변수에 해당 기능을 사용함으로써 복사하는 것과 같은 효과도 낼 수 있습니다.

int[] arr = {1,2,3,4,5};
arr = Arrays.copyOf(arr, 10); // {1,2,3,4,5,0,0,0,0,0}

 

 

 

배열 일부만 자르기

$ Arrays.copyOfRange(배열, 시작_인덱스, 끝_인덱스)

 

배열의 일부만 잘라서 쓰고 싶은 경우 사용합니다.

return Arrays.copyOfRange(userList, 0, nowSize);

 

 

 

배열 정렬

$ Arrays.sort(배열, 설정)

// 오름차순 정렬 {1, 2, 3, 4}
Arrays.sort(array);

// 내림차순 정렬 {4, 3, 2, 1}
Arrays.sort(array, Collections.reverseOrder());

 

 

 

 

HashSet

HashSet은 중복을 허용하지 않으며, 순서를 가지지 않습니다.

 

 

set 생성

$ HashSet<Integer> set = new HashSet<>();

 

 

 

set -> array

$ Integer[] answer = set.toArray(new Integer[0]); // 0으로 해서 크기를 지정할 수 있음

 

 

 

array -> set

$ Set<Integer> set = new HashSet<Integer>(Arrays.asList(arr));  

 

 

 

 

ArrayList

리스트 생성

$ ArrayList<타입> 리스트명 = new ArrayList<>();

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

 

 

 

리스트에 요소 추가

$ 리스트명.add(값);

$ 리스트명.add(인덱스, 값);

list.add(1);

 

 

 

리스트 요소 가져오기

$ 리스트명.get(인덱스);

list.get(1);

 

 

 

리스트 요소 제거

$ 리스트명.remove(인덱스);

list.remove(2);

 

 

 

리스트 탐색

$ 리스트명.indexOf(값) // 리스트의 위치를 알려줌

$ 리스트명.contains(값) // 리스트의 존재 여부를 알려줌

int i = list.indexOf(8); // 존재하면 인덱스, 없으면 -1 리턴
boolean b = list.contains(8); // 값 존재 유무 리턴

 

 

 

정렬

$ 리스트명.sort(옵션);

list.sort(Comparator.naturalOrder()); // 오름차순 정렬
list.sort(Comparator.reverseOrder()); // 내림차순 정렬

 

 

뒤집기

$ Collections.reverse(리스트명)

 

 

 

자료구조

Collection interface

contains(Object o); // 요소를 포함하고 있는지 판단
size();

 

 

 

List

ArrayList와 LinkedList를 가짐

// $ ArrayList<타입> 리스트명 = new ArrayList<>();
List<String> names = new ArrayList<>();
// List<String> names = new LinkedList<>();

// 리스트 요소 추가하기
// $ 리스트명.add(인덱스, 요소);
names.add("Angel"); // 요소 추가하기
names.add("Player");
names.add("Angel");
names.add("Player");
names.addAll(0, "Hola"); // 특정 위치에 요소 추가하기
System.out.println(names); // [Hola, Angel, Player, Angel, Player]

// 요소 가져오기
// $ 리스트명.get(인덱스);
System.out.println(names.get(0)); // Hola

// 요소 변경하기
// $ 리스트명.set(인덱스, 값);
names.set(0, "AngelPlayer");

// 요소가 존재하는지 확인
// $ 인덱스명.contains(요소);
System.out.println(names.contains("Angel")); // true

// 요소의 인덱스 확인
// $ 인덱스명.indexOf(요소);
System.out.println(names.indexOf("Angel")); // 1
System.out.println(names.indexOf("Hola")); // -1

// 요소 삭제
names.remove(1); // 인덱스1의 값 제거
names.remove("Angel");
System.out.println(names); // [AngelPlayer, Player, Player]

 

 

 

set

순서 상관 없음

중복 없음

Set<Object> names = new HashSet<Object>();

names.add(Integer.valueOf(1));
names.add("Angel");
names.add("Angel"); // 중복 데이터는 추가해도 무시
names.add(1); // 기본형은 wrapper를 통해 추가해야 함
names.add("Player");

// names.remove(1); // 인덱스를 통한 삭제 불가능
// names.set(0, "AngelPlayer"); // 데이터 업데이트 불가능

 

 

 

스택

$ Stack<레퍼런스 타입> 스택명 = new Stack<>();

Stack<Integer> s = new Stack<>(); // 선언

s.push(8); // 스택에 값 추가 
s.pop(); // 스택의 값 하나 꺼내기

s.size(); // 스택안의 개수 출력 | int
s.empty(); // 스택이 비었는지 확인 | t/f
s.contains(값); // 스택 안에 데이터 있는지 여부 확인 | t/f

 

 

Queue

Queue<Integer> q = new LinkedList<>(); // 생성

q.offer(1); // 추가
q.offer(2);
q.poll(3); // 꺼내기

 

 

 

Map (HashMap)

key-value 쌍을 가지는 자료구조

HashMap의 경우 입력순서를 가지지 않음

// 선언
HashMap<Character, Integer> map = new HashMap<>();

// 삽입
map.put('A', 1); // map에 key-value 쌍 삽입
map.put('N', 1); // map에 key-value 쌍 삽입

// 반환
System.out.println(map.get('A')); // 1
System.out.println(map.get('H')); // null
System.out.println(map.getOrDefault('H', 0)); // 0


// 업데이트
map.put(N, map.get(N) + 1); // update

// 전체 출력
System.out.println(map); // {A=1, N=2}

// 크기 반환
System.out.println(map.size()); // 2

// 순회
for (Character key: map.keySet()) {
    System.out.println(key + " : " + map.get(key));
}

// key 삭제
System.out.println(map.remove('A')); // 삭제, 삭제하면서 value값 반환