Java 24 major language and API improvements

Path classPath = Path.of("build/classes/java/main/twentyfour/api/ClassFileApi.class");

byte[] classBytes = Files.readAllBytes(classPath);
ClassModel classModel = ClassFile.of().parse(classBytes);

System.out.println("Class name: " + classModel.thisClass().asInternalName());
System.out.println("Method count: " + classModel.methods().size());

classModel.methods().forEach(method ->
    System.out.println("Method: " + method.methodName().stringValue())
);

ClassDesc helloWorldClass = ClassDesc.of("HelloWorld");

byte[] classBytes = ClassFile.of()
    .build(helloWorldClass, classBuilder -> {
      classBuilder
          .withFlags(ACC_PUBLIC)
          .withMethod("main", MethodTypeDesc.of(CD_void, CD_String.arrayType()),
              ACC_PUBLIC | ACC_STATIC, methodBuilder -> {
                methodBuilder.withCode(codeBuilder -> {
                  codeBuilder
                      .getstatic(ClassDesc.of("java.lang.System"), "out",
                          ClassDesc.of("java.io.PrintStream"))
                      .ldc("Hello from generated class!")
                      .invokevirtual(ClassDesc.of("java.io.PrintStream"), "println",
                          MethodTypeDesc.of(CD_void, CD_String))
                      .return_();
                });
              });
    });
Files.write(Path.of("HelloWorld.class"), classBytes);

Path classPath = Path.of("build/classes/java/main/twentyfour/api/ClassFileApi.class");
byte[] originalBytes = Files.readAllBytes(classPath);

byte[] transformedBytes = ClassFile.of().transformClass(
    ClassFile.of().parse(originalBytes),
    ClassTransform.transformingMethods(
        (methodBuilder, methodElement) -> {
          if (methodElement instanceof CodeAttribute codeAttr) {
            methodBuilder.transformCode(codeAttr,
                CodeTransform.ofStateful(() ->
                    (builder, element) -> {
                      builder.with(element);// pass through
                    })
            );
          } else {
            methodBuilder.with(methodElement);
          }
        }
    )
);
Files.write(Path.of("build/tmp/TransformedClass.class"), transformedBytes);

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6);

List<List<Integer>> pairs = new ArrayList<>();
for (int i = 0; i < numbers.size() - 1; i++) {
    pairs.add(List.of(numbers.get(i), numbers.get(i + 1)));
}

assertEquals(5, pairs.size());
assertEquals(List.of(1, 2), pairs.get(0));
assertEquals(List.of(2, 3), pairs.get(1));

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6);

List<List<Integer>> pairs = numbers.stream()
    .gather(Gatherers.windowSliding(2))
    .toList();

assertEquals(5, pairs.size()); // [1,2], [2,3], [3,4], [4,5], [5,6]
assertEquals(List.of(1, 2), pairs.get(0));
assertEquals(List.of(2, 3), pairs.get(1));

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

List<Integer> batchSums = new ArrayList<>();
List<Integer> currentBatch = new ArrayList<>();

for (Integer number : numbers) {
    currentBatch.add(number);
    if (currentBatch.size() == 3) {
        int sum = currentBatch.stream().mapToInt(Integer::intValue).sum();
        batchSums.add(sum);
        currentBatch.clear();
    }
}
if (!currentBatch.isEmpty()) {
    int sum = currentBatch.stream().mapToInt(Integer::intValue).sum();
    batchSums.add(sum);
}

assertEquals(List.of(6, 15, 24, 10), batchSums); // (1+2+3), (4+5+6), (7+8+9), (10)

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

List<Integer> batchSums = numbers.stream()
    .gather(Gatherers.windowFixed(3))
    .map(batch -> batch.stream().mapToInt(Integer::intValue).sum())
    .toList();

assertEquals(List.of(6, 15, 24, 10), batchSums); // (1+2+3), (4+5+6), (7+8+9), (10)

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

List<Integer> runningSums = new ArrayList<>();
int runningTotal = 0;

for (Integer number : numbers) {
    runningTotal += number;
    runningSums.add(runningTotal);
}

assertEquals(List.of(1, 3, 6, 10, 15, 21, 28, 36, 45, 55), runningSums);

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

Gatherer<Integer, ?, Integer> runningSum = Gatherer.ofSequential(
    () -> new int[]{0}, // state: running total
    Gatherer.Integrator.ofGreedy((state, element, downstream) -> {
        state[0] += element;
        downstream.push(state[0]);
        return true;
    })
);

List<Integer> runningSums = numbers.stream()
    .gather(runningSum)
    .toList();

assertEquals(List.of(1, 3, 6, 10, 15, 21, 28, 36, 45, 55), runningSums);

List<String> sentences = List.of(
    "Java 24 is great",
    "Stream gatherers are useful",
    "Programming is fun"
);

List<String> longWords = sentences.stream()
    .flatMap(sentence -> List.of(sentence.split(" ")).stream())
    .filter(word -> word.length() > 4)
    .toList();

assertEquals(List.of("great", "Stream", "gatherers", "useful", "Programming"), longWords);

        List<String> sentences = List.of(
            "Java 24 is great",
            "Stream gatherers are useful",
            "Programming is fun"
        );

        Gatherer<String, ?, String> splitWords = Gatherer.ofSequential(
            Gatherer.Integrator.ofGreedy((unused, sentence, downstream) -> {
                for (String word : sentence.split(" ")) {
                    downstream.push(word);
                }
                return true;
            })
        );
        
        List<String> longWords = sentences.stream()
            .gather(splitWords)
            .filter(word -> word.length() > 4)
            .toList();

        assertEquals(List.of("great", "Stream", "gatherers", "useful", "Programming"), longWords);
    }
}