romegames 1
romegames
Reklam vermek için turkmmo@gmail.com

Java Stream Yapısı: filter, map, collect ve reduce Mantığı

image453b6030abaaadf7.jpg


Döngü Mantığını Pipeline Yapısına Dönüştürmek

Stream, bir veri kümesi üzerinde işlem yapmayı sağlayan bir aktarım hattıdır (pipeline). Genellikle bir koleksiyonla başlayan bu süreçte; elemanları filtreleme, dönüştürme veya sıralama gibi adım adım işlemler dizisi oluşturulur ve nihayetinde bir sonuç elde edilir. Geçici değişkenler ve if bloklarıyla dolu klasik döngüler yerine, yapılmak istenen adımları sırasıyla belirtir ve veri üzerinde gezinme işini arka plandaki akışa bırakırsınız.

Lambda ifadeleriyle birlikte stream yapısı oldukça pratik bir hal alır: Uygulanan her adım, tek bir veri elemanına nasıl müdahale edileceğini açıklayan bir lambda fonksiyonu ya da metod referansı kabul eder.

Java:
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> names = List.of("Ada", "Boris", "Chen", "Dmitri");

        List<String> result = names.stream()
            .filter(name -> name.length() > 3)   // 3 karakterden uzun isimleri tut
            .map(String::toUpperCase)            // her birini dönüştür
            .collect(Collectors.toList());       // yeni bir listede topla

        System.out.println(result);
    }
}

Yukarıdaki akış incelendiğinde; listedeki veriler çekilir, uzunluğu uygun olanlar süzülür, harfleri büyütülür ve yeni bir listede toplanır. Bu esnada kaynak konumundaki names listesi hiçbir değişime uğramaz. Stream mekanizması mevcut veriyi korur ve tamamen yeni bir çıktı oluşturur.

Bir Stream Pipeline'ının Temel Bileşenleri

Bir akış zinciri üç ana bölümden meydana gelir:

• Veri Kaynağı - Örnek olarak list.stream(), Arrays.stream(array) veya Stream.of(a, b, c) gösterilebilir.
• Ara İşlemler (Sıfır veya daha fazla) - filter, map, sorted, distinct, limit gibi yöntemlerdir. Bunların her biri geriye yeni bir stream döndürür, böylece işlemler birbirine bağlanabilir.
• Sonlandırıcı İşlem (Tam olarak bir adet) - collect, count, forEach, reduce veya findFirst gibi adımlardır. Akışı başlatan, veri işlemesini tetikleyen ve nihai bir sonuç (ya da yan etki) üreten kısımdır.

Bu ayrım, akışların çalışma mantığını anlamak açısından kritik bir kurala dayanır.

Ara İşlemlerde Tembel Çalışma (Lazy Evaluation) İlkesi

Ara adımlar kendi başlarına herhangi bir veri işlemezler; yalnızca hangi adımların uygulanacağını kaydederler. Akış hattı, ancak sonlandırıcı bir işlem çağrıldığında çalışmaya başlar.

Java:
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4);

        nums.stream()
            .map(n -> {
                System.out.println("mapping " + n);
                return n * 2;
            });
        // Terminal işlem yok -> hiçbir şey yazdırılmaz.

        System.out.println("Done, but nothing was mapped.");
    }
}

Kodu çalıştırdığınızda, map içerisindeki lambda ifadesinin hiç tetiklenmediğini görürsünüz. Sürece sonlandırıcı bir adım eklendiğinde ise tüm yapı çalışır hale gelir:

Java:
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4);

        List<Integer> doubled = nums.stream()
            .map(n -> {
                System.out.println("mapping " + n);
                return n * 2;
            })
            .collect(Collectors.toList());   // terminal -> şimdi çalışır

        System.out.println(doubled);
    }
}

Bu tembellik bir eksiklik değil, aksine performansı artıran bir özelliktir; akışın birden fazla adımı birleştirmesine ve gereksiz veri işlemeyi engellemesine olanak tanır. Ancak sonlandırıcı işlem eklenmeyen zincirlerin hiçbir çıktı üretmeyeceğini unutmamak gerekir; bu durum sık yapılan hatalardan biridir.

filter ve map Kullanımı: Ayıklama ve Dönüştürme

Stream işlemlerinde en çok başvurulan iki yöntem filter ve map'tir. filter metodu bir Predicate (boolean sonuç veren lambda) alarak sadece koşula uyan verileri sonraki adıma aktarır. map ise bir Function alarak her bir elemanı yeni bir biçime dönüştürür.

Java:
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> words = List.of("apple", "fig", "banana", "kiwi", "cherry");

        List<Integer> lengths = words.stream()
            .filter(w -> w.length() > 3)   // "fig" ve "kiwi"yi at
            .map(String::length)           // her kelimeyi uzunluğuna çevir
            .collect(Collectors.toList());

        System.out.println(lengths);   // [5, 6, 6]
    }
}

Burada map metodunun veri tipini değiştirebildiğine dikkat edilmelidir; String türündeki akış, Integer türünde bir akışa dönüşmüştür. Kullanılan String::length ifadesi, w -> w.length() lambdasının kısa yoludur.

Sonlandırıcı İşlemler ve Çıktı Üretimi

Stream üzerindeki şekillendirmeler bittiğinde, sonlandırıcı işlem veriyi somut bir nesneye dönüştürür:

Java:
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(3, 1, 4, 1, 5, 9, 2, 6);

        long bigCount = nums.stream()
            .filter(n -> n > 3)
            .count();                       // kaç tanesi geçti?

        boolean anyEven = nums.stream()
            .anyMatch(n -> n % 2 == 0);     // en az bir çift sayı var mı?

        System.out.println("Big numbers: " + bigCount);
        System.out.println("Any even? " + anyEven);
    }
}

Sık tercih edilen sonlandırıcılar şunlardır: collect (verileri bir koleksiyona aktarır), count, forEach, anyMatch / allMatch / noneMatch, findFirst, min / max ve reduce. Sonlandırıcı adım çalıştırıldıktan sonra akış tüketilmiş olur ve tekrar kullanılamaz. Yeni bir işlem yapmak için list.stream() ile yeniden akış başlatılmalıdır.

Elde Edilen Verileri Toplama

Collectors sınıfı ile collect metodu, sonuçları bir araya getirmede kilit rol oynar. En sık kullanılan yöntem Collectors.toList() şeklindedir:

Java:
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> names = List.of("ada", "boris", "chen");

        // Tek bir string'e birleştir
        String joined = names.stream()
            .map(String::toUpperCase)
            .collect(Collectors.joining(", "));

        System.out.println(joined);   // ADA, BORIS, CHEN
    }
}

Ayrıca Collectors vasıtasıyla toSet(), joining(...), groupingBy(...) ve counting() gibi işlevler de kullanılabilir. Java 16 sürümüyle birlikte collect(Collectors.toList()) yerine doğrudan .toList() ifadesi tercih edilebilir (bu yöntem değiştirilemez bir liste sunar):

Java:
List<String> result = names.stream().map(String::toUpperCase).toList();

sorted, distinct ve limit Metodları

Bu ara adımlar, veriler toplanmadan önce akışı düzenlemeye yarar:

Java:
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(5, 3, 8, 3, 1, 9, 5, 2);

        List<Integer> top3 = nums.stream()
            .distinct()                 // yinelenenleri at
            .sorted((a, b) -> b - a)    // azalan
            .limit(3)                   // ilk üçünü al
            .collect(Collectors.toList());

        System.out.println(top3);   // [9, 8, 5]
    }
}

Parametre almayan sorted() kullanımı varsayılan sıralamayı temel alır. Özel bir sıralama mantığı için bir Comparator verilebilir. Büyükten küçüğe sıralamak için Comparator.reverseOrder() pratik bir seçenektir.

reduce: Akıştaki Verileri Tek Bir Değere İndirgeme

Tüm verileri tek bir sonuçta birleştirmek istediğinizde (toplam hesaplama, çarpım bulma veya en uzun metni seçme gibi), reduce yöntemi devreye girer. Bu işlem için bir başlangıç değeri ve iki elemanı birleştiren bir fonksiyon tanımlanır:

Java:
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(2, 4, 6, 8);

        int sum = nums.stream()
            .reduce(0, (a, b) -> a + b);   // 0'dan başla, eklemeye devam et

        int product = nums.stream()
            .reduce(1, (a, b) -> a * b);   // 1'den başla, çarpmaya devam et

        System.out.println("Sum: " + sum);
        System.out.println("Product: " + product);
    }
}

Sayısal verilerin basit toplamı veya ortalaması için özel olarak sunulan akışlar daha pratiktir: nums.stream().mapToInt(Integer::intValue).sum(). Doğrudan hazır bir toplayıcının bulunmadığı karmaşık durumlarda reduce tercih edilmelidir.

Stream Her Senaryo İçin Uygun mudur?

Stream yapısı, bir veri koleksiyonunu işleyip yeni bir çıktıya dönüştürürken mükemmel sonuç verir. Ancak her zaman standart döngülerden daha hızlı çalışmazlar; dış değişkenleri güncellemeniz gereken veya döngüden erken çıkış yapılması gereken durumlarda karmaşık bir hal alabilirler. Eğer veri işleme adımları tek bir akıcı cümle gibi ifade edilebiliyorsa stream kullanılabilir; fakat indeks takibi veya ortak bir sayaç kullanımı gerekiyorsa geleneksel bir for döngüsü yazmak daha anlaşılır ve doğrudur.

Bunun yanında stream nesnelerinin yalnızca bir kez tüketilebileceği unutulmamalıdır. Tüketilmiş bir stream'i tekrar kullanmak hata verir:

Java:
Stream<String> s = names.stream();
s.forEach(System.out::println);
s.count();   // IllegalStateException: stream has already been operated upon

Gelecek Konu: Optional Yapısı

Stream üzerindeki findFirst, min, max veya başlangıç değeri belirtilmeyen reduce gibi bazı sonlandırıcı işlemler bir sonuç bulamayabilir. Bu nedenle doğrudan bir değer dönmek yerine Optional yapısını tercih ederler. Java'da "değer var olabilir veya olmayabilir" durumunu yöneten bu yapı, null dönme problemine güvenli bir alternatif sunar.
 

Şu an konuyu görüntüleyenler (Toplam : 0, Üye: 0, Misafir: 0)

Geri
Üst