Java 24 Stream Gatherers ve Class-File API Yenilikleri: JEP 485 ile Custom Intermediate Operations Rehberi (2026)

Java 24 Genel Bakış (Java 24 Overview)

Java 24, 18 Mart 2025'te resmi olarak yayınlandı (officially released on March 18, 2025). Üç ayda bir gelen Java release döngüsünde olağanüstü dolu bir sürüm — toplam 24 JEP (Java Enhancement Proposal) içeriyor. Bunlardan en dikkat çekici olanları:

• ✅ JEP 485: Stream Gatherers (finalize)
• ✅ JEP 484: Class-File API (finalize)
• ✅ JEP 491: Synchronize Virtual Threads without Pinning
• ✅ JEP 496/497: Quantum-Resistant Algorithms (ML-KEM, ML-DSA)
• ✅ JEP 487: Scoped Values (preview 2)
• ✅ JEP 488: Primitive Types in Patterns (preview)
• ✅ JEP 478: Key Derivation Function API

Stream Gatherers API (JEP 485)

Stream Gatherers, Java 22'de preview, Java 23'te second preview olarak gelmiş, Java 24'te finalize edilmiş bir özellik. Amacı: mevcut intermediate operation'larla (map, filter, flatMap vb.) yapılması zor olan custom transformation'ları (özel dönüşümleri) basit bir API ile sağlamak.

Klasik Stream'de eksik olan neydi? Şu örneklere bakın:

• 🟡 Sliding window: Ardışık 3'lü gruplar oluşturmak
• 🟡 Fixed grouping: Her 5 elemanı bir araya getirmek (chunk)
• 🟡 Running aggregate: Kümülatif toplam akışı
• 🟡 Deduplication with state: Sıralı duplicate kaldırma

Bunlar mevcut API'de ya mümkün değildi ya da çok zahmetli idi. Gatherers ile artık tek satırda yazılabiliyor.

import java.util.stream.Gatherers;
import java.util.stream.Stream;

// 1. Sliding window (3'lü ardışık gruplar)
List<List<Integer>> windows = Stream.of(1, 2, 3, 4, 5)
    .gather(Gatherers.windowSliding(3))
    .toList();
// [[1,2,3], [2,3,4], [3,4,5]]

// 2. Fixed grouping (5'er paketler)
List<List<Integer>> chunks = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    .gather(Gatherers.windowFixed(5))
    .toList();
// [[1,2,3,4,5], [6,7,8,9,10]]

// 3. Fold (running aggregate)
List<Integer> cumulative = Stream.of(1, 2, 3, 4, 5)
    .gather(Gatherers.fold(() -> 0, Integer::sum))
    .toList();
// [1, 3, 6, 10, 15]

// 4. Scan
List<String> scanned = Stream.of("a", "b", "c")
    .gather(Gatherers.scan(() -> "", String::concat))
    .toList();
// ["a", "ab", "abc"]

Custom Gatherer Yazma (Writing Custom Gatherers)

Built-in gatherers'ın ötesinde, kendi gatherer'ınızı yazabilirsiniz. Alesta Web rehberinde sıkça karşılaşılan bir senaryoyu örnekleyelim: art arda tekrar eden değerleri tek sefere indirgemek (consecutive distinct).

import java.util.stream.Gatherer;

public class Gatherers2 {

    public static <T> Gatherer<T, ?, T> distinctConsecutive() {
        return Gatherer.ofSequential(
            // initializer: previous value holder
            () -> new Object[]{null},

            // integrator: her eleman için çağrılır
            (state, element, downstream) -> {
                if (!java.util.Objects.equals(state[0], element)) {
                    state[0] = element;
                    return downstream.push(element);
                }
                return true;
            }
        );
    }
}

// Kullanım:
List<Integer> result = Stream.of(1, 1, 2, 2, 2, 3, 1, 1, 4)
    .gather(Gatherers2.distinctConsecutive())
    .toList();
// [1, 2, 3, 1, 4]

Gatherer'ın dört bileşeni var:

1. Initializer: Per-stream durum başlangıcı
2. Integrator: Her element için çalışır (push downstream)
3. Combiner: Parallel stream'de state birleştirme
4. Finisher: Stream bittiğinde son işlem

Class-File API: Bytecode Standart Oldu (Standard Bytecode API)

JEP 484 ile Class-File API Java 24'te finalize oldu. Bu API, Java bytecode okumak, yazmak ve modifiye etmek için standart, immutable, modern bir API sunuyor. Daha önce bunun için ASM, BCEL, Javassist gibi third-party kütüphanelere ihtiyacımız vardı.

import java.lang.classfile.*;
import java.nio.file.*;

// Bir class dosyasını okuma ve metot adlarını listeleme
Path classPath = Paths.get("MyClass.class");
ClassModel classModel = ClassFile.of().parse(classPath);

System.out.println("Class: " + classModel.thisClass().asInternalName());

for (MethodModel method : classModel.methods()) {
    System.out.println("  Method: " + method.methodName().stringValue() +
                       " " + method.methodType().stringValue());
}

// Yeni class oluşturma (programatik bytecode üretimi)
byte[] bytes = ClassFile.of().build(
    ClassDesc.of("com.example.Generated"),
    classBuilder -> classBuilder
        .withFlags(ClassFile.ACC_PUBLIC)
        .withMethodBody("hello", MethodTypeDesc.of(ConstantDescs.CD_String),
            ClassFile.ACC_PUBLIC | ClassFile.ACC_STATIC,
            codeBuilder -> codeBuilder
                .ldc("Hello from Alesta Web!")
                .areturn())
);

Avantajlar:

• ✅ Standart JDK, third-party dependency yok
• ✅ Modern API (Builder pattern, Stream uyumlu)
• ✅ JDK versiyonu ile birlikte güncellenir (her zaman güncel bytecode)
• ✅ Immutable, thread-safe, lazy parsing

Framework geliştiricileri için kritik: Spring, Hibernate, Quarkus gibi büyük framework'ler kademeli olarak ASM yerine Class-File API'ye geçiyor.

Project Loom: Synchronized + Virtual Threads (JEP 491)

Java 21 LTS ile gelen virtual threads'in tek büyük eksiği vardı: synchronized bloklarda kullanıldıklarında platform thread'i pinleyebiliyorlardı (could pin platform threads). Bu, milyonlarca virtual thread'i destekleme vaadinin önündeki en büyük engeldi.

Java 24 (JEP 491) bu sorunu çözdü. Artık virtual thread'ler synchronized içinde de pin olmadan çalışıyor (no pinning in synchronized blocks).

// Java 21'de SORUN (pinning oluyordu)
public synchronized void handleRequest(Request req) {
    var result = httpClient.send(req);  // ← burada virtual thread pin olurdu
    process(result);
}

// Java 24'te NORMAL DAVRANIR
public synchronized void handleRequest(Request req) {
    var result = httpClient.send(req);  // ← virtual thread park olur, başka task çalışır
    process(result);
}

Quantum-Resistant Algoritmalar (Post-Quantum Cryptography)

Java 24 ile birlikte NIST tarafından standardize edilmiş iki quantum-resistant algoritma JDK'ya geldi:

• 🔐 JEP 496: ML-KEM (Module-Lattice-Based Key Encapsulation) — eski adı CRYSTALS-Kyber
• 🔐 JEP 497: ML-DSA (Module-Lattice-Based Digital Signature) — eski adı CRYSTALS-Dilithium

Quantum computer'ların ileride RSA ve ECDSA gibi mevcut cryptographic algoritmaları kırma riski var. ML-KEM ve ML-DSA bu tehdide karşı dirençli (resistant).

import java.security.*;

// Key generation
KeyPairGenerator kpg = KeyPairGenerator.getInstance("ML-KEM");
kpg.initialize(NamedParameterSpec.ML_KEM_768);
KeyPair kp = kpg.generateKeyPair();

// Encapsulation (göndericinin tarafı)
KEM kem = KEM.getInstance("ML-KEM");
KEM.Encapsulator enc = kem.newEncapsulator(kp.getPublic());
KEM.Encapsulated encapsulated = enc.encapsulate();
byte[] sharedSecret = encapsulated.key().getEncoded();
byte[] ciphertext = encapsulated.encapsulation();

// Decapsulation (alıcının tarafı)
KEM.Decapsulator dec = kem.newDecapsulator(kp.getPrivate());
SecretKey recoveredKey = dec.decapsulate(ciphertext);

Alesta Web notu: Şimdiden post-quantum'a geçmek zorunda değilsiniz, ancak yeni geliştirilecek long-term gizlilik içeren sistemler için (banking, healthcare, government) ML-KEM ve ML-DSA'yı tanımak ve crypto-agility yaklaşımıyla mimari kurmak gerekiyor.

Migration ve Compatibility Notları (Migration Notes)

Java 21 → Java 24 Migration Adımları

# 1. pom.xml / build.gradle güncelle
<maven.compiler.source>24</maven.compiler.source>
<maven.compiler.target>24</maven.compiler.target>

# 2. JDK 24 yükle (SDKMAN)
sdk install java 24-oracle
sdk use java 24-oracle

# 3. Bağımlılıkları güncelle (Spring, Hibernate vb.)
mvn versions:display-dependency-updates

# 4. Test ile çalıştır
mvn clean verify

# 5. Production deploy

Dikkat Edilmesi Gerekenler

• ⚠️ Removed APIs: JNI helper warnings artık error olabilir, native code'u kontrol edin
• ⚠️ Garbage Collector: ZGC generational mode varsayılan; eski GC config'lerini revize edin
• ⚠️ Foreign Memory API: Stable, ancak mevcut MemorySegment kullananları kontrol et
• ⚠️ Pattern Matching: Primitive types preview, üretimde kullanmayın

📚 Kaynaklar ve Referanslar / Sources and References

• OpenJDK 24 Project Page — Resmi proje sayfası
• JEP 485: Stream Gatherers
• JEP 484: Class-File API
• JEP 491: Synchronize Virtual Threads
• Oracle JDK 24 Documentation

Alesta Web olarak Java 24'ün tüm major özelliklerini kendi test ortamlarımızda doğruladık.