競プロ用のチートシート（Java）

# はじめに
競プロで使う Java のチートシートを載せています。

# 標準入力
:::note warn
記号は次の意味で使い分けています。
整数：$N, M, A_i, B_i, H, W$
文字列：$S, T, S_i$
:::

:::note warn
コメントで記載されている部分に入るコードのチートシートになります。
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // ここの部分を載せています
    }
}
```
:::

## 標準入力が int 型の場合
> $N$
> ```java
> int n = sc.nextInt();
> ```

> $N$ $M$
> ```java
> int n = sc.nextInt();
> int m = sc.nextInt();
> ```

> $N$
> $A_1$ $A_2$ $\dots$ $A_N$
> ```java
> int n = sc.nextInt();
> int[] a = new int[n];
> for (int i = 0; i < n; i++) {
>     a[i] = sc.nextInt();
> }
> ```

> $N$
> $A_1$
> $A_2$
> $\vdots$
> $A_N$
> ```java
> int n = sc.nextInt();
> int[] a = new int[n];
> for (int i = 0; i < n; i++) {
>     a[i] = sc.nextInt();
> }
> ```

> $N$
> $A_1$ $B_1$
> $A_2$ $B_2$
> $\vdots$
> $A_N$ $B_N$
> ```java
> int n = sc.nextInt();
> int[] a = new int[n];
> int[] b = new int[n];
> for (int i = 0; i < n; i++) {
>     a[i] = sc.nextInt();
>     b[i] = sc.nextInt();
> }
> ```

> $H$ $W$
> $A_{1,1}$ $A_{1,2}$ $\dots$ $A_{1,W}$
> $A_{2,1}$ $A_{2,2}$ $\dots$ $A_{2,W}$
> $\vdots$
> $A_{H,1}$ $A_{H,2}$ $\dots$ $A_{H,W}$
> ```java
> int h = sc.nextInt();
> int w = sc.nextInt();
> int[][] a = new int[h][w];
> for (int i = 0; i < h; i++) {
>     for (int j = 0; j < w; j++) {
>         a[i][j] = sc.nextInt();
>     }
> }
> ```

## 標準入力が long 型の場合

> $N$
> ```java
> long n = sc.nextLong();
> ```

> $N$ $M$
> ```java
> long n = sc.nextLong();
> long m = sc.nextLong();
> ```

> $N$
> $A_1$ $A_2$ $\dots$ $A_N$
> ```java
> int n = sc.nextInt();
> long[] a = new long[n];
> for (int i = 0; i < n; i++) {
>     a[i] = sc.nextLong();
> }
> ```

> $N$
> $A_1$
> $A_2$
> $\vdots$
> $A_N$
> ```java
> int n = sc.nextInt();
> long[] a = new long[n];
> for (int i = 0; i < n; i++) {
>     a[i] = sc.nextLong();
> }
> ```

> $N$
> $A_1$ $B_1$
> $A_2$ $B_2$
> $\vdots$
> $A_N$ $B_N$
> ```java
> int n = sc.nextInt();
> long[] a = new long[n];
> long[] b = new long[n];
> for (int i = 0; i < n; i++) {
>     a[i] = sc.nextLong();
>     b[i] = sc.nextLong();
> }
> ```

> $H$ $W$
> $A_{1,1}$ $A_{1,2}$ $\dots$ $A_{1,W}$
> $A_{2,1}$ $A_{2,2}$ $\dots$ $A_{2,W}$
> $\vdots$
> $A_{H,1}$ $A_{H,2}$ $\dots$ $A_{H,W}$
> ```java
> int h = sc.nextInt();
> int w = sc.nextInt();
> long[][] a = new long[h][w];
> for (int i = 0; i < h; i++) {
>     for (int j = 0; j < w; j++) {
>         a[i][j] = sc.nextLong();
>     }
> }
> ```

## 標準入力が文字列の場合

> $S$
> ```java
> String s = sc.next();
> ```

> $S$ $T$
> ```java
> String s = sc.next();
> String t = sc.next();
> ```

> $N$
> $S_1$
> $S_2$
> $\vdots$
> $S_N$
> ```java
> int n = sc.nextInt();
> String[] s = new String[n];
> for (int i = 0; i < n; i++) {
>     s[i] = sc.next();
> }
> ```

# 型変換
:::note warn
記号は次の意味で使い分けています。
$\text{int}$ 型の整数：$N_{\text{int}}$
$\text{long}$ 型の整数：$N_{\text{long}}$
文字：$C$
文字列：$S$
$\text{int}$ 型の整数の配列：$L_{N_\text{int}}$
$\text{long}$ 型の整数の配列：$L_{N_\text{long}}$
文字の配列：$L_C$
文字列の配列：$L_S$
:::
:::note alert
型変換は期待通りの結果にならない場合があります。
例えば、 $S$ $\rightarrow$ $C$ では、文字列 $S$ の長さが $1$ 以外の場合は期待通りの結果になりません。
他にも、 $N_{\text{long}}$ $\rightarrow$ $N_{\text{int}}$ では、 $N_{\text{long}}$ の値が $32\\, \text{bit}$ 整数型に収まらない場合は型変換を行うとオーバーフローします。
:::

> $N_{\text{int}}$ $\rightarrow$ $N_{\text{long}}$ $(\ \text{int}\ \rightarrow \text{long}\ )$
> ```java
> long n_long = n_int;
> ```

> $N_{\text{long}}$ $\rightarrow$ $N_{\text{int}}$ $(\ \text{long}\ \rightarrow \text{int}\ )$
> ```java
> int n_int = (int) n_long;
> ```

> $N_{\text{int}}$ $\rightarrow$ $C$ $(\ \text{int}\ \rightarrow \text{char}\ )$
> ```java
> char c = (char) n_int;
> ```

> $N_{\text{long}}$ $\rightarrow$ $C$ $(\ \text{long}\ \rightarrow \text{char}\ )$
> ```java
> char c = (char) n_long;
> ```

> $N_{\text{int}}$ $\rightarrow$ $S$ $(\ \text{int}\ \rightarrow \text{String}\ )$
> ```java
> String s = String.valueOf(n_int);
> ```

> $N_{\text{long}}$ $\rightarrow$ $S$ $(\ \text{long}\ \rightarrow \text{String}\ )$
> ```java
> String s = String.valueOf(n_long);
> ```

> $N_{\text{int}}$ $\rightarrow$ $L_{N_\text{int}}$ $(\ \text{int}\ \rightarrow \text{int [ ]}\ )$
> ```java
> char[] l_c = String.valueOf(n_int).toCharArray();
> int[] l_n_int = new int[l_c.length];
> for (int i = 0; i < l_c.length; i++) {
>     l_n_int[i] = l_c[i] - '0';
> }
> ```

> $N_{\text{long}}$ $\rightarrow$ $L_{N_\text{long}}$ $(\ \text{long}\ \rightarrow \text{long [ ]}\ )$
> ```java
> char[] l_c = String.valueOf(n_long).toCharArray();
> long[] l_n_long = new long[l_c.length];
> for (int i = 0; i < l_c.length; i++) {
>     l_n_long[i] = l_c[i] - '0';
> }
> ```

> $N_{\text{int}}$ $\rightarrow$ $L_C$ $(\ \text{int}\ \rightarrow \text{char [ ]}\ )$
> ```java
> char[] l_c = String.valueOf(n_int).toCharArray();
> ```

> $N_{\text{long}}$ $\rightarrow$ $L_C$ $(\ \text{long}\ \rightarrow \text{char [ ]}\ )$
> ```java
> char[] l_c = String.valueOf(n_long).toCharArray();
> ```

> $N_{\text{int}}$ $\rightarrow$ $L_S$ $(\ \text{int}\ \rightarrow \text{String [ ]}\ )$
> ```java
> String[] l_s = String.valueOf(n_int).split("");
> ```

> $N_{\text{long}}$ $\rightarrow$ $L_S$ $(\ \text{long}\ \rightarrow \text{String [ ]}\ )$
> ```java
> String[] l_s = String.valueOf(n_long).split("");
> ```

> $C$ $\rightarrow$ $N_{\text{int}}$ $(\ \text{char}\ \rightarrow \text{int}\ )$
> ```java
> int n_int = c;
> ```

> $C$ $\rightarrow$ $N_{\text{long}}$ $(\ \text{char}\ \rightarrow \text{long}\ )$
> ```java
> long n_long = c;
> ```

> $C$ $\rightarrow$ $S$ $(\ \text{char}\ \rightarrow \text{String}\ )$
> ```java
> String s = String.valueOf(c);
> ```

> $S$ $\rightarrow$ $N_{\text{int}}$ $(\ \text{String}\ \rightarrow \text{int}\ )$
> ```java
> int n_int = Integer.parseInt(s);
> ```

> $S$ $\rightarrow$ $N_{\text{long}}$ $(\ \text{String}\ \rightarrow \text{long}\ )$
> ```java
> long n_long = Long.parseLong(s);
> ```

> $S$ $\rightarrow$ $C$ $(\ \text{String}\ \rightarrow \text{char}\ )$
> ```java
> char c = s.charAt(0);
> ```

> $S$ $\rightarrow$ $L_{N_\text{int}}$ $(\ \text{String}\ \rightarrow \text{int [ ]}\ )$
> ```java
> int[] l_n_int = new int[s.length()];
> for (int i = 0; i < s.length(); i++) {
>     l_n_int[i] = s.charAt(i) - '0';
> }
> ```

> $S$ $\rightarrow$ $L_{N_\text{long}}$ $(\ \text{String}\ \rightarrow \text{long [ ]}\ )$
> ```java
> long[] l_n_long = new long[s.length()];
> for (int i = 0; i < s.length(); i++) {
>     l_n_long[i] = s.charAt(i) - '0';
> }
> ```

> $S$ $\rightarrow$ $L_C$ $(\ \text{String}\ \rightarrow \text{char [ ]}\ )$
> ```java
> char[] c = s.toCharArray();
> ```

> $S$ $\rightarrow$ $L_S$ $(\ \text{String}\ \rightarrow \text{String [ ]}\ )$
> ```java
> String[] l_s = s.split("");
> ```

> $L_{N_\text{int}}$ $\rightarrow$ $N_\text{int}$ $(\ \text{int [ ]}\ \rightarrow \text{int}\ )$
> ```java
> String s = "";
> for (int i = 0; i < l_n_int.length; i++) {
>     s += l_n_int[i];
> }
> int n_int = Integer.parseInt(s);
> ```

> $L_{N_\text{long}}$ $\rightarrow$ $N_\text{long}$ $(\ \text{long [ ]}\ \rightarrow \text{long}\ )$
> ```java
> String s = "";
> for (int i = 0; i < l_n_long.length; i++) {
>     s += l_n_long[i];
> }
> long n_long = Long.parseLong(s);
> ```

> $L_{N_\text{int}}$ $\rightarrow$ $S$ $(\ \text{int [ ]}\ \rightarrow \text{String}\ )$
> ```java
> String s = "";
> for (int i = 0; i < l_n_int.length; i++) {
>     s += l_n_int[i];
> }
> ```

> $L_{N_\text{long}}$ $\rightarrow$ $S$ $(\ \text{long [ ]}\ \rightarrow \text{String}\ )$
> ```java
> String s = "";
> for (int i = 0; i < l_n_long.length; i++) {
>     s += l_n_long[i];
> }
> ```

> $L_{N_\text{int}}$ $\rightarrow$ $L_C$ $(\ \text{int [ ]}\ \rightarrow \text{char [ ]}\ )$
> ```java
> char[] l_c = new char[l_n_int.length];
> for (int i = 0; i < l_n_int.length; i++) {
>     l_c[i] = (char) (l_n_int[i]);
> }
> ```

> $L_{N_\text{long}}$ $\rightarrow$ $L_C$ $(\ \text{long [ ]}\ \rightarrow \text{char [ ]}\ )$
> ```java
> char[] l_c = new char[l_n_long.length];
> for (int i = 0; i < l_n_long.length; i++) {
>     l_c[i] = (char) (l_n_long[i]);
> }
> ```

> $L_{N_\text{int}}$ $\rightarrow$ $L_S$ $(\ \text{int [ ]}\ \rightarrow \text{String [ ]}\ )$
> ```java
> String[] l_s = new String[l_n_int.length];
> for (int i = 0; i < l_n_int.length; i++) {
>     l_s[i] = String.valueOf(l_n_int[i]);
> }
> ```

> $L_{N_\text{long}}$ $\rightarrow$ $L_S$ $(\ \text{long [ ]}\ \rightarrow \text{String [ ]}\ )$
> ```java
> String[] l_s = new String[l_n_long.length];
> for (int i = 0; i < l_n_long.length; i++) {
>     l_s[i] = String.valueOf(l_n_long[i]);
> }
> ```

> $L_C$ $\rightarrow$ $S$ $(\ \text{char [ ]}\ \rightarrow \text{String}\ )$
> ```java
> String s = new String(l_c);
> ```

> $L_C$ $\rightarrow$ $L_{N_\text{int}}$ $(\ \text{char [ ]}\ \rightarrow \text{int [ ]}\ )$
> ```java
> int[] l_n_int = new int[l_c.length];
> for (int i = 0; i < l_c.length; i++) {
>     l_n_int[i] = l_c[i] - '0';
> }
> ```

> $L_C$ $\rightarrow$ $L_{N_\text{long}}$ $(\ \text{char [ ]}\ \rightarrow \text{long [ ]}\ )$
> ```java
> long[] l_n_long = new long[l_c.length];
> for (int i = 0; i < l_c.length; i++) {
>     l_n_long[i] = l_c[i] - '0';
> }
> ```

> $L_C$ $\rightarrow$ $L_S$ $(\ \text{char [ ]}\ \rightarrow \text{String [ ]}\ )$
> ```java
> String[] l_s = new String[l_c.length];
> for (int i = 0; i < l_c.length; i++) {
>     l_s[i] = String.valueOf(l_c[i]);
> }
> ```

> $L_S$ $\rightarrow$ $N_\text{int}$ $(\ \text{String [ ]}\ \rightarrow \text{int}\ )$
> ```java
> int n_int = Integer.parseInt(String.join("", l_s));
> ```

> $L_S$ $\rightarrow$ $N_\text{long}$ $(\ \text{String [ ]}\ \rightarrow \text{long}\ )$
> ```java
> long n_long = Long.parseLong(String.join("", l_s));
> ```

> $L_S$ $\rightarrow$ $S$ $(\ \text{String [ ]}\ \rightarrow \text{String}\ )$
> ```java
> String s = String.join("", l_s);
> ```

> $L_S$ $\rightarrow$ $L_{N_\text{int}}$ $(\ \text{String [ ]}\ \rightarrow \text{int [ ]}\ )$
> ```java
> int[] l_n_int = new int[l_s.length];
> for (int i = 0; i < l_s.length; i++) {
>     l_n_int[i] = Integer.parseInt(l_s[i]);
> }
> ```

> $L_S$ $\rightarrow$ $L_{N_\text{long}}$ $(\ \text{String [ ]}\ \rightarrow \text{long [ ]}\ )$
> ```java
> long[] l_n_long = new long[l_s.length];
> for (int i = 0; i < l_s.length; i++) {
>     l_n_long[i] = Long.parseLong(l_s[i]);
> }
> ```

> $L_S$ $\rightarrow$ $L_C$ $(\ \text{String [ ]}\ \rightarrow \text{char [ ]}\ )$
> ```java
> char[] l_c = new char[l_s.length];
> for (int i = 0; i < l_s.length; i++) {
>     l_c[i] = l_s[i].charAt(0);
> }
> ```