【Java】競技プログラミング　初心者向けTips

競技プログラミングで、標準入力の受け取り方や受け取った値を加工しやすくするための前処理(型変換など)の方法をまとめます。
※具体的な使用例は▶で折りたたみになっています。

# 1. 標準入力の受け取り

## 1.0. Scannerの使用

```java
Scanner sc = new Scanner(System.in);
```

<details>
<summary>使用例</summary>
<div>
`java.util.Scanner`をインポートして使用します。

```java
// Scannerのインポート
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 処理を記述...

    }
}
```
</div>
</details>

## 1.1. 空白文字まで受け取る

### 文字列(String型)

```java
String s = sc.next();
```

<details>
<summary>使用例</summary>
<div>
Scannerクラスの`next`メソッドで、[空白文字](https://www.javadrive.jp/start/scanner/index1.html#section3)区切りでString型の文字列として取得出来ます。

```bash:標準入力
hoge fuga
piyo
```

```java
//Scannerのインポート
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 1つ目の文字列をString型で受け取る
        String s = sc.next();
        // 2つ目の文字列をString型で受け取る
        String t = sc.next();
        // 3つ目の文字列をString型で受け取る
        String u = sc.next();

        // 受け取った文字列を出力
        System.out.println(s);
        System.out.println(t);
        System.out.println(u);
    }
}
```

```bash:標準出力
hoge
fuga
piyo
```

</div>
</details>

### 数値(int型)

#### ① int型の数値として直接受け取る(Scanner.nextInt)

```java
int x = sc.nextInt();
```

<details>
<summary>使用例</summary>
<div>
Scannerクラスの`nextInt`メソッドで、[空白文字](https://www.javadrive.jp/start/scanner/index1.html#section3)区切りでint型の数値として取得出来ます。

```bash:標準入力
1
20 300
```

```java
//Scannerのインポート
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 1つ目の数値をint型で受け取る
        int x = sc.nextInt();
        // 2つ目の数値をint型で受け取る
        int y = sc.nextInt();
        // 3つ目の数値をint型で受け取る
        int z = sc.nextInt();

        // 受け取った数値を出力
        System.out.println(x);
        System.out.println(y);
        System.out.println(z);
    }
}
```

```bash:標準出力
1
20
300
```

</div>
</details>

#### ② 文字列として受け取る & int型に変換する(Scanner.next + Integer.parseInt)

```java
int x = Integer.parseInt(sc.next());
```

<details>
<summary>使用例</summary>
<div>
Scannerクラスの`next`メソッドで、[空白文字](https://www.javadrive.jp/start/scanner/index1.html#section3)区切りでString型の文字列として取得した後に、Integerクラスの`parseInt`メソッドでint型に変換します。

```bash:標準入力
1
20 300
```

```java
//Scannerのインポート
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 1つ目の数値をString型で受け取ってint型に変換
        int x = Integer.parseInt(sc.next());
        // 2つ目の数値をString型で受け取ってint型に変換
        int y = Integer.parseInt(sc.next());
        // 3つ目の数値をString型で受け取ってint型に変換
        int z = Integer.parseInt(sc.next());

        // 受け取った数値を出力
        System.out.println(x);
        System.out.println(y);
        System.out.println(z);
    }
}
```

```bash:標準出力
1
20
300
```
</div>
</details>

## 1.2. 1行ごとに受け取る

### 文字列(String型)

#### 1行受け取る(Scanner.nextLine)

```java
String s = sc.nextLine();
```

<details>
<summary>使用例</summary>
<div>
Scannerクラスの`nextLine`メソッドで、改行区切りでString型の文字列として取得出来ます。

```bash:標準入力
hoge fuga
piyo
```

```java
//Scannerのインポート
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 1行目をString型で受け取る
        String s = sc.nextLine();
        // 2行目をString型で受け取る
        String t = sc.nextLine();

        // 受け取った文字列を出力
        System.out.println(s);
        System.out.println(t);
    }
}
```

```bash:標準出力
hoge fuga
piyo
```
</div>
</details>

## 1.3. 複数の入力を受け取る

### String型配列(String[]型)

#### ①受け取りを繰り返す(for文 + Scanner.next)

```java
for (int i=0; i<N; i++) {
    sArray[i] = sc.next();
}
```

<details>
<summary>使用例</summary>
<div>
Scannerクラスの`next`メソッドで、文字列の個数だけfor文で繰り返して取得します。

```bash:標準入力
3
hoge fuga piyo
```

```java
//Scannerのインポート
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);
        
        // 文字列の個数を取得
        int N = Integer.parseInt(sc.nextLine());
        
        // 受け取る文字列を格納するString型配列の宣言
        String[] sArray = new String[N];

        // 文字列を一つずつ受け取って配列に格納
        for (int i=0; i<N; i++) {
            sArray[i] = sc.next();
        }

        // 配列の全要素を出力
        for (int i=0; i <sArray.length; i++) {
            System.out.println("sArray[" + i + "] : "+ sArray[i]);
        }
    }
}
```

```bash:標準出力
sArray[0] : hoge
sArray[1] : fuga
sArray[2] : piyo
```
</div>
</details>

#### ②受け取りを繰り返す(while文)

```java
int count = 0;
while(sc.hasNext()) {
    sArray[count] = sc.next();
    count++;
}
```

<details>
<summary>使用例</summary>
<div>
Scannerクラスの`next`メソッドで、文字列の個数だけwhile文で繰り返して取得します。
`hasNext`メソッドで次の文字列があるかを判定することで、全ての文字列を取得出来ます。

```bash:標準入力
3
hoge fuga piyo
```

```java
//Scannerのインポート
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 文字列の個数を取得
        int N = Integer.parseInt(sc.nextLine());

        // 受け取る文字列を格納するString型配列の宣言
        String[] sArray = new String[N];

        // ループカウンタ
        int count = 0;
        // 文字列がある限り、一つずつ文字列を受け取って配列に格納
        while(sc.hasNext()) {
            sArray[count] = sc.next();
            count++;
        }

        // 配列の全要素を出力
        for (int i=0; i <sArray.length; i++) {
            System.out.println("sArray[" + i + "] : "+ sArray[i]);
        }
    }
}
```

```bash:標準出力
sArray[0] : hoge
sArray[1] : fuga
sArray[2] : piyo
```
</div>
</details>

#### ③一行受け取って、区切り文字を指定して分割する(Scanner.nextLine + String.split)

```java
String delimiter = " ";
String[] sArray = sc.nextLine().split(delimiter);
```

<details>
<summary>使用例</summary>
<div>
Scannerクラスの`nextLine`メソッドで、改行区切りでString型の文字列として取得して、Stringクラスのsplitメソッドで区切り文字で区切って配列にします。

```bash:標準入力
3
hoge fuga piyo
```

```java
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 文字列の個数は必要ないので一行進む
        sc.nextLine();

        // 区切り文字を指定
        String delimiter = " ";
        // 1行文字列として取得して、区切り文字で分割して格納
        String[] sArray = sc.nextLine().split(delimiter);

        // 配列の全要素を出力
        for (int i=0; i <sArray.length; i++) {
            System.out.println("sArray[" + i + "] : "+ sArray[i]);
        }
    }
}
```

```bash:標準出力
sArray[0] : hoge
sArray[1] : fuga
sArray[2] : piyo
```
</div>
</details>

#### ④Lambda式を使用する(Arrays.setAll + Lambda式)

```java
Arrays.setAll(sArray, i -> sc.next());
```

<details>
<summary>使用例</summary>
<div>
Lambda式でString型の文字列での受け取りを繰り返して、
その結果得られた値をArraysクラスの`setAll`メソッドで配列に格納します。

```bash:標準入力
3
hoge fuga piyo
```

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

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 文字列の個数を取得
        int N = Integer.parseInt(sc.nextLine());

        // 受け取る文字列を格納するString型配列の宣言
        String[] sArray = new String[N];

        // 配列を全てセットするメソッドとLambda式を用いて文字列を取得、格納
        Arrays.setAll(sArray, i -> sc.next());

        // 配列の全要素を出力
        for (int i=0; i <sArray.length; i++) {
            System.out.println("sArray[" + i + "] : "+ sArray[i]);
        }
    }
}
```

```bash:標準出力
sArray[0] : hoge
sArray[1] : fuga
sArray[2] : piyo
```
</div>
</details>

#### ⑤Stream API + Lambda式を使用する(Stream API + Lambda式)

```java
String[] sArray = IntStream
        .range(0,N)
        .mapToObj(i -> sc.next())
        .toArray(String[]::new);
```

<details>
<summary>使用例</summary>
<div>
Stream APIの中でlambda式`i -> sc.next()`を使用して文字列を受け取っています。

```bash:標準入力
3
hoge fuga piyo
```

```java
import java.util.Scanner;
import java.util.stream.IntStream;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 文字列の個数を取得
        int N = Integer.parseInt(sc.nextLine());

        // Stream APIとLambda式を用いて文字列を取得、格納
        String[] sArray = IntStream
                .range(0,N)
                .mapToObj(i -> sc.next())
                .toArray(String[]::new);

        // 配列の全要素を出力
        for (int i=0; i <sArray.length; i++) {
            System.out.println("sArray[" + i + "] : "+ sArray[i]);
        }
    }
}
```

```bash:標準出力
sArray[0] : hoge
sArray[1] : fuga
sArray[2] : piyo
```
</div>
</details>

### int型配列(int[]型)

#### ①受け取りを繰り返す(for文)

```java
for (int i=0; i<N; i++) {
    nArray[i] = sc.nextInt();
}
```

<details>
<summary>使用例</summary>
<div>
Scannerクラスの`nextInt`メソッドで、数値の個数だけfor文で繰り返して取得します。

```bash:標準入力
3
1 20 300
```

```java
//Scannerのインポート
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 数値の個数を取得
        int N = Integer.parseInt(sc.nextLine());

        // 受け取る数値を格納するint型配列の宣言
        int[] nArray = new int[N];

        // 数値を一つずつ受け取って配列に格納
        for (int i=0; i<N; i++) {
            nArray[i] = sc.nextInt();
        }

        // 配列の全要素を出力
        for (int i=0; i <nArray.length; i++) {
            System.out.println("nArray[" + i + "] : "+ nArray[i]);
        }
    }
}
```

```bash:標準出力
nArray[0] : 1
nArray[1] : 20
nArray[2] : 300
```
</div>
</details>

#### ②受け取りを繰り返す(while文)

```java
int count = 0;

while(sc.hasNext()) {
    nArray[count] = sc.nextInt();
    count++;
}
```

<details>
<summary>使用例</summary>
<div>
Scannerクラスの`nextInt`メソッドで、数値の個数だけwhile文で繰り返して取得します。
`hasNext`メソッドで次の文字列があるかを判定することで、全ての数値を取得出来ます。

```bash:標準入力
3
1 20 300
```

```java
//Scannerのインポート
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 文字列の個数を取得
        int N = Integer.parseInt(sc.nextLine());

        // 受け取る数値を格納するint型配列の宣言
        int[] nArray = new int[N];

        // ループカウンタ
        int count = 0;
        // 数値がある限り、一つずつ数値を受け取って配列に格納
        while(sc.hasNext()) {
            nArray[count] = sc.nextInt();
            count++;
        }

        // 配列の全要素を出力
        for (int i=0; i <nArray.length; i++) {
            System.out.println("nArray[" + i + "] : "+ nArray[i]);
        }
    }
}
```

```bash:標準出力
nArray[0] : 1
nArray[1] : 20
nArray[2] : 300
```
</div>
</details>

#### ③一行受け取って、区切り文字を指定して分割する(Scanner.nextLine + String.split)

```java
String[] sArray = sc.nextLine().split(delimiter);
int[] nArray = new int[N];

for ( int i = 0; i < N; i++) {
    nArray[i] = Integer.parseInt(sArray[i]);
}
```

<details>
<summary>使用例</summary>
<div>
Scannerクラスの`nextLine`メソッドで、改行区切りでString型の文字列として取得して、Stringクラスのsplitメソッドで区切り文字で区切って配列にします。
その後、String型配列の各要素をint型に変換します。

```bash:標準入力
3
1 20 300
```

```java
//Scannerのインポート
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 数値の個数を受け取る
        int N = Integer.parseInt(sc.nextLine());

        // 区切り文字を指定
        String delimiter = " ";
        // 1行文字列として取得して、区切り文字で分割して格納
        String[] sArray = sc.nextLine().split(delimiter);
        // int型配列を初期化
        int[] nArray = new int[N];

        // String型配列の各要素をint型に変換して格納
        for ( int i = 0; i < N; i++) {
            nArray[i] = Integer.parseInt(sArray[i]);
        }

        // 配列の全要素を出力
        for (int i=0; i <nArray.length; i++) {
            System.out.println("nArray[" + i + "] : "+ nArray[i]);
        }
    }
}
```

```bash:標準出力
nArray[0] : 1
nArray[1] : 20
nArray[2] : 300
```
</div>
</details>

#### ④Lambda式を使用する(Arrays.setAll + Lambda式)

```java
Arrays.setAll(nArray, i -> sc.nextInt());
```

<details>
<summary>使用例</summary>
<div>
Lambda式でint型の数値での受け取りを繰り返して、
Arraysクラスの`setAll`メソッドで配列に格納します。

```bash:標準入力
3
1 20 300
```

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

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 数値の個数を取得
        int N = Integer.parseInt(sc.nextLine());

        // 受け取る数値を格納するint型配列の宣言
        int[] nArray = new int[N];

        // 配列を全てセットするメソッドとLambda式を用いて数値を取得、格納
        Arrays.setAll(nArray, i -> sc.nextInt());

        // 配列の全要素を出力
        for (int i=0; i <nArray.length; i++) {
            System.out.println("sArray[" + i + "] : "+ nArray[i]);
        }
    }
}
```

```bash:標準出力
sArray[0] : 1
sArray[1] : 20
sArray[2] : 300
```
</div>
</details>

#### ⑤Stream API + Lambda式を使用する(Stream API + Lambda式)

```java
int[] nArray = IntStream
        .range(0,N)
        .map(i -> sc.nextInt())
        .toArray();
```

<details>
<summary>使用例</summary>
<div>
Stream APIの中でlambda式`i -> sc.nextInt()`を使用して数値を受け取っています。

```bash:標準入力
3
1 20 300
```

```java
import java.util.Scanner;
import java.util.stream.IntStream;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 数値の個数を取得
        int N = Integer.parseInt(sc.nextLine());

        // Stream APIとLambda式を用いて数値を取得、格納
        int[] nArray = IntStream
                .range(0,N)
                .map(i -> sc.nextInt())
                .toArray();

        // 配列の全要素を出力
        for (int i=0; i <nArray.length; i++) {
            System.out.println("nArray[" + i + "] : "+ nArray[i]);
        }
    }
}
```

```bash:標準出力
nArray[0] : 1
nArray[1] : 20
nArray[2] : 300
```
</div>
</details>

# 2. 標準出力

## 2.1. 値を出力する(System.out.print)

```java
 System.out.print(s);
```

<details>
<summary>使用例</summary>
<div>
SystemクラスのPrintStream型のインスタンスの`print`メソッドを使用することで、様々な型の値を出力することができます。

```bash:標準入力
hoge fuga 300
```

```java
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 出力文字列を標準入力から受け取る
        String s = sc.next();
        String t = sc.next();
        int x = sc.nextInt();

        // 標準出力
        System.out.print(s);
        System.out.print(t);
        System.out.print(x);
    }
}
```

```bash:標準出力
hogefuga300
```
</div>
</details>

## 2.2. 改行込みで値を出力する(System.out.println)

```java
System.out.println(s);
```

<details>
<summary>使用例</summary>
<div>
SystemクラスのPrintStream型のインスタンスの`println`メソッドを使用することで、様々な型の値を改行込みで出力することができます。

```bash:標準入力
hoge fuga 300
```

```java
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 出力文字列を標準入力から受け取る
        String s = sc.next();
        String t = sc.next();
        int x = sc.nextInt();

        // 標準出力
        System.out.println(s);
        System.out.println(t);
        System.out.println(x);
    }
}
```

```bash:標準出力
hoge
fuga
300
```
</div>
</details>

# 3. 値の操作

## 3.1. 文字列(String型)

### 3.1.1. 文字列をコピーする

```java
String t = new String(s);
```

<details>
<summary>使用例</summary>
<div>
文字列(String型)などの参照型変数をコピーする際は、新しくインスタンスを生成して、その初期値としてコピーする値を指定します。
**※直接イコールで代入(String s = t;)をすると、内部で同じ値を参照してしまうため、片方の値を操作した際にもう片方の値も変わってしまう可能性があります。**

```bash:標準入力
hoge
```

```java
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 出力文字列を標準入力から受け取る
        String s = sc.next();
        // sをコピーする
        String t = new String(s);

        // 標準出力
        System.out.println(s);
        System.out.println(t);
    }
}
```

```bash:標準出力
hoge
hoge
```
</div>
</details>

### 3.1.2. 指定した一文字を取り出す

#### ① charAtメソッドを使用する(String.charAt)

```java
char c0 = s.charAt(index);
```

<details>
<summary>使用例</summary>
<div>
Stringクラスの`charAt`メソッドを使用することで、指定した一文字を取り出すことができます。
**※戻り値の型はchar型ですので注意してください。**

```bash:標準入力
hoge
```

```java
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 出力文字列を標準入力から受け取る
        String s = sc.next();

        // sから指定した1文字を取り出す
        char c0 = s.charAt(0);
        char c1 = s.charAt(1);
        char c2 = s.charAt(2);
        char c3 = s.charAt(3);

        // 標準出力
        System.out.println(c0);
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
    }
}
```

```bash:標準出力
h
o
g
e
```
</div>
</details>

#### ② 1文字ごとの配列にして取得する。(String.toCharArray)

```java
char[] cArray = s.toCharArray();
```

<details>
<summary>使用例</summary>
<div>
Stringクラスの`toCharArray`メソッドを使用することで、一文字ごとのchar型配列を生成できます。

```bash:標準入力
hoge
```

```java
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 出力文字列を標準入力から受け取る
        String s = sc.next();

        // sから1文字ごとの配列を生成
        char[] cArray = s.toCharArray();

        // 標準出力
        System.out.println(cArray[0]);
        System.out.println(cArray[1]);
        System.out.println(cArray[2]);
        System.out.println(cArray[3]);
    }
}
```

```bash:標準出力
h
o
g
e
```
</div>
</details>

#### ③ 1文字ごとの配列にして取得する。(String.split)

```java
String[] sArray = s.split("");
```

<details>
<summary>使用例</summary>
<div>
Stringクラスの`split`メソッドで、文字列を空文字("")で分割することで、一文字ごとのString型配列を生成できます。

```bash:標準入力
hoge
```

```java
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 出力文字列を標準入力から受け取る
        String s = sc.next();

        // sから1文字ごとの配列を生成
        String[] sArray = s.split("");

        // 標準出力
        System.out.println(sArray[0]);
        System.out.println(sArray[1]);
        System.out.println(sArray[2]);
        System.out.println(sArray[3]);
    }
}
```

```bash:標準出力
h
o
g
e
```
</div>
</details>

### 3.1.3. 文字列を結合する

#### ① +演算子を使用する

```java
String st = s + t;
```

<details>
<summary>使用例</summary>
<div>
String型文字列同士の結合は、`+`演算子を用いて行うことができます。

```bash:標準入力
hoge fuga
```

```java
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 出力文字列を標準入力から受け取る
        String s = sc.next();
        String t = sc.next();

        // 文字列を結合する
        String st = s + t;

        // 標準出力
        System.out.println(st);
    }
}
```

```bash:標準出力
hogefuga
```
</div>
</details>

#### ② 区切り文字を指定して結合する(String.join)

```java
String st = String.join(delimiter, s, t);
```

<details>
<summary>使用例</summary>
<div>
Stringクラスの`join`メソッドで、区切り文字を指定して文字列を結合できます。
第一引数に区切り文字を指定して、第二引数以降は任意の数だけ文字列を指定できます。

```bash:標準入力
hoge fuga piyo
```

```java
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 出力文字列を標準入力から受け取る
        String s = sc.next();
        String t = sc.next();
        String u = sc.next();

        // 区切り文字を指定する
        String delimiterEmpty = "";
        String delimiterComma = ",";
        String delimiterSpace = " ";
        // 文字列を結合する
        String stu = String.join(delimiterEmpty, s, t, u);
        String stuComma = String.join(delimiterComma, s, t, u);
        String stuSpace = String.join(delimiterSpace, s, t, u);

        // 標準出力
        System.out.println(stu);
        System.out.println(stuComma);
        System.out.println(stuSpace);
    }
}
```

```bash:標準出力
hogefugapiyo
hoge,fuga,piyo
hoge fuga piyo
```
</div>
</details>

### 3.1.4 文字列の一部を切り出す(String.substring)

```java
String t = s.substring(beginIndex, lastIndex);
```

<details>
<summary>使用例</summary>
<div>
Stringクラスの`substring`メソッドで、文字列の一部を切り出すことができます。
第一引数に開始文字が何文字目かを指定します。終了箇所が途中の場合は、第二引数に終了文字の1文字後が何文字目か(終了文字のインデックス + 1)を指定します。
**※substringメソッドは、元の文字列を変更しません。(非破壊的メソッド)**

```bash:標準入力
hoge
```

```java
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 出力文字列を標準入力から受け取る
        String s = sc.next();

        // sからインデックスを指定して文字を切り出す(0:h 1:o 2:g 3:e)
        String s123 = s.substring(1);
        String s2 = s.substring(2, 3);

        System.out.println(s);
        System.out.println(s123);
        System.out.println(s2);
    }
}
```

```bash:標準出力
hoge
oge
g
```
</div>
</details>

### 3.1.5 文字列から指定した文字列を置換する(String.replace)

```java
String t = s.replace(target, replacement);
```

<details>
<summary>使用例</summary>
<div>
Stringクラスの`replace`メソッドで、文字列の中で指定した文字列を置換することができます。
第一引数に置換対象の文字列を指定します。第二引数に置換後の文字列を指定します。
**※substringメソッドは、元の文字列を変更しません。(非破壊的メソッド)**

```bash:標準入力
example
```

```java
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 出力文字列を標準入力から受け取る
        String s = sc.next();

        // 文字を指定して置換する
        String exam_ap = s.replace("exam", "ap");
        String e_O = s.replace("e", "O");
        String x_ = s.replace("x", "");

        System.out.println(s);
        System.out.println(exam_ap);
        System.out.println(e_O);
        System.out.println(x_);
    }
}
```

```bash:標準出力
example
apple
OxamplO
eample
```
</div>
</details>

## 3.2. 数値(int型)

### 3.2.1. 演算代入

```java
xSum += y;
xDif -= y;
xMul *= y;
xDiv /= y;
xRem %= y;
```

<details>
<summary>使用例</summary>
<div>
複合演算子を用いて、演算と代入を同時に行うことができます。
例えば、`x = x + y`を`x += y`と記述することができます。

```bash:標準入力
5 2
```

```java
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 数値を標準入力から受け取る
        int x = sc.nextInt();
        int y = sc.nextInt();

        // 演算のためにxをコピー
        int xSum = x;
        int xDif = x;
        int xMul = x;
        int xDiv = x;
        int xRem = x;

        // 加算(x + y)
        xSum += y;
        // 減算(x - y)
        xDif -= y;
        // 乗算(x * y)
        xMul *= y;
        // 除算(x / y)
        xDiv /= y;
        // 剰余(x % y)
        xRem %= y;

        // 標準出力
        System.out.println(xSum);
        System.out.println(xDif);
        System.out.println(xMul);
        System.out.println(xDiv);
        System.out.println(xRem);
    }
}
```

```bash:標準出力
7
3
10
2
1
```
</div>
</details>

## 3.3. 配列

### 3.3.1. 配列のコピー

#### ① 配列をコピーする(clone)

```java
String[] sArrayClone = sArray.clone();
int[] nArrayClone = nArray.clone();
```

<details>
<summary>使用例</summary>
<div>
`clone`メソッドで配列のコピーをできます。
コピー元とコピー先の要素はそれぞれ別の値を参照しているため、片方の配列を操作しても、もう片方に影響はありません。

```bash:標準入力
apple banana cat dog elephant
1 3 5 7 9
```

```java
import java.util.Arrays;
import java.util.Scanner;
import java.util.stream.IntStream;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 出力文字列を標準入力から受け取る
        String[] sArray = sc.nextLine().split(" ");
        int[] nArray = IntStream
                .range(0,5)
                .map(i -> sc.nextInt())
                .toArray();

        // 配列をコピー
        String[] sArrayClone = sArray.clone();
        int[] nArrayClone = nArray.clone();

        // 元の配列を一部変更
        sArrayClone[2] = "clone";
        nArrayClone[2] = 0;

        // 標準出力
        System.out.println(Arrays.toString(sArray));
        System.out.println(Arrays.toString(sArrayClone));
        System.out.println(Arrays.toString(nArray));
        System.out.println(Arrays.toString(nArrayClone));
    }
}
```

```:標準出力
[apple, banana, cat, dog, elephant]
[apple, banana, clone, dog, elephant]
[1, 3, 5, 7, 9]
[1, 3, 0, 7, 9]
```
</div>
</details>

#### ② 配列をコピーする(Arrays.copyOf)

```java
String[] sArrayCopy = Arrays.copyOf(sArray, sArray.length);
int[] nArrayCopy = Arrays.copyOf(nArray, nArray.length);
```

<details>
<summary>使用例</summary>
<div>
Arraysクラスの`copyOf`メソッドで、、配列のコピーをできます。
第一引数にコピー元の配列、第二引数にコピーする要素数を指定します。

コピー元とコピー先の要素はそれぞれ別の値を参照しているため、片方の配列を操作しても、もう片方に影響はありません。

```bash:標準入力
apple banana cat dog elephant
1 3 5 7 9
```

```java
import java.util.Arrays;
import java.util.Scanner;
import java.util.stream.IntStream;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 出力文字列を標準入力から受け取る
        String[] sArray = sc.nextLine().split(" ");
        int[] nArray = IntStream
                .range(0,5)
                .map(i -> sc.nextInt())
                .toArray();

        // 配列をコピー
        String[] sArrayCopy = Arrays.copyOf(sArray, sArray.length);
        int[] nArrayCopy = Arrays.copyOf(nArray, nArray.length);

        // 元の配列を一部変更
        sArrayCopy[2] = "clone";
        nArrayCopy[2] = 0;

        // 標準出力
        System.out.println(Arrays.toString(sArray));
        System.out.println(Arrays.toString(sArrayCopy));
        System.out.println(Arrays.toString(nArray));
        System.out.println(Arrays.toString(nArrayCopy));
    }
}
```

```:標準出力
[apple, banana, cat, dog, elephant]
[apple, banana, clone, dog, elephant]
[1, 3, 5, 7, 9]
[1, 3, 0, 7, 9]
```
</div>
</details>

#### ③ 配列をコピーする(System.arraycopy)

```java
System.arraycopy(sourceArray, srcPositions, destinationArray, destPositions, arrayLength);
```

<details>
<summary>使用例</summary>
<div>
Systemクラスの`arraycopy`メソッドで、、配列のコピーをできます。
第一引数にコピー元の配列、第二引数にコピー元の開始位置のインデックス、第三引数にコピー先の配列、第四引数にコピー先の開始位置のインデックス、第五引数にコピーする要素数を指定します。

コピー元とコピー先の要素はそれぞれ別の値を参照しているため、片方の配列を操作しても、もう片方に影響はありません。

```bash:標準入力
apple banana cat dog elephant
1 3 5 7 9
```

```java
import java.util.Arrays;
import java.util.Scanner;
import java.util.stream.IntStream;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 出力文字列を標準入力から受け取る
        String[] sArray = sc.nextLine().split(" ");
        int[] nArray = IntStream
                .range(0,5)
                .map(i -> sc.nextInt())
                .toArray();

        // コピー先配列を生成
        String[] sArrayCopy = new String[sArray.length];
        int[] nArrayCopy = new int[nArray.length];

        // 配列をコピー
        System.arraycopy(sArray, 0, sArrayCopy, 0, sArray.length);
        System.arraycopy(nArray, 0, nArrayCopy, 0, nArray.length);

        // 元の配列を一部変更
        sArrayCopy[2] = "copy";
        nArrayCopy[2] = 0;

        // 標準出力
        System.out.println(Arrays.toString(sArray));
        System.out.println(Arrays.toString(sArrayCopy));
        System.out.println(Arrays.toString(nArray));
        System.out.println(Arrays.toString(nArrayCopy));
    }
}
```

```:標準出力
[apple, banana, cat, dog, elephant]
[apple, banana, copy, dog, elephant]
[1, 3, 5, 7, 9]
[1, 3, 0, 7, 9]
```
</div>
</details>

### 3.3.2. 配列の比較

#### ① 1次元配列を比較(Arrays.equals)

```java
boolean isSame = Arrays.equals(array0, array1);
```

<details>
<summary>使用例</summary>
<div>
Arraysクラスの`equals`メソッドで、1次元配列を比較できます。
第一引数と第二引数に比較したい1次元配列を渡すと、要素の順序含めて一致していればtrue、不一致の場合はfalseを返します。

```bash:標準入力
apple banana cat dog elephant
apple banana cat dog elephant
1 3 5 7 9
9 7 5 3 1
```

```java
import java.util.Arrays;
import java.util.Scanner;
import java.util.stream.IntStream;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 文字列を標準入力から受け取る
        String[] s0Array = sc.nextLine().split(" ");
        String[] s1Array = sc.nextLine().split(" ");

        // 数値を標準入力から受け取る
        int[] n0Array = IntStream
                .range(0,5)
                .map(i -> sc.nextInt())
                .toArray();
        int[] n1Array = IntStream
                .range(0,5)
                .map(i -> sc.nextInt())
                .toArray();

        // 配列を比較
        boolean  isSameS0 = Arrays.equals(s0Array, s1Array);
        boolean  isSameS1 = Arrays.equals(n0Array, n1Array);

        // 標準出力
        System.out.println(isSameS0);
        System.out.println(isSameS1);
    }
}
```

```bash:標準出力
true
false
```
</div>
</details>

#### ② 多次元配列を比較

```java
boolean isSame = Arrays.deepEquals(s0ArrayArray, s1ArrayArray);
```

<details>
<summary>使用例</summary>
<div>
Arraysクラスの`deepEquals`メソッドで、多次元配列を比較できます。
第一引数と第二引数に比較したい多次元配列を渡すと、要素の順序含めて一致していればtrue、不一致の場合はfalseを返します。
配列の要素が配列である2次元配列などでも、各要素が一致しているかを比較できます。

```bash:標準入力
apple banana cat dog
1 3 5 7
```

```java
import java.util.Arrays;
import java.util.Scanner;
import java.util.stream.IntStream;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 文字列を標準入力から受け取る
        String[] sArray = sc.nextLine().split(" ");


        // 数値を標準入力から受け取る
        int[] nArray = IntStream
                .range(0,4)
                .map(i -> sc.nextInt())
                .toArray();

        // 多次元配列を生成
        String[][] s0ArrayArray = new String[2][2];
        System.arraycopy(sArray, 0, s0ArrayArray[0], 0, 2);
        System.arraycopy(sArray, 2, s0ArrayArray[1], 0, 2);
        int[][] n0ArrayArray = new int[2][2];
        System.arraycopy(nArray, 0, n0ArrayArray[0], 0, 2);
        System.arraycopy(nArray, 2, n0ArrayArray[1], 0, 2);

        // 多次元配列のコピーを生成
        String[][] s1ArrayArray = new String[2][2];
        System.arraycopy(sArray, 0, s1ArrayArray[0], 0, 2);
        System.arraycopy(sArray, 2, s1ArrayArray[1], 0, 2);
        int[][] n1ArrayArray = new int[2][2];
        System.arraycopy(nArray, 0, n1ArrayArray[0], 0, 2);
        System.arraycopy(nArray, 2, n1ArrayArray[1], 0, 2);

        // コピー先の配列を一部変更
        s1ArrayArray[1][0] = "copy";

        // 配列を比較
        boolean  isSameS = Arrays.deepEquals(s0ArrayArray, s1ArrayArray);
        boolean  isSameN = Arrays.deepEquals(n0ArrayArray, n1ArrayArray);

        // 標準出力
        System.out.println(isSameS);
        System.out.println(isSameN);
    }
}
```

```bash:標準出力
false
true
```
</div>
</details>

### 3.3.3. 配列の並び替え

#### ① 配列を昇順に並び替える

```java
Arrays.sort(sArray);
Arrays.sort(nArray);
```

<details>
<summary>使用例</summary>
<div>
Arraysクラスの`sort`メソッドで、配列を昇順に並び替えることができます。
**※引数に渡した配列を直接変更します。**

文字列の場合はa-zの順番で、数値の場合は値が小さい順です。


```bash:標準入力
banana apple cat elephant dog 
3 1 5 9 7
```

```java
import java.util.Arrays;
import java.util.Scanner;
import java.util.stream.IntStream;

public class Main {

    public static void main(String[] args) {

        // Scannerのインスタンスを生成
        Scanner sc = new Scanner(System.in);

        // 出力文字列を標準入力から受け取る
        String[] sArray = sc.nextLine().split(" ");
        int[] nArray = IntStream
                .range(0,5)
                .map(i -> sc.nextInt())
                .toArray();

        // 配列を昇順に並び替え
        Arrays.sort(sArray);
        Arrays.sort(nArray);

        // 標準出力
        System.out.println(Arrays.toString(sArray));
        System.out.println(Arrays.toString(nArray));
    }
}
```

```:標準出力
[apple, banana, cat, dog, elephant]
[1, 3, 5, 7, 9]
```
</div>
</details>

# 参考

[キーボードから入力された値を取得する - デフォルトの区切り文字である空白文字について](https://www.javadrive.jp/start/scanner/index1.html#section3)