add examples in java 8 (#12)

* code for chapters 3-9 in Java

* code for chapters 1 in Java

* code for chapter 2 in Java

* missing CheckVoter for chapter 5 in Java

* add missing sample output for SetCovering as a comment

04_quicksort/java/01_loop_sum/src/LoopSum.java

@@ -0,0 +1,15 @@
+public class LoopSum {
+
+    private static int sum(int[] arr) {
+        int total = 0;
+        for (int x = 0; x < arr.length; x++) {
+            total += arr[x];
+        }
+
+        return total;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(sum(new int[]{1, 2, 3, 4})); // 10
+    }
+}

04_quicksort/java/02_recursive_sum/src/RecursiveSum.java

@@ -0,0 +1,16 @@
+import java.util.Arrays;
+
+public class RecursiveSum {
+
+    private static int sum(int[] arr) {
+        if (arr.length == 0) {
+            return 0;
+        } else {
+            return arr[0] + sum(Arrays.copyOfRange(arr, 1, arr.length));
+        }
+    }
+
+    public static void main(String[] args) {
+        System.out.println(sum(new int[]{1, 2, 3, 4})); // 10
+    }
+}

04_quicksort/java/03_recursive_count/src/RecursiveCount.java

@@ -0,0 +1,16 @@
+import java.util.Arrays;
+
+public class RecursiveCount {
+
+    private static int count(int[] list) {
+        if (list.length == 0) {
+            return 0;
+        }
+
+        return 1 + count(Arrays.copyOfRange(list, 1, list.length));
+    }
+
+    public static void main(String[] args) {
+        System.out.println(count(new int[]{0, 1, 2, 3, 4, 5})); // 6
+    }
+}

04_quicksort/java/04_recursive_max/src/RecursiveMax.java

@@ -0,0 +1,17 @@
+import java.util.Arrays;
+
+public class RecursiveMax {
+
+    private static int max(int[] list) {
+        if (list.length == 2) {
+            return list[0] > list[1] ? list[0] : list[1];
+        }
+
+        int subMax = max(Arrays.copyOfRange(list, 1, list.length));
+        return list[0] > subMax ? list[0] : subMax;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(max(new int[]{1, 5, 10, 25, 16, 1})); // 25
+    }
+}

04_quicksort/java/05_quicksort/src/Quicksort.java

@@ -0,0 +1,35 @@
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class Quicksort {
+    public static void main(String[] args) {
+        System.out.println(quicksort(Arrays.asList(10, 5, 2, 3))); // [2, 3, 5, 10]
+    }
+
+    private static List<Integer> quicksort(List<Integer> list) {
+        if (list.size() < 2) {
+            // base case, arrays with 0 or 1 element are already "sorted"
+            return list;
+        } else {
+            // recursive case
+            Integer pivot = list.get(0);
+
+            // sub-array of all the elements less than the pivot
+            List<Integer> less = list.stream().skip(1).filter(el -> el <= pivot)
+                    .collect(Collectors.toList());
+
+            // sub-array of all the elements greater than the pivot
+            List<Integer> greater = list.stream().skip(1).filter(el -> el > pivot)
+                    .collect(Collectors.toList());
+
+            return Stream.of(
+                    quicksort(less).stream(),
+                    Stream.of(pivot),
+                    quicksort(greater).stream())
+                    .flatMap(Function.identity()).collect(Collectors.toList());
+        }
+    }
+}