Java Grammar

Java Grammar / Data Structure / Algorithm

Grammar

입출력 (I/O)

StringTokenizer 버전 (간단)

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
int n = Integer.parseInt(st.nextToken());
long m = Long.parseLong(st.nextToken());

출력

// 빠른 출력
StringBuilder sb = new StringBuilder();
sb.append("answer=").append(42).append('\n');
System.out.print(sb);

// 포맷 출력
System.out.printf("%.6f%n", 3.1415926535); // 반올림 6자리 + 개행

I/O 팁

• 반복 출력은 StringBuilder에 모아서 한 번에.

• next() 뒤 바로 nextLine() 쓰면 빈 줄 잡힐 수 있음(버퍼에 개행 남음 주의).

• 큰 입력: Scanner 지양(느림).

기본 자료형

타입	바이트	범위(대략)	비고
byte	1	-128 ~ 127	드뭄
short	2	±3e4	드뭄
int	4	±2.1e9	기본
long	8	±9e18	합/곱/거리 누적 시 사용
float	4	~7자리 정밀	거의 안 씀
double	8	~15자리 정밀	실수 계산
char	2	0 ~ 65535	유니코드 코드 유닛
boolean	1	true/false

리터럴

long L = 1_000_000_000L;  // L 붙이기
double d = 1.23;          // double 기본
float f = 1.23f;          // f 붙이기

형변환 & 오버플로

int a = 1_500_000_000, b = 2_000_000_000;
// int 합이 범위 초과 → long으로 승격해서 계산
long sum = (long) a + b;

실수 비교

double x = 0.3 * 3 + 0.1;      // 부동소수 오차
double y = 1.0;
double eps = 1e-9;
if (Math.abs(x - y) < eps) { /* equal */ }

String

불변(immutable) → 누적 결합은 StringBuilder 사용.

// 생성/기본
String s = "abc";
int len = s.length();
char c = s.charAt(1);     // 'b'
String t = s.substring(1); // "bc"
String u = s.substring(0, 2); // [0,2) → "ab"

// 비교
if (s.equals("abc")) { }
int cmp = s.compareTo("abd"); // 사전순

// 검색/치환
int i = s.indexOf("b");       // 1, 없으면 -1
String r = s.replace("a", "z"); // "zbc"

// 분할/조인
String[] parts = "a b  c".trim().split("\\s+");
String joined = String.join("-", parts); // "a-b-c"

// 누적은 StringBuilder
StringBuilder sb = new StringBuilder();
for (int k = 0; k < 3; k++) sb.append(k).append(',');
String res = sb.toString();

문자-숫자 변환

char ch = '7';
int digit = ch - '0'; // 7
char upper = Character.toUpperCase('a'); // 'A'
boolean isDigit = Character.isDigit(ch);

Array

선언/초기화

int[] a = new int[5];
int[] b = {3,1,4};
int[][] grid = new int[N][M];
boolean[][] vis = new boolean[N][M];

복사/채우기

int[] c = Arrays.copyOf(b, b.length);
Arrays.fill(a, -1);
for (int[] row : grid) Arrays.fill(row, 0);

정렬

Arrays.sort(b); // 오름차순
Integer[] B = {3,1,4};
Arrays.sort(B, Comparator.reverseOrder()); // 내림차순 (참조형 배열만)

2D 좌표/이벤트 정렬

int[][] edges = {{u1,v1,w1}, {u2,v2,w2}};
Arrays.sort(edges, Comparator.comparingInt(e -> e[2])); // 가중치 기준

이분 탐색

int idx = Arrays.binarySearch(b, 4); // 찾으면 인덱스, 없으면 (-(삽입위치)-1)

리스트와 혼용

List<Integer>[] g = new ArrayList[N];
for (int i=0;i<N;i++) g[i] = new ArrayList<>();

조건문 / 반복문

// if / else if / else
if (x > 0) { ... }
else if (x == 0) { ... }
else { ... }

// switch (자주 쓰는 형태)
switch (op) {
    case '+': res = a + b; break;
    case '-': res = a - b; break;
    default:  throw new IllegalArgumentException();
}

// for
for (int i=0; i<n; i++) { ... }

// 향상된 for (읽기 전용에 가깝게 사용)
for (int v : b) { /* 수정하면 안 안전 */ }

// while
while (cond) { ... }

// break/continue
for (int i=0;i<n;i++){
    if (skip(i)) continue;
    if (done(i)) break;
}

자주 쓰는 패턴

• 최솟값/최댓값 갱신

int INF = 1_000_000_000;
int ansMin = INF, ansMax = -INF;
ansMin = Math.min(ansMin, val);
ansMax = Math.max(ansMax, val);

• 범위 체크

static boolean in(int x,int l,int r){ return l<=x && x<=r; }

Math

기본

int a = Math.abs(-7);          // 7
int mn = Math.min(x, y);
int mx = Math.max(x, y);
long r = Math.round(3.6);      // 4 (long 반환 주의)
double f = Math.floor(3.6);    // 3.0
double c = Math.ceil(3.1);     // 4.0
double p = Math.pow(2, 10);    // 1024.0 (정수 거듭제곱엔 직접 구현 권장)
double s = Math.sqrt(81);      // 9.0

난수 (테스트용)

java.util.Random rnd = new java.util.Random(42);
int x = rnd.nextInt(100);     // 0..99
long y = Math.abs(rnd.nextLong());

정수 연산 유틸

// 최대공약수(GCD), 최소공배수(LCM)
static long gcd(long a, long b){
    while (b != 0) { long t = a % b; a = b; b = t; }
    return Math.abs(a);
}
static long lcm(long a, long b){
    return a / gcd(a, b) * b; // 오버플로 주의: 분자 먼저 나눠서
}

// 빠른 거듭제곱 (정수 모듈러)
static long modPow(long a, long e, long MOD){
    long r = 1 % MOD; a %= MOD;
    while (e > 0){
        if ((e & 1) == 1) r = (r * a) % MOD;
        a = (a * a) % MOD;
        e >>= 1;
    }
    return r;
}

// 안전한 모듈러(음수 보정)
static long mod(long x, long MOD){
    x %= MOD; if (x < 0) x += MOD; return x;
}

좌표/격자 이동

int[] dx = {1,-1,0,0};
int[] dy = {0,0,1,-1};
for (int dir=0; dir<4; dir++){
    int nx = x + dx[dir], ny = y + dy[dir];
}

Tip

• 입출력

  • Scanner 느림 → BufferedReader+StringTokenizer or FastScanner.

  • 마지막 개행/공백, 포맷 문자열(대소문자) 정확히.

• 자료형

  • 누적합/곱/거리/인덱스 곱셈: 반드시 long.

  • 오버플로 방지: (long)a * b, a / gcd(a,b) * b.

• 배열/리스트

  • 2차원 fill: 행마다 반복 필요.

  • Arrays.sort 비교자: a[1]-b[1] 대신 Integer.compare(a[1], b[1]) (오버플로 방지).

• 알고리즘 선택

  • 최단거리: 무가중치→BFS, 0/1→0-1 BFS, 양수 가중치→Dijkstra.

  • 구간 질의/업데이트 반복→Fenwick/SegmentTree.

• 방문/거리

  • 상태가 늘어날 때 visited 차원 확장(예: visited[x][y][broken]).

  • Dijkstra에서 if (d != dist[u]) continue; 필수.

• 성능

  • 문자열 누적은 StringBuilder.

  • 정렬/힙/맵 초기 용량 고려(대규모 입력).

  • 불필요한 박싱/언박싱 줄이기(가능하면 primitive 배열).

💡 팁

• 면 이름을 고정하고, 각 방향에 맞는 고정된 치환만 구현하면 버그가 크게 줄어든다.

• 다른 규칙(예: 바닥면 복사 반대 등)도 위 상호작용 부분만 바꾸면 된다.