Javaまとめ

curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"

sdk version

SDKMAN!
script: 5.18.2
native: 0.4.6

# 最新LTSのJavaをインストール
sdk install java

java --version
openjdk 21.0.3 2024-04-16 LTS
OpenJDK Runtime Environment Temurin-21.0.3+9 (build 21.0.3+9-LTS)
OpenJDK 64-Bit Server VM Temurin-21.0.3+9 (build 21.0.3+9-LTS, mixed mode)

.
├── build
│   ├── classes
│   │   └── java
│   │       └── main
│   │           └── org
│   │               └── example
│   │                   └── Main.class
│   ├── generated
│   │   └── sources
│   │       ├── annotationProcessor
│   │       │   └── java
│   │       │       └── main
│   │       └── headers
│   │           └── java
│   │               └── main
│   └── tmp
│       └── compileJava
│           └── previous-compilation-data.bin
├── build.gradle.kts
├── gradle
│   └── wrapper
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradlew
├── gradlew.bat
├── settings.gradle.kts
└── src
    ├── main
    │   ├── java
    │   │   └── org
    │   │       └── example
    │   │           └── Main.java
    │   └── resources
    └── test
        ├── java
        └── resources

plugins {
    id("java")
}

repositories {
    mavenCentral()
}

dependencies {
    testImplementation(platform("org.junit:junit-bom:5.10.0"))
    testImplementation("org.junit.jupiter:junit-jupiter")
}

./gradlew tasks

tasks.test {
    useJUnitPlatform()
}

tasks.register("hello") {
    group = "Other"
    doLast {
        println("Hello World!!")
    }
}

./gradlew hello

> Task :hello
Hello World!!

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello world!");
    }
}

String str = "Java";

System.out.println("Hello, " + "World!!");
System.out.println("Hello, ".concat("World!!"));

        // StringBuilder
        var sb = new StringBuilder();
        for(var i = 0; i < 100; i++) {
            sb.append(i);
        }
        var str = sb.toString();
        System.out.println(str);

        var sb = new StringBuilder();

        System.out.println(sb.capacity()); // 16
        sb.append("a".repeat(17));
        System.out.println(sb.capacity()); // 34

        // 文字列の長さ
        System.out.println("abcde".length()); // 5

        // 小文字、大文字
        System.out.println("upper".toUpperCase());
        System.out.println("LOWER".toLowerCase());

        // 空白　isEmpty, isBlank, trim
        var emptyStr = "   ";
        System.out.println("emptyStr is empty : " + emptyStr.isEmpty()); // false
        System.out.println("emptyStr is blank : " + emptyStr.isBlank()); // true

        var includeSpaceStr = "     Java        ";
        System.out.println(includeSpaceStr);
        System.out.println(includeSpaceStr.trim());
        System.out.println(includeSpaceStr.strip()); // Unicodeの空白文字全体を対象

        var name = "Alice";
        var age = 20;
        var formated = String.format("user name is %s. age is %d", name, age);
        System.out.println(formated);

        formated = "";
        formated = "user name is %s. age is %d".formatted(name, age);
        System.out.println(formated);

        System.out.printf("%s\n", "Java");
        System.out.printf("%d\n", 21);
        System.out.printf("%f\n", 1.11); // 1.110000
        System.out.printf("%.2f\n", 1.11); // 1.11
        System.out.printf("%x\n", 255); // ff
        System.out.printf("%04d\n", 1); // 0001

        // substring
        var day = "2024/5/8";
        System.out.println("today is " + day.substring(7) + " day");
        System.out.println("today is " + day.substring(0, 4) + " year");

        // split
        var arr = day.split("/");
        for (var s : arr) {
            System.out.println(s);
        }

        // startWith, endWith
        class Id {
            static String get(int num) {
                return num == 0 ? "01-xxxx" : "xxxx-a";
            }
        }

        System.out.println("start with 01: " + Id.get(0).startsWith("01")); // true
        System.out.println("end with a: " + Id.get(1).endsWith("a")); // true

        // charの話
        char a = 'a';
        for(char c : "Java".toCharArray()) {
            System.out.println(c);
        }

        var p = Pattern.compile("^Hello, World(!+)?$");
        var m1 = p.matcher("Hello, World");
        var m2 = p.matcher("Hello, World!");
        var m3 = p.matcher("Hello, World!!");
        var m4 = p.matcher("Hello, World!!$");

        System.out.println("m1: "+m1.find());
        System.out.println("m2: "+m2.find());
        System.out.println("m3: "+m3.find());
        System.out.println("m4: "+m4.find());

        var p2 = Pattern.compile("(\\d{3})-(\\d{3})-(\\d{4})");
        var m5 = p2.matcher("049-111-2222");

        if(m5.find()) {
            System.out.println(m5.group());
            System.out.println(m5.group(1));
            System.out.println(m5.group(2));
            System.out.println(m5.group(3));
        }

        var pass = "ajeiuikoljlx";
        var passPattern = Pattern.compile("[a-zA-Z]");
        var passMatcher = passPattern.matcher(pass);
        System.out.println(passMatcher.replaceAll("x"));

        System.out.println(Arrays.toString("😄".getBytes()));
        // [-16, -97, -104, -124]

        // テキストブロック Java 15
        var json = """
                {
                    "name": "Alice",
                    "age": 20,
                }
                """;
        System.out.println(json);

        // 文字列テンプレート Java 21 プレビュー機能
        var lang = "Java";
        System.out.println(STR."This code is \{lang}");

        // 32ビット整数
        int num = 1;
        Integer num2 = 2;

        // 64ビット整数 数字の後に`L`をつける
        long num3 = 3L;
        Long num4 = 4L;

        // 32ビット浮動小数 数字の後に`f`をつける
        float num5 = 0.1f;
        Float num6 = 0.1f;

        // 64ビット浮動小数
        double num7 = 0.1;
        Double num8 = 0.1;

        // 四則演算

        // 足し算
        System.out.println(num + num); // 2
        System.out.println(num + num2); // 3(後述のアンボクシングが働く)

        // 引き算
        System.out.println(5 -1); // 4

        // 掛け算
        System.out.println(2 * 5); // 10

        // 割り算
        System.out.println(10 / 2); // 5
        // System.out.println(10 / 0); // 0徐算 ArithmeticExceptionが発生する

        // 暗黙的な型変換
        System.out.println(num + num5); // 1.1

        // オートボクシングとアンボクシング
        var list = new ArrayList<Integer>();

        // オートボクシングでintからIntegerに自動変換される
        list.add(1);
        list.add(2);

        // アンボクシングでIntegerからintに自動変換される
        int sum = 0;
        for(int i : list) {
            sum += i;
        }

        // オートボクシングのパフォーマンス影響
        // 毎回Integerインスタンスを生成することになりとてもコストがかかる処理になってしまう
        // IntelliJはこのようなとき警告出してくれるので便利
        Integer sum2 = 0;
        for(var i = 0; i < 1000;i++) {
            sum2 += i;
        }

        // Integerはnullを受け入れるので、以下のようにnullが混入する場合もある
        // 以下の場合、nullのラッパークラスをアンボクシングしようとしてNullPointerExceptionが発生する
//        list.add(null);
//        for(var i : list) {
//            i++; // この処理に特に意味はない
//        }

        // 小数の計算は正確には表現できない
        // プログラムにおける小数は近似値でしかなく以下のような誤差が生じてしまう
        // お金の計算のような誤差が許されないような計算をする場合はBigDecimalを利用する
        System.out.println(1.00 - 9 * 0.10); // 0.09999999999999998

        var n1 = new BigDecimal("1.00");
        var n2 = new BigDecimal("9");
        var n3 = new BigDecimal("0.10");

        System.out.println(n1.subtract(n2.multiply(n3))); // 0.10

        // 文字列 -> 数値
        Integer.parseInt("1");
        try {
            Integer.parseInt("a");
        } catch (Exception e) {
            System.out.println(e.getClass()); // class java.lang.NumberFormatException
            System.out.println(e.getMessage()); // For input string: "a"
        }

        // for文
        for(int i = 0; i < 10; i++) {
            System.out.print(i); // 0123456789
        }

        /// 拡張for文
        var list = List.of(1, 2, 3);
        for(var num : list) {
            System.out.print(num); // 123
        }

        var result = calculator.add(1, 2);
        if(result == 3) {
            System.out.println("result is 3!!");
        } else if(result == 5) {
            System.out.println("result is 5!!");
        } else {
            System.out.println("result is other!!");
        }

        /// 三項演算子
        var message = result == 3 ? "result is 3!!" : "result is " + result;
        System.out.println(message);

        // while
        // 123445678910
        var counter = 0;
        while(counter < 10) {
            counter++;
            System.out.print(counter);
        }

        counter = 0;
        System.out.println();

        // 123445678910
        // do-whileは最初に処理ブロックが評価されるので絶対一回は処理が実行される
        // どちらでもいいがｄo-whileでないといけない場面もほとんどないかつ、
        // 条件が最初にきていたほうが読みやすいので前者の書き方推奨
        do {
            counter++;
            System.out.print(counter);
        } while (counter < 10);

        // switch式 Java12
        // switch式は式なので変数に結果を代入できる
        // breakがいらない
        // Java12以降であればswitch式を推奨
        var result3 = calculator.add(1, 2);
        switch (result3) {
            case 0 -> System.out.println("result 0");
            case 1 -> System.out.println("result 1");
            default -> System.out.println("result " + result3);
        }

        var result4 = calculator.add(1,1);
        var result5 = switch (result4) {
            case 0 -> 0;
            case 1, 2 -> result4 * 2;
            default -> result4;
        };

        System.out.println(result5); // 4

        // 配列

        // 初期化1　配列のサイズを指定 この場合はサイズ5でnullが格納される
        var strArr = new String[5];

        // 初期化2 宣言と同時に初期値を指定
        strArr = new String[]{"a", "b", "c"};

        var arr = new int[2];

        // 配列への書き込み
        arr[0] = 1;
        arr[1] = 2;

        // 配列の読み込み
        System.out.printf("arr[0]: %d arr[1]: %d%n", arr[0], arr[1]); // arr[0]: 1 arr[1]: 2

        // 配列のサイズを超えた要素にアクセスするとエラー
        try{
            arr[2] = 3;
        } catch(IndexOutOfBoundsException e) {
            System.out.println("サイズを超えた要素にアクセスするとエラー");
        }

        // 配列のループ
        for(var i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        for(var num : arr) {
            System.out.println(num);
        }

        // 多次元配列
        var matrix = new int[][] {
                {1, 2, 3},
                {1, 2, 3},
                {1, 2, 3},
        };

        System.out.println("---------------------------------------------------");

        // List
        // Listはインターフェースで実際の実装クラスがある
        // 代表的なのがArrayListでLinkedListといったクラスもある
        var arrayList = new ArrayList<Integer>();
        var linkedList = new LinkedList<Integer>();

        // 追加
        arrayList.add(1);
        arrayList.add(2);

        // 取得
        System.out.println(arrayList.get(1)); // 2

        // 削除
        System.out.println(arrayList); // [1,2]
        arrayList.remove(1);
        System.out.println(arrayList); // [1]

        // contains
        if(arrayList.contains(1)) {
            System.out.println("arrayList contains `1`");
        }

        // isEmpty
        arrayList.clear();
        if (arrayList.isEmpty()) {
            System.out.println("arrayList is empty");
        }

        // immutableList
        List<Integer> immutableList = List.of(1, 2, 3);
        try {
            immutableList.add(4);
        }catch (UnsupportedOperationException e) {
            System.out.println("イミュータブルListは変更できないよ");
        }

        // sort
        var sortList = new ArrayList<>(List.of(2, 3, 1));
        System.out.println(sortList); // [2, 3, 1]
        Collections.sort(sortList); // 自然な順序でソート
        System.out.println(sortList); // [1, 2, 3]

        // 匿名クラスでComparatorインターフェースのcompareメソッドを実装する
        sortList.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o2, o1);
            }
        });
        System.out.println(sortList); // [3, 2, 1]

        // ラムダ式
        sortList.sort((o1, o2) -> Integer.compare(o1, o2));
        System.out.println(sortList); // [1, 2, 3]
        // メソッド参照
        sortList.sort(Comparator.comparingInt(o -> o));

        // Set
        var set = new HashSet<Integer>();
        var linkedHashSet = new LinkedHashSet<Integer>();
        var treeSet = new TreeSet<Integer>();
        
        var immutableSet = Set.of(1, 2, 3);
        
        // Map
        var map = new HashMap<String, String>();
        var linkedHashMap = new LinkedHashMap<String, String>();
        var treemap = new TreeMap<String, String>();
        
        var immutableMap = Map.of("key1", 1, "key2", 2);

package org.example;

public class ClassDemo {
    public static class User {
        // プロパティ
        private String name;
        private int age;

        // コンストラクタ
        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }

        // getter / setter
        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }

        public String hello() {
            return "Hello, " + this.name;
        }
    }

    public static void demo() {
        var user = new User("Tanaka", 20);
        System.out.println(user);
        System.out.println(user.hello());
    }
}

package org.example;

public abstract class AbstractUser {
    private String name;
    private int age;

    protected AbstractUser(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String hello() {
        return "Hello, " + this.name;
    }

    public abstract String greet();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public interface Greetor {
    void greet();

    // 定数 public static finalは省略できる
    String HELLO = "Hello";

    // デフォルト実装
    default void hello() {
        System.out.println(HELLO + "!!");
        greet();
    }
}

package org.example;

import java.util.EnumSet;
import java.util.Optional;
import java.util.regex.Pattern;

public class ConstantsDemo {
    // 定数
    public static final String MESSAGE_1 = "Hello, World!!";
    // Patternオブジェクトなんかは毎回インスタンス化せずに定数で宣言しておく方が
    // 毎回インスタンスを生成せずに済むため効率が良いことが多い
    public static final Pattern MOBILE_PHONE_PATTERN = Pattern.compile("^\\d{3}-\\d{4}-\\d{4}$");

    // enum
    enum StatusCode {
        OK(200, "Success"),
        NOT_FOUND(404, "Not Found")
        ;

        // フィールド
        private final int code;
        private final String message;

        // コンストラクタ
        StatusCode(int code, String message) {
            this.code = code;
            this.message = message;
        }

        // code -> enum
        public static Optional<StatusCode> codeOf(int code) {
            return EnumSet.allOf(StatusCode.class).stream().filter(sc -> sc.code == code).findFirst();
        }
    }

    public static void demo() {
        System.out.println(MESSAGE_1); // Hello, World!!

//        MESSAGE_1 = ""; 定数なので値の上書きはできない、不変

        System.out.println(StatusCode.OK);
        System.out.println(StatusCode.NOT_FOUND);

        StatusCode.codeOf(200).ifPresent(System.out::println);
        StatusCode.codeOf(404).ifPresent(System.out::println);
        StatusCode.codeOf(500).ifPresentOrElse(System.out::println, () -> {
            throw new IllegalArgumentException("サポートしていないステータスコードです");
        });
    }
}

public record Example(String str, int num) {
}

var ex = new Example("example", 1);

    record User(long id, String name, int age) {
        // staticイニシャライザ
        static {
            System.out.println("static");
        }

        // staticメソッド
        public static void hello() {
            System.out.println("Hello");
        }

        // staticフィールド
        public static final String HELLO = "Hello";

        // コンパクトコンストラクタ
        public User {
            System.out.println("id "+id+" age "+age);
        }

        // 普通に関数の定義
        public User newUser() {
            return new User(this.id, this.name, this.age);
        }
    }

public class StreamDemo {
    private interface Reader {
        void read();
    }

    public static void demo() {
        // 匿名クラス
        Reader r = new Reader() {
            @Override
            public void read() {
                // 何か読み出し処理
                System.out.println("何か読み出しの処理をしました");
            }
        };
        r.read();
    }
}

        // 実際は以下のように特定のインターフェースを引数に取る関数
        // を呼び出す場合に使うことが多いでしょう
        useReaderFunc(new Reader() {
            @Override
            public void read() {
                // 何か読み出し処理
                System.out.println("何か読み出しの処理をしました");
            }
        });

    public static void demo() {
        // 匿名クラス
        Reader r = new Reader() {
            @Override
            public void read() {
                // 何か読み出し処理
                System.out.println("何か読み出しの処理をしました");
            }
        };
        r.read();

        // 実際は以下のように特定のインターフェースを引数に取る関数
        // を呼び出す場合に使うことが多いでしょう
        useReaderFunc(new Reader() {
            @Override
            public void read() {
                // 何か読み出し処理
                System.out.println("何か読み出しの処理をしました");
            }
        });

        // Runnable run: () -> void
        // 引数も戻り値もなし
        new Runnable() {
            @Override
            public void run() {
            }
        }.run();

        // Predicate<T> test: T -> boolean
        // 引数を一つ取りbooleanを返す関数
        new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return false;
            }
        }.test("test");

        // Consumer<T> accept: T -> void
        // 引数を一つ取り戻り値はなしの関数
        new Consumer<String>() {
            @Override
            public void accept(String s) {

            }
        }.accept("test");

        // Function<T, R> apply: T -> R
        // 引数を一つ受け取り結果を返す関数
        new Function<String, String>() {
            @Override
            public String apply(String s) {
                return "";
            }
        }.apply("test");

        // Supplier<T> get: () -> T
        new Supplier<String>() {

            @Override
            public String get() {
                return "";
            }
        }.get();

        // UnaryOperator<T> apply: T -> T
        // 引数を一つ取り同じ型の値を返す関数
        new UnaryOperator<String>() {
            @Override
            public String apply(String s) {
                return "";
            }
        }.apply("test");

        // BinaryOperator<T, T> apply: T, T -> T
        // 同じ型の引数を二つ受け取り、同じ型の値を返す関数
        new BinaryOperator<String>() {
            @Override
            public String apply(String s, String s2) {
                return "";
            }
        }.apply("test", "test");

        //BiFunction<T, R, U> apply: T, R -> U
        // 二つの引数を受け取り、結果を1つ返す関数
        new BiFunction<String, Integer, Boolean>() {
            @Override
            public Boolean apply(String s, Integer integer) {
                return null;
            }
        }.apply("test", 1);
        
        // BiConsumer<T, R> accept: T, R -> void
        // 引数を二つ受け取り、値は返さない関数
        new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer integer) {
                
            }
        }.accept("test", 1);
        
        // BiPredicate<T, R> test: T, R -> boolean
        // 引数を2つ受け取り、booleanを返す関数
        new BiPredicate<String, Integer>() {
            @Override
            public boolean test(String s, Integer integer) {
                return false;
            }
        }.test("test", 1);
    }

        new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return false;
            }
        }.test("test");
        
        ((Predicate<String>) s -> false).test("test");

        useReaderFunc(new Reader() {
            @Override
            public void read() {
                // 何か読み出し処理
                System.out.println("何か読み出しの処理をしました");
            }
        });

        // ラムダ式
        useReaderFunc(() -> System.out.println("ラムダ式で実装しました"));

        // sorted()は関数型インターフェースであるComparatorを引数にとるため以下のようにラムダ式で書ける
        // Comparatorはcompare: T, T -> int という抽象メソッドのみを持つ関数型インターフェース
        // compareが返す整数値によってListなどの並び替えをする
        var l = Stream.of(2, 3).sorted((Integer s1, Integer s2) -> {
            return s2 - s1;
        });

        var l = Stream.of(2, 3).sorted((s1, s2) -> {
            return s2 - s1;
        });

        var l = Stream.of(2, 3).sorted((s1, s2) -> s2 - s1);

        l = Stream.of(2, 2, 3).filter((Integer num) -> num > 2);

        // 型も型推論が効くので省略できる
        l = Stream.of(2, 2, 3).filter(num -> num > 2);

        Optional.empty().orElseThrow(() -> new RuntimeException("値が存在しません"));

        Function<String, Integer> f = Integer::parseInt;
        f = str -> Integer.parseInt(str);

String str = "Hello";
Supplier<Integer> lengthSupplier = str::length;

        Function<String, String> toUpperCase = String::toUpperCase;
        toUpperCase.apply("aaa");
        // これと同義
        toUpperCase = s -> s.toUpperCase();

        class MyClass {
            private final String id;
            MyClass(String id) {
                this.id = id;
            }

            public String getId() {
                return this.id;
            }
        }

        Stream.of(1, 2, 3)
                .map(String::valueOf)
                .map(MyClass::new)
                .forEach(mc -> System.out.println(mc.getId()));

        Stream.of("aaa", "bbb", "ccc");
        Stream.empty();

        Stream.builder()
                .add(1)
                .add(2)
                .build();

        // 無限シーケンス
        Stream.iterate(0, num -> num + 1);
        var r = new Random();
        Stream.generate(r::nextInt);

        IntStream.range(0, 100);

        IntStream.rangeClosed(0, 10)
                .filter(n -> n % 2 == 0)
                .forEach(System.out::println);
        
        IntStream.rangeClosed(0, 10)
                .map(n -> n * 2)
                .forEach(System.out::println);

        IntStream.rangeClosed(0, 10)
                .sum();
        
        Stream.of(1, 2, 3).toList();

public class OuterClass {
    public class MemberClass {

    }
}

        // メンバークラス
        var outer = new OuterClass();
        var member = outer.new MemberClass();

public class OuterClass {
    public void hello() {
        final var text = "Hello!!";

        // スコープは関数内になるため
        // 可視性の修飾子はつけれない
        class LocalClass {
            public void print() {
                System.out.println(text);
            }
        }

        new LocalClass().print();
    }
}

public class OuterClass {
    public class MemberClass {

    }

    static public class StaticClass {
        {
            // 外側の非staticなフィールドにはアクセスできない
            // のでこれはコンパイルエラーになる
            var m = new MemberClass();
        }
    }
}

        // 静的クラス
        var s= new OuterClass.StaticClass();

public sealed interface Color {
    record Red() implements Color {}
    record Blue() implements Color {}
    record Green() implements Color {}

    record Rgb(int red, int blue, int green) implements Color {
        @Override
        public String toString() {
            return "(%d,%d,%d)".formatted(this.red, this.blue, this.green);
        }
    }
}

public sealed class Color {
    static final public class Red extends Color {}
    static final public class Blue extends Color {}
    static final public class Green extends Color {}
    
    static final public class Rgb extends Color {
        public final int red;
        public final int blue;
        public final int green;
        
        public Rgb(int red, int blue, int green) {
            this.red = red;
            this.blue = blue;
            this.green = green;
        }
        
        @Override
        public String toString() {
            return "(%d,%d,%d)".formatted(this.red, this.blue, this.green);
        }
    }
}

// この場合permitsは省略可能
public sealed interface Color permits Color.Red, Color.Blue, Color.Green, Color.Rgb {
    record Red() implements Color {}
    record Blue() implements Color {}
    record Green() implements Color {}

    record Rgb(int red, int blue, int green) implements Color {
        @Override
        public String toString() {
            return "(%d,%d,%d)".formatted(this.red, this.blue, this.green);
        }
    }
}

        var color = getColor("rgb", /* red = */255, /* green = */255, /* blue = */255);
        switch(color) {
            case Color.Red ignored -> System.out.println("red");
            case Color.Blue ignored -> System.out.println("blue");
            case Color.Green ignored -> System.out.println("green");
            case Color.Rgb rgb -> System.out.println("rgb: "+rgb);
//            default -> throw new IllegalStateException("Unexpected value: " + color);
        }
    }

    private static Color getColor(String str, Integer red, Integer green, Integer blue) {
        return switch (str) {
            case "Red", "red" -> new Color.Red();
            case "Green", "green" -> new Color.Green();
            case "Blue", "blue" -> new Color.Blue();
            case "RGB", "rgb" -> new Color.Rgb(
                    red != null ? red : 0,
                    green != null ? green : 0,
                    blue != null ? blue : 0
            );
            case null, default -> throw new IllegalStateException("Unexpected value: " + str);
        };
    }

public class ErrorDemo {
    private static void throwRuntimeException() {
        throw new RuntimeException("runtime exception");
    }

    private static void throwCheckedException() throws Exception {
        throw new Exception("checked exception");
    }

    public static void demo() {
        // RuntimeExceptionはtry-catchは不要
        // throwRuntimeException();

        // 検査例外はtry-catchするか呼び出し元に例外を伝搬する必要がある
        try {
            throwCheckedException();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

        try {
            throwCheckedException();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        } finally {
            System.out.println("Complete!!");
        }

    record User(long id){}

    static class NotSpecifyIdException extends RuntimeException {
        public NotSpecifyIdException() {
            super();
        }

        public NotSpecifyIdException(String message) {
            super(message);
        }

        public NotSpecifyIdException(String message, Throwable cause) {
            super(message, cause);
        }
    }

    static class NotFoundUserException extends Exception {
        private final long id;

        public NotFoundUserException(long id) {
            super();
            this.id = id;
        }

        public NotFoundUserException(long id, String message) {
            super(message);
            this.id = id;
        }

        public NotFoundUserException(long id, String message, Throwable cause) {
            super(message, cause);
            this.id = id;
        }

        @Override
        public String getMessage() {
            return super.getMessage() + " id: " + this.id;
        }
    }

    private static User findUser(Long id) throws NotFoundUserException {
        if(id == null) {
            throw new NotSpecifyIdException("IDの指定がなければ実行時例外をスローする");
        } else if(id != 1) {
            throw new NotFoundUserException(id, "ユーザーが見つかりませんでした");
        } else {
            return new User(id);
        }
    }

    testImplementation("org.assertj:assertj-core:3.26.3")

import static org.assertj.core.api.Assertions.*;

        assertThat(1 + 1).isEqualTo(2);

package org.example;

public class Caluculator {
    public enum Operator {
        ADD, SUBTRACT, MULTIPLE, DIVIDE;
    }

    private Operator operator;

    public Caluculator(Operator operator) {
        this.operator = operator;
    }

    public double calculate(int x, int y) {
        return switch (this.operator) {
            case ADD -> x + y;
            case SUBTRACT -> x - y;
            case MULTIPLE -> x * y;
            case DIVIDE -> (double) x / y;
        };
    }
}

package org.example;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import static org.assertj.core.api.Assertions.*;

public class CalculatorTest {
    @Test
    @DisplayName("1 + 1 = 2")
    void addTest() {
        var sut = new Caluculator(Caluculator.Operator.ADD);
        var act = sut.calculate(1, 1);
        assertThat(act).isEqualTo(2);
    }
}

package org.example;

import org.junit.jupiter.api.*;

import static org.assertj.core.api.Assertions.*;

public class CalculatorTest {
    @BeforeAll
    static void init() {
        System.out.println("BeforeAll");
    }

    @BeforeEach
    void setup() {
        System.out.println("BeforeEach");
    }

    @AfterAll
    static void finish() {
        System.out.println("AfterAll");
    }

    @AfterEach
    void teardown() {
        System.out.println("AfterEach");
    }

    @Test
    @DisplayName("1 + 1 = 2")
    void addTest() {
        var sut = new Caluculator(Caluculator.Operator.ADD);
        var act = sut.calculate(1, 1);
        assertThat(act).isEqualTo(2).satisfies(value -> System.out.println("act: " + value + " expect: " + 2));
    }

    @Test
    @DisplayName("3 - 1 = 2")
    void subtractTest() {
        var sut = new Caluculator(Caluculator.Operator.SUBTRACT);
        var act = sut.calculate(3, 1);
        assertThat(act).isEqualTo(2).satisfies(value -> System.out.println("act: " + value + "expect: " + 2));
    }
}

BeforeAll
BeforeEach
act: 2.0 expect: 2
AfterEach
BeforeEach
act: 2.0expect: 2
AfterEach
AfterAll

        assertThat("AssertJ")
                .isNotNull()
                .startsWith("Assert")
                .endsWith("J");

        record User(String name, int age){}
        var user = new User("user", 30);

        // テストの説明追記
        // [check user's age]
        // expected: 20
        // but was: 30
       assertThat(user.age).as("check %s's age", user.name).isEqualTo(20);

        var str = "test";
        assertThat(str).isNotNull();
        // 空文字ではない
        assertThat(str).isNotEmpty();
        // 空文字もしくは空白のみではない
        assertThat(str).isNotBlank();
        assertThat(str).startsWith("te");
        assertThat(str).endsWith("st");
        assertThat(str).isEqualTo("test");
        assertThat(str).contains("es");
        assertThat(str).matches(Pattern.compile("^[a-z]{4}$"));

        var num = 2;
        assertThat(num).isLessThan(5);
        assertThat(num).isGreaterThan(1);
        assertThat(num).isPositive();

        var list = List.of("a", "b", "c");
        assertThat(list).contains("b").doesNotContain("d");
        assertThat(list).allMatch(elm -> elm.length() == 1);
        assertThat(list).anyMatch(elm -> Objects.equals(elm, "b"));

        var map = Map.of("key1", 1, "key2", 2, "key3", 3);
        assertThat(map).contains(Map.entry("key2", 2));
        assertThat(map).isNotEmpty();

        class SomethingThrow {
            static void throwEx() throws OperationNotSupportedException {
                throw new OperationNotSupportedException("この関数は実行できません");
            }
        }

        assertThatThrownBy(SomethingThrow::throwEx)
                .hasMessage("この関数は実行できません")
                .isInstanceOf(OperationNotSupportedException.class);

    @TestFactory
    Stream<DynamicTest> calculatorTest() {
        record Case(String name, int x, int y, Caluculator.Operator operator, double expected){}
        List<Case> tests = List.of(
                new Case("1 + 2 = 3", 1, 2, Caluculator.Operator.ADD, 3.0),
                new Case("5 - 3 = 2", 5, 3, Caluculator.Operator.SUBTRACT, 2.0),
                new Case("5 * 2 = 10", 5, 2, Caluculator.Operator.MULTIPLE, 10.0),
                new Case("6 / 3 = 2", 6, 3, Caluculator.Operator.DIVIDE, 2.0)
        );

        return tests.stream().map(t -> DynamicTest.dynamicTest(t.name, () -> {
            var sut = new Caluculator(t.operator);
            assertThat(sut.calculate(t.x, t.y)).isEqualTo(t.expected);
        }));
    }

    @ParameterizedTest
    @ValueSource(ints = { 2, 4, 6, 8 })
    void evenTest(int num) {
        assertThat(num % 2).isZero();
    }

    @ParameterizedTest
    @NullAndEmptySource
    @ValueSource(strings = { " ", "  ", "\t", "\n" })
    void nullEmptyAndBlankStrings(String text) {
        assertThat(text == null || text.trim().isEmpty()).isTrue();
    }

    @ParameterizedTest
    @EnumSource
    void operatorTest(Caluculator.Operator op) {
        assertThat(op).isNotNull();
    }

    @ParameterizedTest
    @MethodSource("range")
    void testWithRangeMethodSource(int argument) {
        assertThat(argument).isNotEqualTo(9);
    }

    static IntStream range() {
        return IntStream.range(0, 20).skip(10);
    }

    @ParameterizedTest
    @MethodSource("CalculatorProvider")
    void calculatorMethodSourceTest(int x, int y, Caluculator.Operator operator, double expected) {
        var sut = new Caluculator(operator);
        assertThat(sut.calculate(x, y)).isEqualTo(expected);
    }

    static Stream<Arguments> CalculatorProvider() {
        return Stream.of(
                Arguments.arguments(1, 2, Caluculator.Operator.ADD, 3.0),
                Arguments.arguments(5, 3, Caluculator.Operator.SUBTRACT, 2.0),
                Arguments.arguments(5, 2, Caluculator.Operator.MULTIPLE, 10.0),
                Arguments.arguments(6, 3, Caluculator.Operator.DIVIDE, 2.0)
        );
    }

    @ParameterizedTest
    @FieldSource
    void oddPattern(Integer num) {
        assertThat(num % 2).isEqualTo(1);
    }

    static final List<Integer> oddPattern = List.of(
            1, 3, 5, 7, 9
    );

    @ParameterizedTest
    @CsvSource({
            "1, 1, 2",
            "2, 3, 5",
            "0, 1, 1",
            "-2, 2, 0",
    })
    void addTest(int x, int y, double expected) {
        var sut = new Caluculator(Caluculator.Operator.ADD);
        assertThat(sut.calculate(x, y)).isEqualTo(expected);
    }

   @ParameterizedTest
    @CsvSource(textBlock = """
        1, 1, 2
        2, 3, 5
        0, 1, 1
        -2, 2, 0
    """)
    void addTest(int x, int y, double expected) {
        var sut = new Caluculator(Caluculator.Operator.ADD);
        assertThat(sut.calculate(x, y)).isEqualTo(expected);
    }

    @ParameterizedTest
    @CsvSource(useHeadersInDisplayName = true, textBlock = """
        x, y, expected
        1, 1, 2
        2, 3, 5
        0, 1, 1
        -2, 2, 0
    """)
    void addTest(int x, int y, double expected) {
        var sut = new Caluculator(Caluculator.Operator.ADD);
        assertThat(sut.calculate(x, y)).isEqualTo(expected);
    }

    @ParameterizedTest
    @CsvFileSource(resources = "/add-test-parameters.csv", useHeadersInDisplayName = true)
    void addTestWithCSVFile(int x, int y, double expected) {
        var sut = new Caluculator(Caluculator.Operator.ADD);
        assertThat(sut.calculate(x, y)).isEqualTo(expected);
    }

    @ParameterizedTest
    @ArgumentsSource(FruitArgumentsProvider.class)
    void fruitTest(String fruit) {
        assertThat(fruit).isNotEqualTo("orange");
    }

    public static class FruitArgumentsProvider implements ArgumentsProvider {

        @Override
        public Stream<? extends Arguments> provideArguments(ExtensionContext context) throws Exception {
            return Stream.of("apple", "banana").map(Arguments::of);
        }
    }

package org.example;

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpServer;

import java.io.IOException;
import java.net.InetSocketAddress;

public class Server {
    public static void start() throws IOException {
        var server = HttpServer.create(new InetSocketAddress(8080), 0);

        // "/hello" へのリクエストを処理するハンドラーを設定
        server.createContext("/hello", (HttpExchange exchange) -> {
            // レスポンスの内容を設定
            var response = "Hello, World!";
            exchange.sendResponseHeaders(200, response.getBytes().length);

            // レスポンスをクライアントに送信
            try(var os = exchange.getResponseBody()) {
                os.write(response.getBytes());
            }
        });

        // デフォルトのスレッドプールを使ってサーバーを起動
        server.setExecutor(null); // null はデフォルトの executor を使用することを意味する
        server.start();

        System.out.println("Server started on port 8080");
    }
}

package org.example;

import java.io.IOException;
import java.net.Authenticator;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpClient.*;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.stream.IntStream;

import static java.net.HttpURLConnection.HTTP_OK;

public class HttpClientDemo {
    public static void demo() {
        try(var client = HttpClient.newBuilder()
                .version(Version.HTTP_1_1)
                .followRedirects(Redirect.NORMAL)
                .connectTimeout(Duration.ofSeconds(20))
//                .authenticator(Authenticator.getDefault())
                .build()) {

            var req = HttpRequest.newBuilder()
                    .uri(URI.create("https://example.com"))
                    .timeout(Duration.ofMinutes(2))
//                    .header("Content-Type", "application/json")
                    .build();

            // 同期通信
            HttpResponse<String> response = client.send(req, HttpResponse.BodyHandlers.ofString());
            System.out.println(response.statusCode());
            System.out.println(response.body());

            // 非同期通信
            var futures = IntStream.range(0, 3).mapToObj(i -> {
                var req2 = HttpRequest.newBuilder()
                        .uri(URI.create("https://example.com"))
                        .header("Count", String.valueOf(i))
                        .timeout(Duration.ofMinutes(2))
                        .build();

                return client.sendAsync(req2, HttpResponse.BodyHandlers.ofString());
            }).toList();

            CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).get();

            for (var future : futures) {
                var res = future.get();
                if (res.statusCode() == HTTP_OK) {
                    System.out.println("Success!!");
                    System.out.println("count: " + res.request().headers().firstValue("Count").orElse(""));
                }
            }

        } catch (IOException | InterruptedException | ExecutionException e) {
            throw new RuntimeException(e);
        }

    }
}

public class FileDemo {
    public static void demo() throws IOException {
        try(
                var is = FileDemo.class.getClassLoader().getResourceAsStream("test.txt");
                var isr = new InputStreamReader(Objects.requireNonNull(is));
                var bsr = new BufferedReader(isr, 1024);
        ){
//            var bytes = is.readAllBytes();
//            System.out.println(new String(bytes));

            var sb = new StringBuilder();
            String line;
            while((line = bsr.readLine()) != null) {
                sb.append(line);
                sb.append(System.lineSeparator());
            }
            System.out.println(sb);
        }
    }
}

var scanner = new Scanner();
var input = scanner.nextLine();

package org.example;

import java.util.*;

public class SystemInDemo {
    private static final List<Integer> CHOICES = List.of(1, 2, 3);

    public static void demo() {
        try(var s = new Scanner(System.in)) {
            System.out.println("じゃーんけーん");
            System.out.println("1. 👊");
            System.out.println("2. ✌️");
            System.out.println("3. ✋");

            int input;
            while (true) {
                try {
                    input = s.nextInt();
                    if (CHOICES.contains(input)) {
                        break;
                    }
                }catch (InputMismatchException ignored) {
                    // 入力をクリア
                    s.nextLine();
                }

                System.out.println("1-3で選んでください");
                System.out.println("じゃーんけーん");
            }

            System.out.println("ぽん！");

            var rand = new Random();
            var choice = CHOICES.get(rand.nextInt(3));

            System.out.println("あなたの手: " + displayChoice(input));
            System.out.println("わたしの手: " + displayChoice(choice));

            switch (input) {
                case 1 -> {
                    if(choice == 1) {
                        System.out.println("あいこです");
                    } else if(choice == 2) {
                        System.out.println("あなたの勝ちです");
                    } else {
                        System.out.println("あなたの負けです");
                    }
                }
                case 2 -> {
                    if(choice == 1) {
                        System.out.println("あなたの負けです");
                    } else if(choice == 2) {
                        System.out.println("あいこです");
                    } else {
                        System.out.println("あなたの勝ちです");
                    }
                }
                case 3 -> {
                    if(choice == 1) {
                        System.out.println("あなたの勝ちです");
                    } else if(choice == 2) {
                        System.out.println("あなたの負けです");
                    } else {
                        System.out.println("あいこです");
                    }
                }
            }
        }

    }

    private static String displayChoice(int choice) {
        return switch (choice) {
            case 1 -> "👊";
            case 2 -> "✌️";
            case 3 -> "✋";
            default -> throw new IllegalStateException("Unexpected value: " + choice);
        };
    }
}