MISC JAVA 8 RECIPIES

Author: Dhananjay Nagargoje

Diff for: .idea/workspace.xml

@@ -1,2 +1,9 @@
-qasx
-qas x
+1
+7
+1 2
+1 3
+2 4
+2 5
+4 6
+4 7
+

Diff for: out/production/main/algorithms/trading/WithoutInvesting.class

@@ -0,0 +1,38 @@
+package javarecipies.collections;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class ConcurrentModification {
+    public static void main(String[] args) {
+
+        List<Integer> modify = new ArrayList<>();
+        modify.add(1);
+        modify.add(2);
+        modify.add(3);
+
+
+        Iterator<Integer> it = modify.iterator();
+        while (it.hasNext()) {
+            Integer x = it.next();
+            System.out.println(x);
+            if (x == 1){
+               //below line will cause ConcurrentModificationException as we have modified collection
+               //without telling iterator
+               // modify.remove(2);
+
+               //to avoid exeception use iterator remove
+                it.remove();
+            }
+        }
+
+        modify = new ArrayList<>();
+        modify.add(1);
+        modify.add(2);
+        modify.add(3);
+
+        modify.removeIf(integer -> integer == 2);
+        System.out.println(modify.toString());
+    }
+}

Diff for: out/production/main/datastructures/graph/BreadthFirstPaths.class

@@ -0,0 +1,35 @@
+package javarecipies.generics;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class GenericMethod {
+    <T> void printType(T item) {
+
+        System.out.println(item);
+
+    }
+
+    public static void main( String args[] ) {
+        GenericMethod demo = new GenericMethod();
+        demo.<String>printType("string");
+        demo.<Integer>printType(5);
+        demo.printType(23.23f);
+
+        List<Employee> list = new ArrayList<>();
+        save(list);
+
+    }
+
+
+    //upper bound on generics
+    static void save(List<? extends Person> person) {
+
+    }
+}
+class Person {
+
+}
+class Employee extends Person {
+
+}

Diff for: out/production/main/datastructures/graph/ConnectedComponent.class

@@ -0,0 +1,61 @@
+package javarecipies.java8;
+
+
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Consumer;
+import java.lang.Integer;
+
+public class Java8ForEachExample {
+
+    public static void main(String[] args) {
+
+        //creating sample Collection
+        List<Integer> myList = new ArrayList<Integer>();
+        for(int i=0; i<10; i++) myList.add(i);
+
+        //traversing using Iterator
+        Iterator<Integer> it = myList.iterator();
+        while(it.hasNext()){
+            Integer i = it.next();
+            System.out.println("Iterator Value::"+i);
+        }
+        /**
+         *
+         * underlying implementation :
+         default void forEach(Consumer<? super T> action) {
+         Objects.requireNonNull(action);
+         for (T t : this) {
+         action.accept(t);
+         }
+         }
+
+         */
+        //traversing through forEach method of Iterable with anonymous class
+        myList.forEach(new Consumer<Integer>() {
+
+            public void accept(Integer t) {
+                System.out.println("forEach anonymous class Value::"+t);
+            }
+
+        });
+
+        //traversing with Consumer interface implementation
+        MyConsumer action = new MyConsumer();
+        myList.forEach(action);
+
+    }
+
+}
+
+//Consumer implementation that can be reused
+class MyConsumer implements Consumer<Integer>{
+
+    public void accept(Integer t) {
+        System.out.println("Consumer impl Value::"+t);
+    }
+
+
+}

Diff for: out/production/main/datastructures/graph/DepthFirstPaths.class

@@ -0,0 +1,53 @@
+package javarecipies.java8;
+
+import java.util.Comparator;
+import java.util.PriorityQueue;
+import java.util.function.Function;
+
+public class LambdaDemo {
+    public static void main(String args[]) {
+
+        DoStuff ds1 = () -> System.out.println("I ran via lambda expression");
+        DoStuff ds2 = new DoStuff() {
+            public void work() {
+                System.out.println("I ran via anonymous class");
+            }
+        };
+        ds1.work();
+        ds2.work();
+
+
+        Comparator<Integer> descendingComparator = (i1, i2) -> {
+            return i2 - i1;
+        };
+        PriorityQueue<Integer> q = new PriorityQueue<>(descendingComparator);
+
+        // add integers to q in ascending order
+        for(int i=0;i<=10;i++) {
+            q.add(i);
+        }
+
+        // verify the numbers are printed in descending order
+        for(int i=0;i<=10;i++) {
+            System.out.println(q.poll());
+        }
+
+        RaiseToPower square = (x) -> {return x*x;};
+        RaiseToPower cube = (x) -> {return x*x*x;};
+        System.out.println(square.raiseToX(3));
+
+
+        Function<Integer, Integer> power = (a) -> a*a;
+        System.out.println(power.apply(3));
+    }
+}
+
+// A functional interface
+interface DoStuff {
+    void work();
+}
+interface RaiseToPower {
+
+    int raiseToX(int x);
+
+}

Diff for: out/production/main/datastructures/graph/Digraph.class

@@ -0,0 +1,88 @@
+package javarecipies.java8;
+
+import java.util.Comparator;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+public class MethodReferences {
+
+    public static void main(String[] args) {
+
+        Function<Person, Integer> age = Person::getAge;
+        Function<Person, Integer> height = Person::getHeight;
+
+        Person person = new Person();
+        person.setAge(23);
+        person.setHeight(170);
+
+        System.out.println(age.apply(person));
+        System.out.println(height.apply(person));
+
+        Consumer<String> printer = System.out::println;
+        printer.accept("Hello World");
+
+
+        Comparator<Person> allComparator =
+                Comparator.comparing(Person::getFirstName)
+                .thenComparing(Person::getLastName)
+                .thenComparing(Person::getHeight);
+
+    }
+
+
+}
+class Person implements Comparable{
+    private int age;
+    private  int height;
+    private String firstName;
+    private String lastName;
+    private Person dad;
+
+    public Person getDad() {
+        return dad;
+    }
+
+    public void setDad(Person dad) {
+        this.dad = dad;
+    }
+
+    public Person() {
+    }
+
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+
+    public void setLastName(String lastName) {
+        this.lastName = lastName;
+    }
+
+    public int getHeight() {
+        return height;
+    }
+
+    public void setHeight(int height) {
+        this.height = height;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+
+    @Override
+    public int compareTo(Object o) {
+        return 1;
+    }
+}

Diff for: out/production/main/datastructures/graph/Graph.class

@@ -0,0 +1,36 @@
+package javarecipies.java8;
+
+import edu.princeton.cs.algs4.In;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.*;
+
+public class NewFunctionalInterfaces {
+
+    public static void main(String[] args) {
+        Consumer<Object> printer = System.out::println;
+        printer.accept("Dhananjay");
+
+        DoubleConsumer doubleConsumer = System.out::println;
+        doubleConsumer.accept(2.1d);
+
+        Supplier<ArrayList<String>> listSupplier = ArrayList::new;
+        List<String> list = listSupplier.get();
+        list.add("Dhananjay");
+        list.add("Nagargoje");
+        printer.accept(list);
+
+        BiFunction<Double, Double, Double> power = Math::pow;
+        printer.accept(power.apply(2.0d, 3.0d));
+
+        Predicate<Integer> isGreaterThan10 = x-> x>10;
+        printer.accept(isGreaterThan10.test(9));
+
+
+
+
+
+    }
+
+}