Java8新特性(Lambda表达式、Stream流、Optional类)等
1. Lambda表达式由来
1 package java8; 2 3 public class EmployeeTest { 4 public static void main(String[] args) { 5 6 Employee employee1 = new EmployeeImpl(); 7 employee1.getSalary(); 8 System.out.println("****************"); 9 10 11 Employee employee2 = new Employee() { 12 @Override 13 public void getSalary() { 14 System.out.println("Employee匿名内部类"); 15 } 16 }; 17 employee2.getSalary(); 18 System.out.println("****************"); 19 20 /** 21 * lambda表达式可以看作是一个接口的实例，使用lambda是有前提条件的，就是该接口必须是函数式接口。 22 * 那么什么是函数式接口呢？用一句话总结就是有且仅有一个抽象方法的接口(在java提供的类库中，函数式接口上面都有@FunctionalInterface注解) 23 * 24 * lambda表达式可以总结为：一个(), 一个 ->, 一段代码{} 25 * 一个()：参数 26 * 一段代码{}：具体业务逻辑 27 */ 28 Employee employee3 = () -> { 29 System.out.println("将上述匿名内部类转为使用lambda表达式"); 30 }; 31 employee3.getSalary(); 32 } 33 34 interface Employee { 35 public void getSalary(); 36 } 37 38 static class EmployeeImpl implements Employee { 39 40 @Override 41 public void getSalary() { 42 System.out.print("Employee的普通实现类"); 43 } 44 } 45 }
2. Stream流
2.1 函数型接口Function定义
1 package java8; 2 3 import java.util.function.Function; 4 5 /** 6 * 1. 函数型接口Function<T,R>：有输入，有输出 7 * 核心抽象方法为 抽象方法 R apply(T t); 8 */ 9 public class FunctionInterface1 { 10 11 public static void main(String[] args) { 12 // 通过lambda实例化一个接口，实现抽象方法R apply(T t); 13 Function<String, Integer> function = (s) -> { 14 if (s == null) { 15 return 0; 16 } 17 return s.length(); 18 }; 19 Integer result = testFunction("hello", function); 20 System.out.println(result); 21 22 System.out.println("****************"); 23 System.out.println(testFunction("hello", s -> { 24 return "更简化的写法".length(); 25 })); 26 } 27 28 29 // interface Function<T, R> 抽象方法 R apply(T t); 30 private static Integer testFunction(String str, Function<String, Integer> function) { 31 // str作为第13行的参数s进行传递 32 return function.apply(str); 33 } 34 }
结果
5
****************
6
2.1 函数型接口Function类型
- 函数型接口Function<T,R>
-
抽象方法 R apply(T t)
-
- 消费型接口Consumer<T>
- 抽象方法：void accept(T t)
- 供给型接口Supplier<T>
- 抽象方法：T get()
- 断言型接口Predicate<T>
- 抽象方法：boolean test(T t)
1 package java8; 2 3 import java.util.function.Function; 4 5 /** 6 * 1. 函数型接口Function<T,R>：有输入，有输出 7 * 核心抽象方法为 抽象方法 R apply(T t); 8 */ 9 public class FunctionInterface1 { 10 11 public static void main(String[] args) { 12 // 通过lambda实例化一个接口，实现抽象方法R apply(T t); 13 Function<String, Integer> function = (s) -> { 14 if (s == null) { 15 return 0; 16 } 17 return s.length(); 18 }; 19 Integer result = testFunction("hello", function); 20 System.out.println(result); 21 22 System.out.println("****************"); 23 System.out.println(testFunction("hello", s -> { 24 return "更简化的写法".length(); 25 })); 26 } 27 28 29 // interface Function<T, R> 抽象方法 R apply(T t); 30 private static Integer testFunction(String str, Function<String, Integer> function) { 31 // str作为第13行的参数s进行传递 32 return function.apply(str); 33 } 34 }
1 package java8; 2 3 import java.util.function.Consumer; 4 5 /** 6 * Consumer<T> 消费性接口有输入，但是没有返回值 7 * 抽象方法：void accept(T t); 8 */ 9 public class ConsuerFunctionInterface { 10 11 public static void main(String[] args) { 12 // s是实例化方法accept的参数，{}内部是accept的方法体 13 testConsumer(s -> {System.out.println(s);}, "消费性接口抽象方法accept实现"); 14 } 15 16 private static void testConsumer(Consumer<String> consumer, String str) { 17 consumer.accept(str); 18 } 19 }
1 package java8; 2 3 4 import java.util.function.Supplier; 5 6 /** 7 * Supplier<T> 供给型接口：无输入、有输出 8 * 抽象方法：T get(); 9 */ 10 public class SupplierFunctionInterface { 11 12 public static void main(String[] args) { 13 14 // ()是实例化方法T get()参数：即无参数，{}是get的方法体 15 testSupplier(()-> { 16 String name = "Supplier<Person>的抽象方法get实现"; 17 System.out.println(name); 18 return new Person(name); 19 }); 20 } 21 22 private static Person testSupplier(Supplier<Person> supplier) { 23 return supplier.get(); 24 } 25 26 } 27 28 class Person { 29 private static String name; 30 31 Person(String name) { 32 this.name = name; 33 } 34 }
1 package java8; 2 3 import java.util.function.Predicate; 4 5 /** 6 * 断言型接口Predicate<T> 7 * 抽象方法：boolean test(T t); 8 */ 9 public class PredicateFunctionInterface { 10 11 public static void main(String[] args) { 12 // b是test方法的参数, {}内部是test方法体 13 boolean res = testPredicate((b) -> { 14 System.out.println("断言型接口Predicate抽象方法boolean test(T t)的实例化"); 15 return b > 99; 16 }, 99); 17 18 System.out.println("b>99, res=" + res); 19 } 20 21 22 private static boolean testPredicate(Predicate<Integer> predicate, int a) { 23 return predicate.test(a); 24 } 25 }
2.3 reduce
https://www.cnblogs.com/flydean/p/java-8-stream-reduce.html
https://www.liaoxuefeng.com/wiki/1252599548343744/1322402971648033
https://blog.csdn.net/qq_33351091/article/details/82494855
1 package mtee3rule; 2 3 import java.util.Arrays; 4 import java.util.List; 5 import java.util.Optional; 6 7 public class ReduceTest { 8 9 public static void main(String[] args) { 10 List<Integer> intList = Arrays.asList(1,2,3,4); 11 12 Optional<Integer> result1 = intList.stream().reduce(Integer::sum); 13 System.out.println("result1=" + result1 + ", sum=" + result1.get()); 14 15 Integer result2=intList.stream().reduce(100, Integer::sum); 16 System.out.println("result2=" + result2 + ", sum=" + result2); 17 18 // 每个线程的初始累加值都是100，最后4个线程加出来的结果就是406 19 // 这里sum方法的identity只能是0。所以这里我们传入100是不对的，因为sum（100+1）！= 1。 20 // 如果我们用0作为identity,则stream和parallelStream计算出的结果是一样的。这就是identity的真正意图。 21 Integer result3=intList.parallelStream().reduce(100, Integer::sum); 22 System.out.println("result3=" + result2 + ", sum=" + result3); 23 24 testMultiReduce1(); 25 } 26 27 private static void testMultiReduce1() { 28 List<String> strings = Arrays.asList("1", "2", "4", "5"); 29 30 System.out.println("********in testMultiReduce1()************"); 31 32 // 非并行流 33 Integer reduce1 = strings.stream().reduce(0, 34 (acc, e) -> acc + Integer.valueOf(e), (u, t) -> { 35 // 非并行流，不会执行第三个参数 36 System.out.println("u----:" + u); 37 // 这里的返回值并没有影响返回结果 38 return null; 39 }); 40 System.out.println("reduce1:" + reduce1); 41 42 // 并行流 43 //System.out.println("out_thread=" + Thread.currentThread().getName()); 44 Integer reduce2 = strings.parallelStream().reduce(0, 45 (acc, e) -> acc + Integer.valueOf(e), (u, t) -> { 46 // u，t分别为并行流每个子任务的结果 47 System.out.println("inner_thread=" + Thread.currentThread().getName() + ", u=" + u + ", t=" + t); 48 49 return u + t; 50 }); 51 System.out.println("out_thread=" + Thread.currentThread().getName()); 52 System.out.println("reduce2:" + reduce2); 53 } 54 55 }
结果：
1 result1=Optional[10], sum=10 2 result2=110, sum=110 3 result3=110, sum=410 4 ********in testMultiReduce1()************ 5 reduce1:12 6 inner_thread=ForkJoinPool.commonPool-worker-2, u=1, t=2 // 第一个线程执行 7 inner_thread=main, u=4, t=5 // 第二个线程执行 8 inner_thread=main, u=3, t=9 // u为第6行执行结果3，t为第7行执行结果9 9 out_thread=main 10 reduce2:12 // 第8行执行结果 = 3 + 9
2.4 创建Stream流的方式
2.4.1 ::（双冒号）使用
https://www.jianshu.com/p/96b4815d629e
1 package java8; 2 3 import java.util.Arrays; 4 import java.util.Comparator; 5 import java.util.List; 6 import java.util.Optional; 7 8 public class DoubleMaoHao { 9 10 public static void main(String[] args) { 11 List<String> listStr = Arrays.asList("adnm", "p", "admmt", "pot", "xbangd", "weoujgsd"); 12 13 // 最大的串：实例化Comparator的抽象方法int compare(T o1, T o2) 14 // (o1, o2)有两个参数，o1作为当前对象，o2作为参数，都是String；返回值为int —— 其它方法满足这样条件的也可以 15 Optional<String> optionalMax1 = listStr.stream().max(((o1, o2) -> { return o1.compareTo(o2);} )); 16 17 // 简写 18 // 而String::compareTo方法是指int compareTo(String anotherString)--即参数为string,返回值为int的 19 // 其它方法 public int indexOf(String str) --即参数为string,返回值为int的 也可以，但是int length() 无参数的方法就不行 20 Optional<String> optionalMax2 = listStr.stream().max(String::compareTo); // String::length报错 21 22 System.out.println("optionalMax1=" + optionalMax1.get() + ", optionalMax2=" + optionalMax2.get()); // optionalMax3=adnm, optionalMax4=w3 23 24 25 List<String> listStr3 = Arrays.asList("adnm", "dn", "n"); 26 List<String> listStr4 = Arrays.asList("adnm", "w3", "3"); 27 Optional<String> optionalMax3 = listStr3.stream().max(String::indexOf); // adnm.indexOf("dn")>0, "dn".indexOf("n")>0 28 Optional<String> optionalMax4 = listStr4.stream().max(String::indexOf); // adnm.indexOf("w3")<0, "w3".indexOf("3")>0 29 System.out.println("optionalMax3=" + optionalMax3.get() + ", optionalMax4=" + optionalMax4.get()); // optionalMax3=adnm, optionalMax4=w3 30 31 Optional<String> optionalMax5 = listStr.stream().max((o1,o2) -> {return 1;}); // >=0：adnm 即两两比较 前面最大； <0，则最后一个最大 32 System.out.println("optionalMax5=" + optionalMax5.get()); // max=adnm （第0个） 33 34 Optional<String> optionalMax6 = listStr.stream().max((o1,o2) -> {return -1;}); // >=0：adnm 即两两比较 前面最大； <0，则最后一个最大 35 System.out.println("optionalMax6=" + optionalMax6.get()); // max=weoujgsd （最后一个） 36 37 38 /** 39 * max()方法中需要一个函数式接口Comparator<T> 40 * comparing方法中需要一个函数型接口Function<T, R>，唯一的抽象方法为R apply(T t); 41 * x作为Function方法的参数，到了Function方法体里 x作为对象来调用 无参数方法（这里x是String类型，则可以调用String的所有无参方法且返回值为int） 42 */ 43 Optional<String> max1 = listStr.stream().max(Comparator.comparing((x) -> { 44 return x.length(); 45 })); 46 Optional<String> max2 = listStr.stream().max(Comparator.comparing((x) -> { 47 return 1; 48 })); 49 Optional<String> max3 = listStr.stream().max(Comparator.comparing((x) -> { 50 return -1; 51 })); 52 // 要看comparing内部的实现Function keyExtractor (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2)); 53 System.out.println("max1=" + max1.get() + ", max2=" + max2.get() + ", max3=" + max3.get()); // max1=weoujgsd, max2=adnm, max3=adnm 54 55 // 简写形式——使用了静态方法Comparator.comparing，比较的是length属性， 56 Optional<String> max1_1 = listStr.stream().max(Comparator.comparing(String::length)); // String::compareTo报错 57 System.out.println("简写_最长的字符串 max1_1：" + max1_1.get()); 58 } 59 }
结果：
optionalMax1=xbangd, optionalMax2=xbangd optionalMax3=adnm, optionalMax4=w3 optionalMax5=adnm optionalMax6=weoujgsd max1=weoujgsd, max2=adnm, max3=adnm 简写_最长的字符串 max1_1：weoujgsd
参考文献：
1.https://zhuanlan.zhihu.com/p/340538961
2.https://blog.csdn.net/yczz/article/details/50896975
3.https://blog.csdn.net/love905661433/article/details/86422169
