(parametreler) -> { ifade gövdesi }

// Geleneksel anonim sınıf
Runnable oldWay = new Runnable() {
    @Override
    public void run() {
        System.out.println("Merhaba Geleneksel Dünya!");
    }
};

// Lambda ifadesi
Runnable newWay = () -> System.out.println("Merhaba Lambda Dünyası!");

oldWay.run();
newWay.run();

Lambda ifadeleri, Java'da fonksiyonel programlamanın kapılarını aralamıştır. Bu sayede daha az satır kodla daha fazla iş yapabiliriz.

Genişletmek için tıkla ...

• Koleksiyonlardan:
  Kod:

  list.stream()

  veya
  Kod:

  list.parallelStream()

• Dizilerden:
  Kod:

  Arrays.stream(array)

• Belirli değerlerden:
  Kod:

  Stream.of("a", "b", "c")

• Dosyalardan:
  Kod:

  Files.lines(path)

• Sonsuz akışlar:
  Kod:

  Stream.iterate(0, n -> n + 2)

  veya
  Kod:

  Stream.generate(Math::random)

• filter(Predicate<T> predicate): Belirli bir koşulu sağlayan öğeleri filtreler.
• map(Function<T, R> mapper): Her öğeyi bir başka türe dönüştürür.
• flatMap(Function<T, Stream<R>> mapper): Birden çok akışı tek bir akışa düzleştirir.
• distinct(): Yinelenen öğeleri kaldırır.
• sorted(): Öğeleri doğal sıralamasına göre veya özel bir karşılaştırıcı ile sıralar.
• limit(long maxSize): Akışın ilk
  Kod:

  maxSize

  öğesini alır.
• skip(long n): Akışın ilk
  Kod:

  n

  öğesini atlar.

• forEach(Consumer<T> action): Akıştaki her öğe üzerinde bir eylem gerçekleştirir.
• collect(Collector<T, A, R> collector): Akıştaki öğeleri bir koleksiyonda toplar. En sık kullanılan toplayıcılar
  Kod:

  Collectors.toList()

  ,
  Kod:

  Collectors.toSet()

  ,
  Kod:

  Collectors.toMap()

  .
• reduce(BinaryOperator<T> accumulator): Akış öğelerini tek bir değere indirger.
• count(): Akıştaki öğe sayısını döndürür.
• min(Comparator<T> comparator): Akıştaki en küçük öğeyi döndürür.
• max(Comparator<T> comparator): Akıştaki en büyük öğeyi döndürür.
• anyMatch(Predicate<T> predicate):, allMatch(Predicate<T> predicate):, noneMatch(Predicate<T> predicate): Akış öğelerinin belirli bir koşulu karşılayıp karşılamadığını kontrol eder.
• findFirst():, findAny(): Akıştaki ilk veya herhangi bir öğeyi döndürür.

class Ogrenci {
    String ad;
    int yas;
    double notOrtalamasi;

    public Ogrenci(String ad, int yas, double notOrtalamasi) {
        this.ad = ad;
        this.yas = yas;
        this.notOrtalamasi = notOrtalamasi;
    }

    public String getAd() { return ad; }
    public int getYas() { return yas; }
    public double getNotOrtalamasi() { return notOrtalamasi; }

    @Override
    public String toString() {
        return "Ogrenci{" + "ad='" + ad + "\'" + ", yas=" + yas + ", notOrtalamasi=" + notOrtalamasi + '}';
    }
}

List<Ogrenci> ogrenciler = Arrays.asList(
    new Ogrenci("Ali", 20, 85.5),
    new Ogrenci("Ayşe", 22, 92.0),
    new Ogrenci("Can", 21, 78.0),
    new Ogrenci("Deniz", 20, 95.0),
    new Ogrenci("Elif", 23, 88.0)
);

// Not ortalaması 90 ve üzeri olan öğrencilerin isimlerini büyük harflerle listeleyelim
List<String> basariliOgrenciler = ogrenciler.stream()
    .filter(o -> o.getNotOrtalamasi() >= 90) // 90 ve üzeri not ortalaması olanları filtrele
    .map(Ogrenci::getAd) // Öğrenci nesnesinden sadece adı al
    .map(String::toUpperCase) // Adı büyük harfe çevir
    .collect(Collectors.toList()); // Sonuçları bir List'e topla

System.out.println("Başarılı Öğrenciler: " + basariliOgrenciler); // Çıktı: [AYŞE, DENİZ]

// Yaşı 21'den küçük olan ve not ortalaması 80'in üzerinde olan kaç öğrenci var?
long sayi = ogrenciler.stream()
    .filter(o -> o.getNotOrtalamasi() > 80 && o.getYas() < 21)
    .count();

System.out.println("Belirtilen kriterlere uyan öğrenci sayısı: " + sayi); // Çıktı: 2

// Tüm öğrencilerin not ortalamalarının toplamı
double toplamNot = ogrenciler.stream()
    .mapToDouble(Ogrenci::getNotOrtalamasi)
    .sum();

System.out.println("Tüm öğrencilerin not ortalamaları toplamı: " + toplamNot); // Çıktı: 438.5

// En yüksek not ortalamasına sahip öğrenciyi bul
Optional<Ogrenci> enYuksekNotluOgrenci = ogrenciler.stream()
    .max(Comparator.comparingDouble(Ogrenci::getNotOrtalamasi));

enYuksekNotluOgrenci.ifPresent(o -> System.out.println("En yüksek not ortalamasına sahip öğrenci: " + o.getAd()));

// Öğrencileri yaşa göre gruplandır
Map<Integer, List<Ogrenci>> yaslaraGoreGruplama = ogrenciler.stream()
    .collect(Collectors.groupingBy(Ogrenci::getYas));

System.out.println("Yaşlara Göre Gruplama: " + yaslaraGoreGruplama);

ClassName::methodName

objectName::methodName

• Statik metod referansı:
  Kod:

  ClassName::staticMethodName

  (Örnek:
  Kod:

  Math::max

  )
• Belirli bir nesnenin instance metod referansı:
  Kod:

  object::instanceMethodName

  (Örnek:
  Kod:

  System.out::println

  )
• Belirli bir türün instance metod referansı:
  Kod:

  ClassName::instanceMethodName

  (Örnek:
  Kod:

  String::length

  )
• Constructor referansı:
  Kod:

  ClassName::new

  (Örnek:
  Kod:

  ArrayList::new

  )

Ogrenci::getAd

String::toUpperCase

o -> o.getAd()

s -> s.toUpperCase()

stream()

parallelStream()

stream().parallel()

List<Integer> sayilar = IntStream.range(1, 1000000).boxed().collect(Collectors.toList());

long startTime = System.nanoTime();
long toplamSeri = sayilar.stream().reduce(0, Integer::sum);
long endTime = System.nanoTime();
System.out.println("Seri Toplam: " + toplamSeri + ", Süre: " + (endTime - startTime) / 1_000_000 + " ms");

startTime = System.nanoTime();
long toplamParalel = sayilar.parallelStream().reduce(0, Integer::sum);
endTime = System.nanoTime();
System.out.println("Paralel Toplam: " + toplamParalel + ", Süre: " + (endTime - startTime) / 1_000_000 + " ms");

Paralel akışlar, doğru kullanıldığında muazzam performans artışları sunabilir, ancak dikkatli olunmalıdır. Paylaşılan değiştirilebilir durumlardan kaçınmak ve işlemlerin birleşme (associativity) özelliğine sahip olduğundan emin olmak önemlidir.

Genişletmek için tıkla ...

• Tembel Değerlendirme (Lazy Evaluation): Ara operasyonlar hemen çalışmaz. Bu, akışın yalnızca nihai bir sonuç gerektiğinde işlenmesi anlamına gelir. Bu davranış, zincirleme operasyonlarda performansı artırır ancak akışın yaşam döngüsünü anlamayı gerektirir.
• Yan Etkisiz Operasyonlar: Stream operasyonları mümkün olduğunca yan etkisiz (stateless) olmalıdır. Yani, bir öğe üzerinde yapılan işlem, başka bir öğeyi veya dışarıdaki bir durumu değiştirmemelidir. Özellikle paralel akışlarda bu kurala uymak kritik öneme sahiptir.
• Akışı Yalnızca Bir Kez Tüketin: Bir akış terminal bir işlem tarafından tüketildikten sonra tekrar kullanılamaz. İkinci bir terminal işlem çağrısı
  Kod:

  IllegalStateException

  fırlatır.
• Performans Analizi: Her zaman paralel akışların daha hızlı olacağı varsayılmamalıdır. Küçük veri setleri veya I/O yoğun işlemler için paralel akışların overhead'i seri akışlardan daha fazla olabilir. Performansınızı ölçün.
• Debug Kolaylığı: Zincirleme akış operasyonlarında hata ayıklamak geleneksel döngülere göre biraz daha zor olabilir.
  Kod:

  peek()

  ara operasyonu, akıştaki her öğeyi incelemek için geçici olarak kullanılabilir, ancak genellikle üretim kodunda kullanılmamalıdır.
• Uygun Collector Seçimi:
  Kod:

  Collectors

  sınıfı, akış öğelerini farklı yapılar altında toplamak için zengin bir dizi metod sunar. İhtiyacınıza en uygun toplayıcıyı seçmek, kodunuzun hem okunabilirliğini hem de performansını artırır. Örneğin,
  Kod:

  groupingBy

  ,
  Kod:

  partitioningBy

  ,
  Kod:

  joining

  ,
  Kod:

  summarizingInt/Long/Double

  gibi metodlar oldukça güçlüdür.