diff --git a/pom.xml b/pom.xml
index 10e5035e..21cf3d92 100644
--- a/pom.xml
+++ b/pom.xml
@@ -7,7 +7,7 @@
     <groupId>manning</groupId>
     <artifactId>lambdasinaction</artifactId>
     <version>1.0</version>
-    
+
     <properties>
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>
@@ -37,8 +37,8 @@
         <artifactId>maven-compiler-plugin</artifactId>
         <version>3.1</version>
         <configuration>
-          <source>1.9</source>
-          <target>1.9</target>
+          <source>1.8</source>
+          <target>1.8</target>
         </configuration>
       </plugin>
       <plugin>
@@ -53,7 +53,8 @@
             <configuration>
               <finalName>benchmarks</finalName>
               <transformers>
-                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                <transformer
+                        implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                   <mainClass>org.openjdk.jmh.Main</mainClass>
                 </transformer>
               </transformers>
diff --git a/src/main/java/lambdasinaction/chap10/OperationsWithOptional.java b/src/main/java/lambdasinaction/chap10/OperationsWithOptional.java
index d2940969..f2c4d28e 100644
--- a/src/main/java/lambdasinaction/chap10/OperationsWithOptional.java
+++ b/src/main/java/lambdasinaction/chap10/OperationsWithOptional.java
@@ -1,9 +1,9 @@
 package lambdasinaction.chap10;
 
-import java.util.*;
+import java.util.Optional;
 
-import static java.util.Optional.of;
 import static java.util.Optional.empty;
+import static java.util.Optional.of;
 
 public class OperationsWithOptional {
 
@@ -11,15 +11,15 @@ public static void main(String... args) {
         System.out.println(max(of(3), of(5)));
         System.out.println(max(empty(), of(5)));
 
-        Optional<Integer> opt1 = of(5);
-        Optional<Integer> opt2 = opt1.or(() -> of(4));
-
-        System.out.println(
-        of(5).or(() -> of(4))
-                          );
+//        Optional<Integer> opt1 = of(5);
+//        Optional<Integer> opt2 = opt1.or(() -> of(4));
+//
+//        System.out.println(
+//        of(5).or(() -> of(4))
+//                          );
     }
 
     public static final Optional<Integer> max(Optional<Integer> i, Optional<Integer> j) {
-         return i.flatMap(a -> j.map(b -> Math.max(a, b)));
+        return i.flatMap(a -> j.map(b -> Math.max(a, b)));
     }
 }
diff --git a/src/main/java/lambdasinaction/chap10/OptionalMain.java b/src/main/java/lambdasinaction/chap10/OptionalMain.java
index dcd97792..30c31dac 100644
--- a/src/main/java/lambdasinaction/chap10/OptionalMain.java
+++ b/src/main/java/lambdasinaction/chap10/OptionalMain.java
@@ -1,24 +1,25 @@
 package lambdasinaction.chap10;
 
-import java.util.*;
-
-import static java.util.stream.Collectors.toSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
 
 public class OptionalMain {
 
     public String getCarInsuranceName(Optional<Person> person) {
         return person.flatMap(Person::getCar)
-                     .flatMap(Car::getInsurance)
-                     .map(Insurance::getName)
-                     .orElse("Unknown");
+                .flatMap(Car::getInsurance)
+                .map(Insurance::getName)
+                .orElse("Unknown");
     }
 
     public Set<String> getCarInsuranceNames(List<Person> persons) {
-        return persons.stream()
-                      .map(Person::getCar)
-                      .map(optCar -> optCar.flatMap(Car::getInsurance))
-                      .map(optInsurance -> optInsurance.map(Insurance::getName))
-                      .flatMap(Optional::stream)
-                      .collect(toSet());
+//        return persons.stream()
+//                      .map(Person::getCar)
+//                      .map(optCar -> optCar.flatMap(Car::getInsurance))
+//                      .map(optInsurance -> optInsurance.map(Insurance::getName))
+//                      .flatMap(Optional::stream)
+//                      .collect(toSet());
+        return null;
     }
 }
diff --git a/src/main/java/lambdasinaction/chap6/Grouping.java b/src/main/java/lambdasinaction/chap6/Grouping.java
index 9105cc80..09b1e506 100644
--- a/src/main/java/lambdasinaction/chap6/Grouping.java
+++ b/src/main/java/lambdasinaction/chap6/Grouping.java
@@ -1,16 +1,27 @@
 package lambdasinaction.chap6;
 
-import java.util.*;
-
-import static java.util.stream.Collectors.*;
-import static lambdasinaction.chap6.Dish.dishTags;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+
+import static java.util.stream.Collectors.collectingAndThen;
+import static java.util.stream.Collectors.counting;
+import static java.util.stream.Collectors.groupingBy;
+import static java.util.stream.Collectors.mapping;
+import static java.util.stream.Collectors.reducing;
+import static java.util.stream.Collectors.summingInt;
+import static java.util.stream.Collectors.toList;
+import static java.util.stream.Collectors.toSet;
 import static lambdasinaction.chap6.Dish.menu;
 
 public class Grouping {
 
-    enum CaloricLevel { DIET, NORMAL, FAT };
+    enum CaloricLevel {DIET, NORMAL, FAT}
+
+    ;
 
-    public static void main(String ... args) {
+    public static void main(String... args) {
         System.out.println("Dishes grouped by type: " + groupDishesByType());
         System.out.println("Dish names grouped by type: " + groupDishNamesByType());
         System.out.println("Dish tags grouped by type: " + groupDishTagsByType());
@@ -33,12 +44,14 @@ private static Map<Dish.Type, List<String>> groupDishNamesByType() {
     }
 
     private static Map<Dish.Type, Set<String>> groupDishTagsByType() {
-        return menu.stream().collect(groupingBy(Dish::getType, flatMapping(dish -> dishTags.get( dish.getName() ).stream(), toSet())));
+        return null;
+        //return menu.stream().collect(groupingBy(Dish::getType, flatMapping(dish -> dishTags.get( dish.getName() ).stream(), toSet())));
     }
 
     private static Map<Dish.Type, List<Dish>> groupCaloricDishesByType() {
+        return null;
 //        return menu.stream().filter(dish -> dish.getCalories() > 500).collect(groupingBy(Dish::getType));
-        return menu.stream().collect(groupingBy(Dish::getType, filtering(dish -> dish.getCalories() > 500, toList())));
+        // return menu.stream().collect(groupingBy(Dish::getType, filtering(dish -> dish.getCalories() > 500, toList())));
     }
 
     private static Map<CaloricLevel, List<Dish>> groupDishesByCaloricLevel() {
@@ -47,7 +60,7 @@ private static Map<CaloricLevel, List<Dish>> groupDishesByCaloricLevel() {
                     if (dish.getCalories() <= 400) return CaloricLevel.DIET;
                     else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
                     else return CaloricLevel.FAT;
-                } ));
+                }));
     }
 
     private static Map<Dish.Type, Map<CaloricLevel, List<Dish>>> groupDishedByTypeAndCaloricLevel() {
@@ -57,7 +70,7 @@ private static Map<Dish.Type, Map<CaloricLevel, List<Dish>>> groupDishedByTypeAn
                             if (dish.getCalories() <= 400) return CaloricLevel.DIET;
                             else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
                             else return CaloricLevel.FAT;
-                        } )
+                        })
                 )
         );
     }
@@ -88,9 +101,11 @@ private static Map<Dish.Type, Integer> sumCaloriesByType() {
     private static Map<Dish.Type, Set<CaloricLevel>> caloricLevelsByType() {
         return menu.stream().collect(
                 groupingBy(Dish::getType, mapping(
-                        dish -> { if (dish.getCalories() <= 400) return CaloricLevel.DIET;
-                        else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
-                        else return CaloricLevel.FAT; },
-                        toSet() )));
+                        dish -> {
+                            if (dish.getCalories() <= 400) return CaloricLevel.DIET;
+                            else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
+                            else return CaloricLevel.FAT;
+                        },
+                        toSet())));
     }
 }
diff --git a/src/main/java/lambdasinaction/chap6/PartitionPrimeNumbers.java b/src/main/java/lambdasinaction/chap6/PartitionPrimeNumbers.java
index 69d7c4ca..3293a16e 100644
--- a/src/main/java/lambdasinaction/chap6/PartitionPrimeNumbers.java
+++ b/src/main/java/lambdasinaction/chap6/PartitionPrimeNumbers.java
@@ -1,15 +1,26 @@
 package lambdasinaction.chap6;
 
-import java.util.*;
-import java.util.function.*;
-import java.util.stream.*;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.BiConsumer;
+import java.util.function.BinaryOperator;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collector;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
 
-import static java.util.stream.Collectors.*;
-import static java.util.stream.Collector.Characteristics.*;
+import static java.util.stream.Collector.Characteristics.IDENTITY_FINISH;
+import static java.util.stream.Collectors.partitioningBy;
 
 public class PartitionPrimeNumbers {
 
-    public static void main(String ... args) {
+    public static void main(String... args) {
         System.out.println("Numbers partitioned in prime and non-prime: " + partitionPrimes(100));
         System.out.println("Numbers partitioned in prime and non-prime: " + partitionPrimesWithCustomCollector(100));
 
@@ -21,7 +32,7 @@ public static Map<Boolean, List<Integer>> partitionPrimes(int n) {
     }
 
     public static boolean isPrime(int candidate) {
-        return IntStream.rangeClosed(2, candidate-1)
+        return IntStream.rangeClosed(2, candidate - 1)
                 .limit((long) Math.floor(Math.sqrt((double) candidate)) - 1)
                 .noneMatch(i -> candidate % i == 0);
     }
@@ -33,20 +44,22 @@ public static Map<Boolean, List<Integer>> partitionPrimesWithCustomCollector(int
     public static boolean isPrime(List<Integer> primes, Integer candidate) {
         double candidateRoot = Math.sqrt((double) candidate);
         //return takeWhile(primes, i -> i <= candidateRoot).stream().noneMatch(i -> candidate % i == 0);
-        return primes.stream().takeWhile(i -> i <= candidateRoot).noneMatch(i -> candidate % i == 0);
+//        return primes.stream().takeWhile(i -> i <= candidateRoot).noneMatch(i -> candidate % i == 0);
+        return true;
     }
-/*
-    public static <A> List<A> takeWhile(List<A> list, Predicate<A> p) {
-        int i = 0;
-        for (A item : list) {
-            if (!p.test(item)) {
-                return list.subList(0, i);
+
+    /*
+        public static <A> List<A> takeWhile(List<A> list, Predicate<A> p) {
+            int i = 0;
+            for (A item : list) {
+                if (!p.test(item)) {
+                    return list.subList(0, i);
+                }
+                i++;
             }
-            i++;
+            return list;
         }
-        return list;
-    }
-*/
+    */
     public static class PrimeNumbersCollector
             implements Collector<Integer, Map<Boolean, List<Integer>>, Map<Boolean, List<Integer>>> {
 
@@ -61,8 +74,8 @@ public Supplier<Map<Boolean, List<Integer>>> supplier() {
         @Override
         public BiConsumer<Map<Boolean, List<Integer>>, Integer> accumulator() {
             return (Map<Boolean, List<Integer>> acc, Integer candidate) -> {
-                acc.get( isPrime( acc.get(true),
-                        candidate) )
+                acc.get(isPrime(acc.get(true),
+                        candidate))
                         .add(candidate);
             };
         }
@@ -95,7 +108,7 @@ public Map<Boolean, List<Integer>> partitionPrimesWithInlineCollector(int n) {
                             put(false, new ArrayList<Integer>());
                         }},
                         (acc, candidate) -> {
-                            acc.get( isPrime(acc.get(true), candidate) )
+                            acc.get(isPrime(acc.get(true), candidate))
                                     .add(candidate);
                         },
                         (map1, map2) -> {
diff --git a/src/main/java/lambdasinaction/demo/Demo01.java b/src/main/java/lambdasinaction/demo/Demo01.java
new file mode 100644
index 00000000..a17e0327
--- /dev/null
+++ b/src/main/java/lambdasinaction/demo/Demo01.java
@@ -0,0 +1,20 @@
+package lambdasinaction.demo;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author zhoukai
+ * @date 2019/9/3
+ */
+public class Demo01 {
+
+    public static void main(String[] args) {
+        List<String> list = new ArrayList<>();
+        list.add("1");
+        list.add("2");
+        list.add("3");
+        list.stream().forEach(p -> System.out.printf(p));
+
+    }
+}