import java.lang.classfile.*;
import java.lang.constant.*;
import java.nio.file.*;
import java.io.IOException;

public class ClassRenamer {

    public static void main(String[] args) throws IOException {
        Path sourcePath = Path.of("MyTargetClass.class");
        String newClassName = "MyTargetClass2";
        Path targetPath = Path.of(newClassName + ".class");

        // 元のクラスファイルを解析
        byte[] classBytes = Files.readAllBytes(sourcePath);
        ClassModel originalModel = ClassFile.of().parse(classBytes);

        // 新しいクラス名でクラスビルダーを開始し、元のクラスの全要素を新しいビルダーにコピーする
        byte[] newClassBytes = ClassFile.of().build(ClassDesc.of(newClassName), builder -> {
            for (ClassElement element : originalModel) {
                // 要素がメソッドの場合、コードを変換して追加
                if (element instanceof MethodModel method) {
                    // withMethod で新しいメソッドを構築
                    builder.withMethod(method.methodName(), method.methodType(), method.flags().flagsMask(), methodBuilder -> {
                        // 元のメソッドの属性（アノテーションなど）をコピー
                        for (MethodElement me : method) {
                            if (!(me instanceof CodeModel)) {
                                methodBuilder.with(me);
                            }
                        }

						boolean[] inserted = {false};
						methodBuilder.transformCode(
							method.code().orElseThrow(),
							(codeBuilder, codeElement) -> {
								// フラグが false の場合（＝初回実行時）のみ挿入
								if (!inserted[0]) {
									insertPrintStatement(codeBuilder, ">> Entering method: " + method.methodName().stringValue());
									inserted[0] = true;
								}
								codeBuilder.with(codeElement);
							});
                    });
                } else {
                    builder.with(element);
                }
            }
        });
        // 変換後のバイトコードを新しいファイルに書き出す
        Files.write(targetPath, newClassBytes);

        System.out.println("クラス名を '" + newClassName + "' に変更し、'" + targetPath + "' に保存しました。");
    }

    private static final ClassDesc SYSTEM = ClassDesc.of("java.lang.System");
    private static final ClassDesc PRINT_STREAM = ClassDesc.of("java.io.PrintStream");
    private static final MethodTypeDesc PRINTLN_MTD = MethodTypeDesc.of(ConstantDescs.CD_void, ConstantDescs.CD_String);

    private static void insertPrintStatement(CodeBuilder codeBuilder, String message) {
        codeBuilder.getstatic(SYSTEM, "out", PRINT_STREAM)
			.ldc(message)
			.invokevirtual(PRINT_STREAM, "println", PRINTLN_MTD);
    }
}

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

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Gatherer;
import java.util.stream.Gatherers;
import java.util.stream.Stream;

public class StreamSample {
	public static void main(String[] args) {
		// 1から9までの数値を3つずつのリストにまとめる
		List<List<Integer>> result = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9)
				.gather(Gatherers.windowFixed(3))
				.toList();

		// 実行結果: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
		System.out.println(result);

		// 1から5までの数値を、3つずつのスライディングウィンドウでまとめる
		List<List<Integer>> result2 = Stream.of(1, 2, 3, 4, 5)
				.gather(Gatherers.windowSliding(3))
				.toList();

		// 実行結果: [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
		System.out.println(result2);

		// 数値の累積和を計算する
		List<Integer> result3 = Stream.of(1, 2, 3, 4, 5)
				.gather(Gatherers.scan(() -> 0, (sum, i) -> sum + i))
				.toList();

		// 実行結果: [1, 3, 6, 10, 15]
		System.out.println(result3);

		// カスタムGathererを使用
		List<List<String>> result4 = Stream.of("a", "a", "b", "c", "c", "c", "b", "a")
				.gather(groupConsecutive())
				.toList();

		// 実行結果: [["a", "a"], ["b"], ["c", "c", "c"], ["b"], ["a"]]
		System.out.println(result4);
	}

	/** Stream内の連続する同じ要素をリストにグループ化するGathererを作成 */
	public static <T> Gatherer<T, ?, List<T>> groupConsecutive() {
		return Gatherer.ofSequential(
				// 1. Initializer: 中間状態を保持するコンテナを準備する
				ArrayList::new,

				// 2. Integrator: 各要素を処理する
				(state, element, downstream) -> {
					// stateが空でなく、最後の要素が現在の要素と違う場合、これまでのstateをリストとして下流に流し、stateをクリアする
					if (!state.isEmpty() && !state.getLast().equals(element)) {
						downstream.push(List.copyOf(state));
						state.clear();
					}
					// 現在の要素をstateに追加する
					state.add(element);
					return true;
				},

				// 3. Finisher: 最後の要素グループを処理する
				(state, downstream) -> {
					// Streamの最後に残った要素がstateにあれば、それを下流に流す
					if (!state.isEmpty()) {
						downstream.push(List.copyOf(state));
					}
				});
	}
}

// Create a KDF object for the specified algorithm
KDF hkdf = KDF.getInstance("HKDF-SHA256");

// Create an ExtractExpand parameter specification
AlgorithmParameterSpec params =
    HKDFParameterSpec.ofExtract()
                     .addIKM(initialKeyMaterial)
                     .addSalt(salt).thenExpand(info, 32);

// Derive a 32-byte AES key
SecretKey key = hkdf.deriveKey("AES", params);

// Additional deriveKey calls can be made with the same KDF object