Stream接口&Function

Author: MyHerux

src/main/java/com/xu/java8/Function/BiConsumerTest.java

@@ -0,0 +1,13 @@
+package com.xu.java8.Function;
+
+import java.util.function.BiConsumer;
+
+/**
+ * Created by xu on 2017/5/10.
+ */
+public class BiConsumerTest {
+    public static void main(String[] args) {
+        //return void
+        BiConsumer<Integer,Integer> accept=(x,y)->{};
+    }
+}

src/main/java/com/xu/java8/Function/BiFunctionTest.java

@@ -0,0 +1,12 @@
+package com.xu.java8.Function;
+
+
+import java.util.function.BiFunction;
+
+public class BiFunctionTest {
+
+    public static void main(String[] args) {
+        BiFunction<Integer, Integer, Integer> add = (x, y) -> x + y;
+        System.out.println(add.apply(10,20));
+    }
+}

src/main/java/com/xu/java8/Function/ConsumerTest.java

@@ -0,0 +1,13 @@
+package com.xu.java8.Function;
+
+import java.util.function.Consumer;
+
+/**
+ * Created by xu on 2017/5/10.
+ */
+public class ConsumerTest {
+    public static void main(String[] args) {
+        //return void
+        Consumer<Integer> accept=x->{};
+    }
+}

src/main/java/com/xu/java8/Function/FunctionTest.java

@@ -0,0 +1,28 @@
+package com.xu.java8.Function;
+
+
+import java.util.function.Function;
+
+public class FunctionTest {
+
+
+    public static void main(String[] args) {
+
+        Function<Integer, Integer> times2 = e -> e * 2;
+        Function<Integer, Integer> squared = e -> e * e;
+        Function<Integer, Integer> identity = Function.identity();
+
+        //return 8 - > 4 * 2
+        Integer a = times2.apply(4);
+        System.out.println(a);
+        //return 32 - > 4 ^ 2 * 2
+        Integer b = times2.compose(squared).apply(4);
+        System.out.println(b);
+        //return 64 - > (4 * 2) ^ 2
+        Integer c = times2.andThen(squared).apply(4);
+        System.out.println(c);
+        //return 4
+        Integer d = identity.apply(4);
+        System.out.println(d);
+    }
+}

src/main/java/com/xu/java8/Function/PredicateTest.java

@@ -0,0 +1,14 @@
+package com.xu.java8.Function;
+
+import java.util.function.Predicate;
+
+/**
+ * Created by xu on 2017/5/10.
+ */
+public class PredicateTest {
+
+    public static void main(String[] args) {
+        Predicate<String> predicate=x->x.startsWith("a");
+        System.out.println(predicate.test("abc"));
+    }
+}

src/main/java/com/xu/java8/Function/SupplierTest.java

@@ -0,0 +1,14 @@
+package com.xu.java8.Function;
+
+import java.util.function.Supplier;
+
+/**
+ * Created by xu on 2017/5/10.
+ */
+public class SupplierTest {
+    public static void main(String[] args) {
+        Supplier<Integer> get= () -> 10;
+        Integer a=get.get();
+        System.out.println(a);
+    }
+}

src/main/java/com/xu/java8/Stream/Collect.java

@@ -0,0 +1,83 @@
+package com.xu.java8.Stream;
+
+
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.Collectors;
+
+public class Collect {
+
+    public static void main(String[] args) {
+        List<String> stringCollection = new ArrayList<>();
+        stringCollection.add("ddd2");
+        stringCollection.add("aaa1");
+        stringCollection.add("bbb1");
+        stringCollection.add("aaa1");
+
+        System.out.println(stringCollection);
+
+        System.out.println(stringCollection.stream().filter(x -> x.startsWith("a")).collect(Collectors.toList()));
+
+        System.out.println(stringCollection.stream().filter(x -> x.startsWith("a")).collect(Collectors.toSet()));
+
+        List<String> list = stringCollection.stream()
+                .filter(x -> x.startsWith("a"))
+                .collect(Collectors.toCollection(ArrayList::new));
+        System.out.println(list);
+
+        Function<String, String> xu = x -> x + "_xu";
+        Map<String, String> map = stringCollection.stream()
+                .filter(x -> x.startsWith("a"))
+                .distinct()
+                .collect(Collectors.toMap(Function.identity(), xu));
+        System.out.println(map);
+
+        Predicate<String> startA = x -> x.startsWith("a");
+        Map<Boolean, List<String>> map2 = stringCollection.stream()
+                .collect(Collectors.partitioningBy(startA));
+        System.out.println(map2);
+
+        Predicate<String> end1 = x -> x.endsWith("1");
+        Map<Boolean, Map<Boolean, List<String>>> map3 = stringCollection.stream()
+                .collect(Collectors.partitioningBy(startA, Collectors.partitioningBy(end1)));
+        System.out.println("map3:" + map3);
+
+        Function<String, String> stringStart = x -> String.valueOf(x.charAt(0));
+        Map<String, List<String>> map4 = stringCollection.stream()
+                .collect(Collectors.groupingBy(stringStart));
+        System.out.println("map4:" + map4);
+
+        Map<String, Long> map5 = stringCollection.stream()
+                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
+        System.out.println("map5:" + map5);
+
+        Map<String, Long> map6 = stringCollection.stream()
+                .collect(Collectors.groupingBy(stringStart, LinkedHashMap::new, Collectors.counting()));
+        System.out.println("map6:" + map6);
+
+        Supplier<List<String>> supplier = ArrayList::new;
+        BiConsumer<List<String>, String> accumulator = List::add;
+        BiConsumer<List<String>, List<String>> combiner = List::addAll;
+        List<String> list1 = stringCollection.stream()
+                .filter(x -> x.startsWith("a"))
+                .collect(supplier, accumulator, combiner);
+        System.out.println("list1:" + list1);
+
+        BinaryOperator<String> binaryOperator = (x, y) -> x + y;
+        String reduceStr1 = stringCollection.stream().reduce(binaryOperator).orElse("");
+        System.out.println("reduceStr1: " + reduceStr1);
+
+        String reduceStr2 = stringCollection.stream().reduce("start:", binaryOperator);
+        System.out.println("reduceStr1: " + reduceStr2);
+
+        List<Person> personList = new ArrayList<>();
+        personList.add(new Person(10, 20));
+        personList.add(new Person(20, 30));
+        personList.add(new Person(30, 50));
+
+        BiFunction<Person, Person, Person> biFunction = (x, y) -> new Person(x.getAge() + y.getAge(), x.getRate() + y.getRate());
+        BinaryOperator<Person> binaryOperator1 = (x, y) -> new Person(x.getAge() + y.getAge(), x.getRate() + y.getRate());
+        Person total = personList.parallelStream().reduce(new Person(0, 0), biFunction, binaryOperator1);
+        System.out.println("total:"+total);
+    }
+}

src/main/java/com/xu/java8/lambda/Lambda2.java

@@ -62,6 +62,8 @@ public Integer convert(String from) {
         System.out.println(converted4);    // result J
 
         /**简写的lambda表达式:constructor*/
+        Person p=new Person("xu","hua");
+        Person p2=new Person("xu","hua","");
         PersonFactory<Person> personFactory = Person::new;
         Person person = personFactory.create("xu", "hua");//Java编译器会自动根据PersonFactory.create方法的签名来选择合适的构造函数。
         System.out.println(person.toString());

src/main/java/com/xu/java8/lambda/Person.java

@@ -12,6 +12,15 @@ public Person(String firstName, String lastName) {
         this.lastName = lastName;
     }
 
+    public Person(String firstName, String lastName,String cc) {
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+
+    public void add(String firstName){
+
+    }
+
     public String toString(){
         return firstName+lastName;
     }