1import java.io.IOException;
2import java.nio.charset.StandardCharsets;
3import java.nio.file.Files;
4import java.nio.file.Path;
5
6/**
7 * ============================================================================
8 *  JAVA 11 - Files.readString / Files.writeString - JEP 330 ile birlikte gelen
9 *  pratik dosya I/O metotlari
10 * ============================================================================
11 *
12 *  NEDIR?
13 *  ------
14 *  Java 11, java.nio.file.Files sinifina iki cok kullanisli metot ekledi:
15 *    - Files.readString(Path)      -> dosyanin TUM icerigini tek String'e okur
16 *    - Files.writeString(Path, CharSequence) -> bir String'i dosyaya yazar
17 *  Her ikisinin de Charset alan asiri yuklemeleri (overload) vardir.
18 *  Varsayilan charset UTF-8'dir.
19 *
20 *  NEDEN GELDI? (Hangi problem?)
21 *  -----------------------------
22 *  Bir dosyanin tum icerigini tek bir String olarak okumak/yazmak gunluk
23 *  hayatta cok sik yapilan bir is. Ama Java'da bunu yapmanin "tek satirlik"
24 *  basit bir yolu yoktu. Insanlar ya:
25 *    - BufferedReader ile satir satir okur (cok kod),
26 *    - Files.readAllBytes(path) + new String(bytes, UTF_8) yazar (charset
27 *      hatasi yapmaya acik),
28 *    - Files.lines(...).collect(joining("\n")) yazar (satir sonu kaybi),
29 *    - ya da Apache Commons IO / Guava gibi 3. parti kutuphane kullanirdi.
30 *
31 *  NE ISE YARAR / NEREDE KOLAYLIK SAGLAR?
32 *  --------------------------------------
33 *    - Konfigurasyon dosyalari (.properties, .json, .yaml) okuma
34 *    - Template (sablon) dosyalari okuyup icini doldurma
35 *    - Kucuk metin dosyalari, SQL script'leri, HTML parcalari okuma
36 *    - Log/rapor yazma, ciktiyi dosyaya kaydetme
37 *
38 *  GERCEK HAYAT ORNEGI:
39 *  --------------------
40 *    Bir uygulama, e-posta sablonunu "email_template.html" dosyasindan okuyup
41 *    icindeki {isim} gibi yer tutuculari degistirip gonderir. Tek satirda
42 *    String oku, replace et, gonder. Eskiden bu 10+ satirdi.
43 *
44 *  DIKKAT (RISK): readString tum dosyayi BELLEGE alir. Cok buyuk dosyalarda
45 *  (orn. yuzlerce MB) OutOfMemoryError riski vardir. Buyuk dosyalar icin hala
46 *  BufferedReader / Files.lines (stream) tercih edilmelidir.
47 * ============================================================================
48 */
49public class FilesReadWriteString {
50
51    public static void main(String[] args) {
52        try {
53            // ================================================================
54            // Gecici bir dosya olusturuyoruz (ornek gercekten calissin diye)
55            // ================================================================
56            Path geciciDosya = Files.createTempFile("java11-ornek", ".txt");
57            System.out.println("Gecici dosya olusturuldu: " + geciciDosya);
58
59            String icerik = "Merhaba Java 11!\n"
60                    + "Bu dosya Files.writeString ile yazildi.\n"
61                    + "Turkce karakterler: cgiosu CGIOSU\n"
62                    + "Ucuncu satir.";
63
64            // ================================================================
65            // 1) YENI YONTEM: Files.writeString ile yazma (UTF-8)
66            // ================================================================
67            // Charset belirtmek istersek StandardCharsets.UTF_8 verebiliriz.
68            Files.writeString(geciciDosya, icerik, StandardCharsets.UTF_8);
69            System.out.println("\n>>> Dosyaya yazildi (Files.writeString).");
70
71            // ================================================================
72            // 2) YENI YONTEM: Files.readString ile okuma (UTF-8)
73            // ================================================================
74            String okunan = Files.readString(geciciDosya, StandardCharsets.UTF_8);
75            System.out.println("\n>>> Dosyadan okunan icerik (Files.readString):");
76            System.out.println("------------------------------------------------");
77            System.out.println(okunan);
78            System.out.println("------------------------------------------------");
79            System.out.println("Okunan karakter sayisi: " + okunan.length());
80
81            // ================================================================
82            // 3) Java 11 lines() ile birlikte kullanim (BONUS)
83            // ================================================================
84            System.out.println("\n>>> Satir satir isleme (String.lines()):");
85            okunan.lines()
86                  .filter(satir -> !satir.isBlank())
87                  .forEach(satir -> System.out.println("   Satir: " + satir));
88
89            // Temizlik: gecici dosyayi sil
90            Files.deleteIfExists(geciciDosya);
91            System.out.println("\nGecici dosya silindi.");
92
93        } catch (IOException e) {
94            System.out.println("Dosya islemi sirasinda hata: " + e.getMessage());
95        }
96    }
97}
98
99/*
100 * ============================================================================
101 *  ESKI vs YENI KARSILASTIRMA
102 * ============================================================================
103 *
104 *  --- ESKI YONTEM 1: Files.readAllBytes + new String ---
105 *  byte[] bytes = Files.readAllBytes(path);
106 *  String icerik = new String(bytes, StandardCharsets.UTF_8);
107 *  // Charset unutursan platform varsayilani kullanilir -> Turkce bozulur!
108 *
109 *  --- ESKI YONTEM 2: BufferedReader ile satir satir ---
110 *  StringBuilder sb = new StringBuilder();
111 *  try (BufferedReader br = Files.newBufferedReader(path, UTF_8)) {
112 *      String line;
113 *      while ((line = br.readLine()) != null) {
114 *          sb.append(line).append(System.lineSeparator());
115 *      }
116 *  }
117 *  String icerik = sb.toString();   // ~7 satir + try-with-resources
118 *
119 *  --- ESKI YONTEM 3: Files.lines (stream) ---
120 *  String icerik;
121 *  try (Stream<String> s = Files.lines(path, UTF_8)) {
122 *      icerik = s.collect(Collectors.joining("\n"));
123 *      // Sondaki satir sonu kaybolur, orijinal birebir korunmaz
124 *  }
125 *
126 *  --- ESKI YAZMA YONTEMI ---
127 *  try (BufferedWriter bw = Files.newBufferedWriter(path, UTF_8)) {
128 *      bw.write(icerik);
129 *  }
130 *
131 *  --- YENI YONTEM (Java 11) ---
132 *  String icerik = Files.readString(path);              // OKUMA - tek satir
133 *  Files.writeString(path, icerik);                     // YAZMA - tek satir
134 *
135 *  OZET TABLO:
136 *  | Islem | Eski (satir sayisi) | Yeni Java 11 |
137 *  |-------|---------------------|--------------|
138 *  | Okuma | 5-7 satir           | 1 satir      |
139 *  | Yazma | 3-4 satir           | 1 satir      |
140 *  | Charset hata riski | Yuksek | Dusuk (UTF-8 varsayilan) |
141 * ============================================================================
142 */

1import java.util.List;
2import java.util.stream.Collectors;
3
4/**
5 * ============================================================================
6 *  JAVA 11 - YENI STRING METOTLARI - JEP 327 (Unicode) + String iyilestirmeleri
7 * ============================================================================
8 *
9 *  Java 11 ile String sinifina cok kullanisli metotlar eklendi:
10 *    - strip(), stripLeading(), stripTrailing()
11 *    - isBlank()
12 *    - lines()
13 *    - repeat(int)
14 *
15 *  Ayrica Collection.toArray(IntFunction) yeniligi de bu dosyada gosterilmistir
16 *  (List<String> -> String[] donusumu icin).
17 *
18 *  GERCEK HAYAT ORNEGI:
19 *  --------------------
20 *    Kullanicidan gelen form verilerini (isim, e-posta) temizlemek, log
21 *    dosyalarini satir satir islemek, CSV/metin parse etmek, rapor/tablo
22 *    cizmek (repeat ile cizgi/bosluk) gibi gunluk islerde cok ise yarar.
23 * ============================================================================
24 */
25public class StringYeniMetotlar {
26
27    public static void main(String[] args) {
28
29        // ====================================================================
30        // 1) strip() vs trim() - EN ONEMLI FARK: UNICODE!
31        // ====================================================================
32        //
33        // NEDIR: strip() bir String'in basindaki ve sonundaki bosluklari siler.
34        //
35        // NEDEN GELDI: Eski trim() metodu 1997'den beri var ama bir SORUNU var:
36        //   trim() yalnizca kod degeri <= U+0020 (space) olan karakterleri siler.
37        //   Yani bazi Unicode bosluk karakterlerini (orn. U+2007, U+00A0 - non
38        //   breaking space, U+2003 - em space) TANIMAZ ve SILMEZ.
39        //   strip() ise Character.isWhitespace() kullanir; tum Unicode bosluk
40        //   karakterlerini dogru sekilde temizler.
41        //
42        System.out.println("=== 1) strip vs trim (Unicode) ===");
43
44        // U+2003 (EM SPACE) ile cevrelenmis metin - trim bunu SILEMEZ:
45        String unicodeBosluklu = "  Merhaba  ";
46
47        System.out.println("Orijinal uzunluk      : " + unicodeBosluklu.length());
48        System.out.println("trim() sonrasi uzunluk: " + unicodeBosluklu.trim().length()
49                + "  (trim Unicode bosluk siremedi!)");
50        System.out.println("strip() sonrasi uzunluk: " + unicodeBosluklu.strip().length()
51                + "  (strip dogru temizledi)");
52
53        // stripLeading(): sadece bastaki, stripTrailing(): sadece sondaki
54        String veri = "   sadece kenarlar   ";
55        System.out.println("stripLeading() : '" + veri.stripLeading() + "'");
56        System.out.println("stripTrailing(): '" + veri.stripTrailing() + "'");
57        System.out.println("strip()        : '" + veri.strip() + "'");
58
59        // ESKI YONTEM: trim() (Unicode-guvensiz) veya replaceAll regex:
60        //   String s = veri.replaceAll("^\\s+|\\s+$", "");  // karmasik regex
61        // YENI YONTEM: veri.strip();  // temiz ve Unicode-dogru
62
63        // ====================================================================
64        // 2) isBlank() - bos VEYA sadece bosluk mu?
65        // ====================================================================
66        //
67        // NEDIR: String bos ("") veya yalnizca bosluk karakterlerinden mi
68        //        olusuyor kontrol eder.
69        // NEDEN GELDI: isEmpty() sadece "" (sifir uzunluk) kontrol eder; icinde
70        //        bosluk olan "   " icin false doner. Form validasyonunda bu sorun.
71        //
72        System.out.println("\n=== 2) isBlank ===");
73        String bosluklu = "    \t  \n  ";
74        System.out.println("isEmpty(): " + bosluklu.isEmpty()
75                + "  (false - icinde bosluk var)");
76        System.out.println("isBlank(): " + bosluklu.isBlank()
77                + "  (true - hepsi bosluk)");
78
79        // GERCEK HAYAT: form alani gercekten dolu mu?
80        String kullaniciGirdisi = "   ";
81        if (kullaniciGirdisi.isBlank()) {
82            System.out.println("HATA: Isim alani bos birakilamaz!");
83        }
84        // ESKI YONTEM: if (s == null || s.trim().isEmpty()) { ... }
85        // YENI YONTEM: if (s.isBlank()) { ... }
86
87        // ====================================================================
88        // 3) lines() - cok satirli metni Stream<String> olarak gez
89        // ====================================================================
90        //
91        // NEDIR: Cok satirli bir String'i, satir sonlarina gore bolup
92        //        Stream<String> dondurur. \n, \r, \r\n hepsini tanir.
93        // NEDEN GELDI: Eskiden split("\n") ile bolerdik ama \r\n (Windows)
94        //        ve platform farkliliklari sorun cikariyordu. lines() bunlari
95        //        dogru ele alir ve tembel (lazy) bir stream verir.
96        //
97        System.out.println("\n=== 3) lines ===");
98        String logMetni = "INFO: baslangic\nWARN: dikkat\nERROR: hata olustu\nINFO: bitis";
99
100        System.out.println("Toplam satir sayisi: " + logMetni.lines().count());
101        System.out.println("Sadece ERROR satirlari:");
102        logMetni.lines()
103                .filter(satir -> satir.startsWith("ERROR"))
104                .forEach(satir -> System.out.println("   >> " + satir));
105
106        // ESKI YONTEM: String[] satirlar = logMetni.split("\\r?\\n");
107        // YENI YONTEM: logMetni.lines()  // stream olarak, lazy, dogru
108
109        // ====================================================================
110        // 4) repeat(int) - String'i N kez tekrarla
111        // ====================================================================
112        //
113        // NEDIR: String'i belirtilen sayida tekrarlayip yeni String dondurur.
114        // NEDEN GELDI: Eskiden bir karakteri/metni N kez tekrarlamak icin dongu
115        //        veya StringBuilder yazmak gerekirdi. Cok yaygin bir ihtiyac.
116        //
117        System.out.println("\n=== 4) repeat ===");
118        System.out.println("=".repeat(40));        // 40 karakterlik cizgi
119        System.out.println("Ya" + "ha ".repeat(3));
120        System.out.println("Girinti:" + " ".repeat(4) + "(4 bosluk girinti)");
121
122        // GERCEK HAYAT: konsol tablosu/rapor basligi cizmek
123        String baslik = "RAPOR";
124        System.out.println("+" + "-".repeat(baslik.length() + 2) + "+");
125        System.out.println("| " + baslik + " |");
126        System.out.println("+" + "-".repeat(baslik.length() + 2) + "+");
127
128        // ESKI YONTEM:
129        //   StringBuilder sb = new StringBuilder();
130        //   for (int i = 0; i < 40; i++) sb.append("=");
131        //   String cizgi = sb.toString();
132        // YENI YONTEM: "=".repeat(40);
133
134        // ====================================================================
135        // 5) Collection.toArray(IntFunction) - BONUS Java 11 yeniligi
136        // ====================================================================
137        //
138        // NEDIR: Bir koleksiyonu tipli diziye cevirirken artik bos dizi
139        //        olusturup gecmek yerine, method reference verebiliriz.
140        //
141        System.out.println("\n=== 5) Collection.toArray(IntFunction) ===");
142        List<String> isimler = List.of("Ali", "Veli", "Ayse");
143
144        // YENI (Java 11): method reference ile temiz
145        String[] dizi = isimler.toArray(String[]::new);
146        System.out.println("Diziye cevrildi: " + String.join(", ", dizi));
147
148        // ESKI YONTEM: isimler.toArray(new String[0]);  // veya new String[size]
149
150        // Birlestirilmis ornek: temizle + tekrarsiz + diziye al
151        List<String> temizlenmis = List.of("  Ali ", "Veli", "  Ayse  ").stream()
152                .map(String::strip)
153                .filter(s -> !s.isBlank())
154                .collect(Collectors.toList());
155        String[] sonDizi = temizlenmis.toArray(String[]::new);
156        System.out.println("Temizlenmis dizi: " + String.join(" | ", sonDizi));
157    }
158}

1import java.time.LocalDate;
2import java.util.List;
3import java.util.stream.Collectors;
4
5/**
6 * ============================================================================
7 *  JAVA 11 - TEK DOSYA KAYNAK KODU CALISTIRMA - JEP 330
8 *  (Launch Single-File Source-Code Programs)
9 * ============================================================================
10 *
11 *  NEDIR?
12 *  ------
13 *  Java 11'den itibaren bir .java dosyasini ONCEDEN DERLEMEDEN (javac
14 *  calistirmadan) DOGRUDAN calistirabiliriz:
15 *
16 *      java TekDosyaCalistirma.java
17 *
18 *  Bu komut dosyayi BELLEKTE derler ve hemen calistirir. Disk'e .class
19 *  dosyasi YAZMAZ. Yani tek adimda kaynak kodu -> calisan program.
20 *
21 *  NEDEN GELDI? (Hangi problem?)
22 *  -----------------------------
23 *  Java'ya yeni baslayanlar ve hizli deneme yapmak isteyenler icin iki adimli
24 *  surec (once javac, sonra java) gereksiz bir engeldi:
25 *      $ javac Merhaba.java     # derle -> Merhaba.class olusur
26 *      $ java Merhaba           # calistir
27 *  Python/Ruby gibi "yaz-calistir" dillerine kiyasla bu fazladan adim,
28 *  ozellikle ogrenme ve kucuk script'lerde zaman kaybiydi. JEP 330 bunu
29 *  tek adima indirdi.
30 *
31 *  NE ISE YARAR / NEREDE KOLAYLIK SAGLAR?
32 *  --------------------------------------
33 *    - OGRENME: Yeni baslayanlar derleme detayina takilmaz.
34 *    - HIZLI PROTOTIPLEME: Kucuk bir fikri saniyeler icinde dener.
35 *    - SCRIPT YAZMA: Java'yi shell script gibi kullanabiliriz (shebang ile).
36 *    - DENEME/TEST: Bir API'yi hizlica denemek icin gecici dosya.
37 *
38 *  NASIL CALISTIRILIR?
39 *  -------------------
40 *      java TekDosyaCalistirma.java
41 *      java TekDosyaCalistirma.java arg1 arg2     # argumanlarla
42 *
43 *  GERCEK HAYAT ORNEGI:
44 *  --------------------
45 *    Bir gelistirici, "su tarih formatlama mantigi dogru calisiyor mu?" diye
46 *    merak eder. Yeni bir proje acmak, IDE baslatmak yerine 20 satirlik bir
47 *    .java dosyasi yazip 'java Test.java' ile aninda gorur.
48 * ============================================================================
49 */
50public class TekDosyaCalistirma {
51
52    public static void main(String[] args) {
53        System.out.println("===========================================");
54        System.out.println(" Java 11 Tek Dosya Calistirma (JEP 330)");
55        System.out.println("===========================================");
56        System.out.println("Bu program 'java TekDosyaCalistirma.java' ile");
57        System.out.println("ONCEDEN DERLENMEDEN dogrudan calistirilabilir!");
58        System.out.println("Bugunun tarihi: " + LocalDate.now());
59
60        // Komut satiri argumanlarini da kullanabiliriz:
61        if (args.length > 0) {
62            System.out.println("\nVerilen argumanlar:");
63            for (int i = 0; i < args.length; i++) {
64                System.out.println("  arg[" + i + "] = " + args[i]);
65            }
66        } else {
67            System.out.println("\n(Arguman verilmedi. Deneyin: "
68                    + "java TekDosyaCalistirma.java Ahmet 42)");
69        }
70
71        // Java 11 ozelliklerini birlikte gosterelim:
72        List<String> isimler = List.of("  ali  ", "veli", "  ", "ayse  ");
73        String temiz = isimler.stream()
74                .map(String::strip)        // Java 11 strip()
75                .filter(s -> !s.isBlank()) // Java 11 isBlank()
76                .map(String::toUpperCase)
77                .collect(Collectors.joining(", "));
78        System.out.println("\nTemizlenmis isimler: " + temiz);
79        System.out.println("\nProgram tek dosya olarak basariyla calisti!");
80    }
81}
82
83/*
84 * ============================================================================
85 *  ESKI YONTEM vs YENI YONTEM
86 * ============================================================================
87 *
88 *  --- ESKI (Java 11 ONCESI): IKI ADIM ---
89 *      $ javac TekDosyaCalistirma.java     # 1. Derle (.class olusur)
90 *      $ java TekDosyaCalistirma           # 2. Calistir
91 *  Dezavantaj: disk'e .class dosyasi yazilir, iki komut gerekir.
92 *
93 *  --- YENI (Java 11): TEK ADIM ---
94 *      $ java TekDosyaCalistirma.java      # Bellekte derle + calistir
95 *  Avantaj: tek komut, disk'e .class yazilmaz, hizli.
96 *
97 *  NOT: .java uzantisini YAZMAK onemlidir. 'java TekDosyaCalistirma.java'
98 *  (uzantili) -> kaynak kodu modu. 'java TekDosyaCalistirma' (uzantisiz)
99 *  -> onceden derlenmis .class arar.
100 *
101 * ============================================================================
102 *  SHEBANG (#!) ILE SCRIPT OLARAK CALISTIRMA
103 * ============================================================================
104 *
105 *  JEP 330 ayrica Java dosyalarini Unix/Linux/macOS'ta SCRIPT gibi
106 *  calistirmaya izin verir. Bunun icin:
107 *
108 *  1) Dosyanin ILK SATIRINA shebang eklenir (uzanti .java OLMAMALI, orn:
109 *     "merhaba" gibi uzantisiz bir dosya):
110 *
111 *         #!/usr/bin/java --source 11
112 *         public class Merhaba {
113 *             public static void main(String[] args) {
114 *                 System.out.println("Merhaba script!");
115 *             }
116 *         }
117 *
118 *  2) Dosyaya calistirma izni verilir:
119 *         $ chmod +x merhaba
120 *
121 *  3) Dogrudan calistirilir (sanki bash/python script'iymis gibi):
122 *         $ ./merhaba
123 *         Merhaba script!
124 *
125 *  ONEMLI: Shebang kullanilan dosya .java UZANTILI OLAMAZ. Shebang yalnizca
126 *  uzantisiz (veya .java disi) dosyalarda gecerlidir; .java dosyalari icin
127 *  'java X.java' komutu kullanilir. --source 11 ile hangi dil seviyesinde
128 *  derlenecegi belirtilir.
129 *
130 *  KISITLAMALAR:
131 *    - Tek dosya: birden fazla kaynak dosyaya bagimli olamaz (sadece JDK +
132 *      classpath'teki hazir kutuphaneler kullanilabilir).
133 *    - Dosya icindeki ILK sinif main metodunu icermeli.
134 *    - Buyuk projeler icin DEGIL; kucuk script/prototip icindir.
135 * ============================================================================
136 */

1import java.util.List;
2import java.util.function.BiFunction;
3import java.util.function.BinaryOperator;
4import java.util.stream.Collectors;
5
6/**
7 * ============================================================================
8 *  JAVA 11 - LAMBDA PARAMETRELERINDE 'var' KULLANIMI - JEP 323
9 * ============================================================================
10 *
11 *  NEDIR?
12 *  ------
13 *  Java 10 ile yerel degisken tip cikarimi (Local Variable Type Inference)
14 *  geldi: "var x = 10;". ANCAK Java 10'da 'var' lambda parametrelerinde
15 *  KULLANILAMIYORDU. Java 11 (JEP 323) bunu mumkun kildi:
16 *      (var a, var b) -> a + b
17 *
18 *  NEDEN GELDI? (Hangi problem cozuldu?)
19 *  -------------------------------------
20 *  Tek basina "lambda parametresine var yazmak" cok da kisaltma saglamaz;
21 *  zaten implicit (tip yazmadan) lambda yazabiliyoruz: (a, b) -> a + b.
22 *  ASIL FAYDA: lambda parametrelerine ANNOTATION (ek aciklama, orn. @NonNull)
23 *  ekleyebilmek icin bir tipe ihtiyac vardir. 'var' bu tipi saglar:
24 *      (@NonNull var a, @NonNull var b) -> a + b
25 *  Eskiden annotation eklemek icin TAM tip yazmak zorundaydik:
26 *      (@NonNull Integer a, @NonNull Integer b) -> a + b   // uzun
27 *  'var' ile annotation'i tutuyoruz ama uzun tip adini yazmiyoruz.
28 *  Ayrica tutarlilik saglar: artik 'var' her yerde (yerel, lambda) calisir.
29 *
30 *  KURALLAR (cok onemli):
31 *  ----------------------
32 *    1) YA HEPSI YA HICBIRI: Bir lambdada parametrelerin ya HEPSI 'var'
33 *       olmali ya da HICBIRI. Karistirilamaz.
34 *       GECERSIZ:  (var a, b) -> ...
35 *       GECERSIZ:  (var a, Integer b) -> ...   // var + explicit tip karisik
36 *       GECERLI:   (var a, var b) -> ...
37 *    2) PARANTEZ ZORUNLU: Tek parametre bile olsa parantez sart.
38 *       GECERSIZ:  var x -> x * 2
39 *       GECERLI:   (var x) -> x * 2
40 *
41 *  GERCEK HAYAT ORNEGI:
42 *  --------------------
43 *    Null-safety annotation'lari (Checker Framework, Spring @NonNull) kullanan
44 *    kurumsal projelerde, lambda parametrelerine de bu annotation'lari koyup
45 *    statik analiz aracina "bu parametre null olamaz" demek icin idealdir.
46 * ============================================================================
47 */
48public class VarLambdaParametre {
49
50    public static void main(String[] args) {
51
52        // ====================================================================
53        // 1) Temel kullanim: (var a, var b) -> ...
54        // ====================================================================
55        System.out.println("=== 1) Temel var lambda ===");
56
57        // YENI (Java 11): var ile
58        BiFunction<Integer, Integer, Integer> topla = (var a, var b) -> a + b;
59        System.out.println("topla(3, 5) = " + topla.apply(3, 5));
60
61        // Bu YENI yontem, asagidaki ESKI yontemlerle ESDEGER:
62        //   ESKI A (implicit): (a, b) -> a + b
63        //   ESKI B (explicit): (Integer a, Integer b) -> a + b
64
65        // ====================================================================
66        // 2) Tek parametreyle - PARANTEZ ZORUNLU
67        // ====================================================================
68        System.out.println("\n=== 2) Tek parametre (parantez zorunlu) ===");
69        java.util.function.Function<String, String> buyut = (var s) -> s.toUpperCase();
70        System.out.println("buyut(\"merhaba\") = " + buyut.apply("merhaba"));
71        // DIKKAT: var s -> ...  YAZILAMAZ (derlenmez). (var s) -> ... olmali.
72
73        // ====================================================================
74        // 3) Stream icinde var lambda (gercekci kullanim)
75        // ====================================================================
76        System.out.println("\n=== 3) Stream icinde var ===");
77        List<String> kelimeler = List.of("elma", "armut", "kiraz", "incir");
78
79        String sonuc = kelimeler.stream()
80                .map((var k) -> k.toUpperCase())            // var parametre
81                .filter((var k) -> k.length() > 4)          // var parametre
82                .collect(Collectors.joining(", "));
83        System.out.println("Sonuc: " + sonuc);
84
85        // ====================================================================
86        // 4) ASIL FAYDA: annotation ekleme (yorum icinde)
87        // ====================================================================
88        // Eger projede bir @NonNull annotation'i olsaydi soyle yazabilirdik:
89        //
90        //   BinaryOperator<Integer> carp =
91        //       (@NonNull var x, @NonNull var y) -> x * y;
92        //
93        // Burada @NonNull ekleyebilmek icin bir tipe ihtiyac var; 'var' bunu
94        // saglar. Annotation'siz haliyle gosterelim:
95        BinaryOperator<Integer> carp = (var x, var y) -> x * y;
96        System.out.println("\n=== 4) Annotation hazirligi ===");
97        System.out.println("carp(4, 6) = " + carp.apply(4, 6));
98        System.out.println("(Gercekte: (@NonNull var x, @NonNull var y) -> x * y yazilabilir)");
99
100        // ====================================================================
101        // 5) GECERSIZ ORNEKLER (sadece yorum - DERLENMEZ!)
102        // ====================================================================
103        // BiFunction<Integer,Integer,Integer> kotu1 = (var a, b) -> a + b;       // HATA: karisik
104        // BiFunction<Integer,Integer,Integer> kotu2 = (var a, Integer b) -> a+b; // HATA: var + tip
105        // Function<Integer,Integer> kotu3 = var x -> x * 2;                       // HATA: parantezsiz
106
107        System.out.println("\nProgram bitti.");
108    }
109}
110
111/*
112 * ============================================================================
113 *  ESKI (Java 10) vs YENI (Java 11) OZET
114 * ============================================================================
115 *  | Durum                          | Java 10        | Java 11       |
116 *  |--------------------------------|----------------|---------------|
117 *  | var yerel degisken             | VAR            | VAR           |
118 *  | var lambda parametresi         | YOK (hata)     | VAR           |
119 *  | lambda parametresine annotation| tam tip lazim  | var + annot.  |
120 *
121 *  Java 10:  (a, b) -> a + b           // var YAZILAMAZ
122 *  Java 11:  (var a, var b) -> a + b   // var YAZILABILIR
123 * ============================================================================
124 */