Stream Exercises

Author: jorisbaiutti

src/StreamExercises/Exercise1.java

@@ -0,0 +1,28 @@
+package StreamExercises;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Created by joris on 19.01.17.
+ */
+
+/*
+Given is a list of the following Strings: "adam", "eva", "anna", "maria", "ruth".
+We want to print all names starting with ‘A’ in a sorted way. Use streams in combination with
+stream operations to solve the problem.
+Output is:
+ADAM
+ANNA
+ */
+public class Exercise1 {
+
+    public static void main(String[] args) {
+        List<String> myList = Arrays.asList("adam", "eva", "anna", "maria", "ruth");
+        myList.stream()
+                .filter(a -> a.startsWith("a"))
+                .map(String::toUpperCase)
+                .sorted()
+                .forEach(System.out::println);
+    }
+}

src/StreamExercises/Exercise10.java

@@ -0,0 +1,39 @@
+package StreamExercises;
+
+import java.util.stream.Stream;
+
+/**
+ * Created by joris on 19.01.17.
+ */
+public class Exercise10 {
+    public static void main(String[] args) {
+        Stream.of("Anna", "Adam", "Eva", "Tom", "Kurt")
+                .map(s -> {
+                    System.out.println("map: " + s);
+                    return s.toUpperCase();
+                })
+                .filter(s -> {
+                    System.out.println("filter: " + s);
+                    return s.startsWith("A");
+                })
+                //prints foreach only for the filtered values
+                .forEach(s -> System.out.println("forEach: " + s));
+    }
+}
+
+/*
+Output:
+map: Anna
+filter: ANNA
+forEach: ANNA
+map: Adam
+filter: ADAM
+forEach: ADAM
+map: Eva
+filter: EVA
+map: Tom
+filter: TOM
+map: Kurt
+filter: KURT
+
+ */

src/StreamExercises/Exercise11.java

@@ -0,0 +1,39 @@
+package StreamExercises;
+
+import java.util.stream.Stream;
+
+/**
+ * Created by joris on 19.01.17.
+ */
+public class Exercise11 {
+    public static void main(String[] args) {
+        Stream.of("Anna", "Adam", "Eva", "Tom", "Kurt")
+                .filter(s -> {
+                    System.out.println("filter: " + s);
+                    return s.startsWith("A");
+                })
+                .sorted((s1, s2) -> {
+                    System.out.printf("sort: %s; %s\n", s1, s2);
+                    return s1.compareTo(s2);
+                })
+                .map(s -> {
+                    System.out.println("map: " + s);
+                    return s.toUpperCase();
+                })
+                .forEach(s -> System.out.println("forEach: " + s));
+    }
+}
+
+/*
+Output:
+filter: Anna
+filter: Adam
+filter: Eva
+filter: Tom
+filter: Kurt
+sort: Adam; Anna
+map: Adam
+forEach: ADAM
+map: Anna
+forEach: ANNA
+ */

src/StreamExercises/Exercise12.java

@@ -0,0 +1,21 @@
+package StreamExercises;
+
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+/**
+ * Created by joris on 19.01.17.
+ */
+public class Exercise12 {
+    public static void main(String[] args) {
+        Supplier<Stream<String>> streamSupplier = () -> Stream.of("Anna", "Adam", "Eva", "Tom", "Kurt")
+                        .filter(s -> s.startsWith("A"));
+        System.out.println(streamSupplier.get().anyMatch(s -> true));
+        System.out.println(streamSupplier.get().noneMatch(s -> true));
+    }
+}
+
+/*
+true
+false
+ */

src/StreamExercises/Exercise13.java

@@ -0,0 +1,21 @@
+package StreamExercises;
+
+import java.util.stream.Stream;
+
+/**
+ * Created by joris on 19.01.17.
+ */
+public class Exercise13 {
+    public static void main(String[] args) {
+        Stream<String> stream = Stream.of("Anna", "Adam", "Eva", "Tom", "Kurt")
+                .filter(s -> s.startsWith("A"));
+        System.out.println(stream.anyMatch(s -> true));
+        System.out.println(stream.noneMatch(s -> true));
+    }
+}
+/*
+Output:
+Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
+	at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:229)
+	at java.util.stream.ReferencePipeline.noneMatch(ReferencePipeline.java:459)
+ */

src/StreamExercises/Exercise14.java

@@ -0,0 +1,48 @@
+package StreamExercises;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * Created by joris on 19.01.17.
+ */
+/*
+Define a simple Person class.
+Then create a list of Persons with:
+List<Person> persons = Arrays.asList(
+new Person("Adam", 18),
+new Person("Peter", 23),
+new Person("Eva", 23),
+new Person("Moriz", 62),
+new Person("Max", 42));
+Use streams and functions to create a new filtered list which contains only persons which name start with M. Then display the new list.
+Output is:
+[Moriz, Max]
+ */
+public class Exercise14 {
+
+
+    public static void main(String[] args) {
+         class Person{
+            String name;
+            int age;
+
+            public Person(String name,int age){
+                this.name = name;
+                this.age = age;
+            }
+            public String toString(){return name;}
+        }
+
+        List<Person> persons = Arrays.asList(new Person("Adam", 18), new Person("Peter", 23), new Person("Eva", 23), new Person("Moriz", 62), new Person("Max", 42));
+
+         List<Person> filteredpersons = persons.stream()
+                 .filter(p -> p.name.startsWith("M"))
+                 .collect(Collectors.toList());
+         System.out.println(filteredpersons.toString());
+
+        System.out.println(persons.stream().map(p -> p.age).reduce((a,b) -> a+b));
+
+    }
+}

src/StreamExercises/Exercise15.java

@@ -0,0 +1,42 @@
+package StreamExercises;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * Created by joris on 19.01.17.
+ */
+/*
+We have the same situation as in the above exercise. Use streams and functions to calculate the
+average age of all persons. The average shall be calculated and displayed as a double.
+Output is:
+33.6
+Solution:
+ */
+public class Exercise15 {
+    public static void main(String[] args) {
+        class Person{
+            String name;
+            int age;
+
+            public Person(String name,int age){
+                this.name = name;
+                this.age = age;
+            }
+            public String toString(){return name;}
+        }
+
+        List<Person> persons = Arrays.asList(new Person("Adam", 18), new Person("Peter", 23), new Person("Eva", 23), new Person("Moriz", 62), new Person("Max", 42));
+
+        persons.stream().mapToDouble(p -> p.age)
+                .average()
+                .ifPresent(System.out::println);
+
+        //alternate Solution
+        Double averageAge = persons
+                .stream()
+                .collect(Collectors.averagingInt(p -> p.age));
+        System.out.println(averageAge);
+    }
+}

src/StreamExercises/Exercise16.java

@@ -0,0 +1,49 @@
+package StreamExercises;
+
+import java.util.Arrays;
+import java.util.IntSummaryStatistics;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * Created by joris on 19.01.17.
+ */
+/*
+We have the same situation as in the above exercise.
+Use streams and functions to calculate and display the following:
+ Number of elements.
+ The sum of all ages.
+ The minimum age.
+ The average age.
+ The maximum age.
+Hint: Use IntSummaryStatistics and Collectors.summarizingInt.
+Output is:
+IntSummaryStatistics{count=5, sum=168, min=18, average=33.600000, max=62}
+ */
+public class Exercise16 {
+
+    public static void main(String[] args) {
+
+
+        class Person {
+            String name;
+            int age;
+
+            public Person(String name, int age) {
+                this.name = name;
+                this.age = age;
+            }
+
+            public String toString() {
+                return name;
+            }
+        }
+
+        List<Person> persons = Arrays.asList(new Person("Adam", 18), new Person("Peter", 23), new Person("Eva", 23), new Person("Moriz", 62), new Person("Max", 42));
+
+        IntSummaryStatistics agesummary = persons.stream()
+                .collect(Collectors.summarizingInt(p -> p.age));
+        System.out.println(agesummary);
+    }
+
+}

src/StreamExercises/Exercise17.java

@@ -0,0 +1,53 @@
+package StreamExercises;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * Created by joris on 19.01.17.
+ */
+/*
+We have the same situation as in the above before.
+This time we want to create a String which contains the names of all persons which are of legal
+age (>=18) in Switzerland.
+When we print this String it shall show something like: In Switzerland Adam and Peter
+and Eva and Moriz and Max are of legal age.
+Again: Use streams and functions to create the String.
+Hint: Use Collectors.joining to create the final result.
+Output is:
+In Switzerland Adam and Peter and Eva and Moriz and Max are of legal age.
+ */
+public class Exercise17 {
+    public static void main(String[] args) {
+        class Person {
+            String name;
+            int age;
+
+            public Person(String name, int age) {
+                this.name = name;
+                this.age = age;
+            }
+
+            public String toString() {
+                return name;
+            }
+        }
+
+        List<Person> persons = Arrays.asList(new Person("Adam", 18), new Person("Peter", 23), new Person("Eva", 23), new Person("Moriz", 62), new Person("Max", 42));
+
+        String phrase = persons.stream()
+                .filter(p -> p.age >= 18)
+                .map(p -> p.name)
+                .collect(Collectors.joining(" and ", "In Switzerland ", " are of legal age"));
+        System.out.println(phrase);
+
+    }
+}
+
+/*
+String phrase = persons.stream()
+                .filter(p -> p.age >= 18)
+                .map(p -> p.name)
+                .collect(Collectors.joining(delimiter"and", prfix"In Switzerland", suffix"are of legal age"));
+ */

src/StreamExercises/Exercise18.java

@@ -0,0 +1,45 @@
+package StreamExercises;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * Created by joris on 19.01.17.
+ */
+/*
+We have the same situation as in the above before.
+We want to create a Map this time. The map shall contain as key the age off the persons and as
+value a string which contains the person of that age as you see below:
+{18=Adam, 23=Peter;Eva, 42=Max, 62=Moriz}
+Peter and Eva have the same age!
+Again: Use streams and functions to create the Map.
+Hint: Use Collectors.toMap to create the final result.
+Output is:
+{18=Adam, 23=Peter;Eva, 42=Max, 62=Moriz}
+ */
+public class Exercise18 {
+    public static void main(String[] args) {
+        class Person {
+            String name;
+            int age;
+
+            public Person(String name, int age) {
+                this.name = name;
+                this.age = age;
+            }
+
+            public String toString() {
+                return name;
+            }
+        }
+
+        List<Person> persons = Arrays.asList(new Person("Adam", 18), new Person("Peter", 23), new Person("Eva", 23), new Person("Moriz", 62), new Person("Max", 42));
+
+        Map<Integer,String> personmap = persons.stream()
+                //third paramater merges, when to items with same key
+                .collect(Collectors.toMap(p -> p.age,p -> p.name,(name1,name2) -> name1 + ";" + name2));
+        System.out.println(personmap);
+    }
+}