item 45 added

Author: mehmetozdeemiir

src/com/example/Item10And11OverridingEqualsAndHashCode/main.java

@@ -24,10 +24,10 @@ public static void main(String[] args) {
 
         DenemeSinif d = new DenemeSinif(1,2);
         DenemeSinif d2 = new DenemeSinif(1,2);
-        System.out.println(d==d2); //false  stack de ayrı sekilde referans tutulur
-        System.out.println(d.equals(d2));
+        System.out.println(d==d2); //false  stack de ayrı sekilde referans tutulur.
+        System.out.println(d.equals(d2)); //false
         System.out.println(d.hashCode());//different to d2 hashcode
-        System.out.println(d2.hashCode());
+        System.out.println(d2.hashCode());//different to d1 hashcode
 
         DenemeSinif deneme= new DenemeSinif(10,11);
         DenemeSinif deneme2= new DenemeSinif(10,11);

src/com/example/Item42LambdasToAnonymous/Main.java

@@ -0,0 +1,30 @@
+package com.example.Item42LambdasToAnonymous;
+
+public class Main {
+
+    public String exampleFour(){
+    return "ornek";
+}
+    public static void main(String[] args) {
+
+        //lambda : kendi başına tanımlanabilen , parametre kabul eden ve döndürülebilen fonksiyondur.
+
+        Yazdir y= ()->{
+            return "yazdim";
+        };
+        System.out.println(y.yazBeni());
+
+
+        String param ="Parametre";
+        YazdirParametre y2=(paramAlacak)->{
+            return paramAlacak + " selam";
+        };
+        System.out.println(y2.yazdirParametreyi(param));
+
+
+
+        Main ma=new Main();
+        Yazdir write =ma::exampleFour;
+        System.out.println(write.yazBeni());
+    }
+}

src/com/example/Item42LambdasToAnonymous/SortFourWays.java

@@ -0,0 +1,44 @@
+package com.example.Item42LambdasToAnonymous;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import static java.util.Comparator.comparingInt;
+
+// Sorting with function objects (Pages 193-4)
+public class SortFourWays {
+
+    public static void main(String[] args) {
+
+        String[] nameList = {"ali","veli","furkan","berna","yennefer","geralt","vesemir","ciri"};
+        List<String> words = Arrays.asList(nameList);
+
+        // Anonymous class instance as a function object - obsolete! (Page 193)
+        Collections.sort(words, new Comparator<String>() {
+            public int compare(String s1, String s2) {
+                return Integer.compare(s1.length(), s2.length());
+            }
+        });
+        System.out.println(words);
+        Collections.shuffle(words);
+
+        // Lambda expression as function object (replaces anonymous class) (Page 194)
+        Collections.sort(words, (s1, s2) -> Integer.compare(s1.length(), s2.length()));
+        System.out.println(words);
+        Collections.shuffle(words);
+
+        // Comparator construction method (with method reference) in place of lambda
+        // (Page 194) Bu terminoloji madde 43 te anlatılıyor burada değinmeyeceğim.
+        Collections.sort(words, comparingInt(String::length));
+        System.out.println(words);
+        Collections.shuffle(words);
+
+        // Default method List.sort in conjunction with comparator construction method
+        // (Page 194)
+        words.sort(comparingInt(String::length));
+        System.out.println(words);
+
+    }
+
+}

src/com/example/Item42LambdasToAnonymous/Yazdir.java

@@ -0,0 +1,6 @@
+package com.example.Item42LambdasToAnonymous;
+
+public interface Yazdir {
+
+    public String yazBeni();
+}

src/com/example/Item42LambdasToAnonymous/YazdirParametre.java

@@ -0,0 +1,6 @@
+package com.example.Item42LambdasToAnonymous;
+
+public interface YazdirParametre {
+
+    public String yazdirParametreyi(String param);
+}

src/com/example/Item43MethodReferencesToLambdas/Freq.java

@@ -0,0 +1,27 @@
+package com.example.Item43MethodReferencesToLambdas;
+
+
+import java.util.Map;
+import java.util.TreeMap;
+
+// Frequency table implemented with map.merge, using lambda and method reference (Page 197)
+public class Freq {
+    public static void main(String[] args) {
+
+
+        Map<String, Integer> frequencyTable = new TreeMap<>();
+
+        for (String s : args)
+            frequencyTable.merge(s, 1, (count, incr) -> count + incr ); // Lambda
+        System.out.println(frequencyTable);
+
+
+
+        frequencyTable.clear();
+        for (String s : args)
+            frequencyTable.merge(s, 1, Integer::sum); // Method reference
+        System.out.println(frequencyTable);
+
+
+    }
+}

src/com/example/Item43MethodReferencesToLambdas/Main.java

@@ -0,0 +1,7 @@
+package com.example.Item43MethodReferencesToLambdas;
+
+public class Main {
+    public static void main(String[] args) {
+
+    }
+}

src/com/example/Item45Streams/TestDrive.java

@@ -0,0 +1,63 @@
+package com.example.Item45Streams;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class TestDrive {
+
+    public static void main(String[] args) {
+
+        // Stream nedir? -> Java8 + sıralı paralel toplu işlemleri kolaylaştırmak için gelmiştir.
+        /*
+         * collections, files, veya başka streamler kaynak olabilir.
+         *
+         * terminal - intermediate
+         */
+
+        List<String> myList = Arrays.asList("jose saramago", "stefan zweig", "tess gerritsen","selami");
+
+
+        myList
+                .stream()
+                .filter(s -> s.startsWith("s"))
+                .map(String::toUpperCase)
+                .forEach(System.out::println);
+
+
+//		stream()
+//	    .intemediateOperation1()
+//	    .intemediateOperation2()
+//	    ...
+//	    .intemediateOperationN()
+//	    .terminalOperation();
+
+
+        Arrays.stream(new int[] {1, 2})
+                .map(n -> 2 * n + 1)
+                .average()
+                .ifPresent(System.out::println);
+ 
+
+        for(int i = 0 ; i < 5 ; i++)
+        {
+            System.out.println(i);
+        }
+
+        IntStream.range(0,5).forEach(System.out::println);
+
+        System.out.println(IntStream.range(0,10).max().getAsInt());
+
+
+        Collection<Integer> a = Collections.emptyList();
+        a.add(10);
+        List<Integer> result = a.stream().
+                filter(s -> s > 0).
+                collect(Collectors.toList());
+
+    }
+
+}

src/com/example/Main.java

@@ -1,7 +1,5 @@
 package com.example;
 
-import java.security.SecureRandom;
-
 public class Main {
 
     public static void main(String[] args) {