java8新特性 lambda Stream map(函数式编程)

我不是女神ヾ 2022-06-06 14:20 369阅读 0赞

1. 1.接口的默认方法  
2.     Java 8允许我们给接口添加一个非抽象的方法实现，只需要使用 **default**关键字即可，这个特征又叫做扩展方法  
3.     //Formula表示一个设计 计算公式 的接口   
4.     **public** **interface** Formula \{  
5.         //计算  
6.         **double** calculate(**int** a);  
7.           
8.         //开方  
9.         **default** **double** sqrt(**int** a)\{  
10.             **return** Math.sqrt(a);  
11.         \}  
12.     \}  
13.   
14.     main:  
15.     Formula f = **new** Formula() \{  
16.         @Override  
17.         **public** **double** calculate(**int** a) \{  
18.             **return** a+1;  
19.         \}  
20.     \};  
21.     System.out.println(f.calculate(4));  
22.     System.out.println(f.sqrt(8));  
23.   
24.     注意:现在接口还可以存在静态方法，  
25.     可以使用 接口名.静态方法名 的形式直接调用  
26.   
27.   
28. 2.Lambda 表达式  
29.     2.1 认识Lambda表达式  
30.     例如:  
31.     **public** **class** LambdaTest1 \{  
32.       
33.         **public** **static** **void** main(String\[\] args) \{  
34.               
35.             //假如一个list机会中的元素要排序  
36.             List<String> list = Arrays.asList  
37.             ("hello","tom","apple","bbc");  
38.             //之前的排序我们可以这样写  
39.             Collections.sort(list, **new** Comparator<String>()\{  
40.                 @Override  
41.                 **public** **int** compare(String o1, String o2) \{  
42.                     **return** -o1.compareTo(o2);  
43.                 \}  
44.             \});  
45.               
46.             //使用Lambda表达式  
47.             Collections.sort(list,(String s1,String s2)->\{  
48.                 **return** s1.compareTo(s2);  
49.             \});  
50.               
51.             //可以简写为  
52.             //1.大括号里面就一句代码  
53.             //2.编译器可以自动推导出参数类型  
54.             Collections.sort(list,(s1,s2)->s1.compareTo(s2));  
55.               
56.             System.out.println(list);  
57.               
58.         \}  
59.           
60.     \}  
61.   
62.     2.2 Functional接口  
63.     “函数式接口”是指仅仅只包含一个抽象方法的接口，每一个该类型的lambda表达式都会被匹配到这个抽象方法。因为 默认方法 不算抽象方法，所以你也可以给你的函数式接口添加默认方法。  
64.     我们可以将lambda表达式当作任意只包含一个抽象方法的接口类型，确保你的接口一定达到这个要求，你只需要给你的接口添加 @FunctionalInterface 注解，编译器如果发现你标注了这个注解的接口有多于一个抽象方法的时候会报错的。  
65.     例如:  
66.     **public** **class** LambdaTest2 \{  
67.       
68.         **public** **static** **void** main(String\[\] args) \{  
69.               
70.             LambdaTest2 t = **new** LambdaTest2();  
71.     //      也可以先创建对象  
72.     //      Action1 a1 = ()->System.out.println("hello");  
73.               
74.             t.test1(()->System.out.println("hello"));  
75.               
76.             //Action2<String,Integer> a2 = (f)->"这个数字是:"+f;  
77.             //如果参数就一个,那么还可以这样简写 去掉小括号  
78.             Action2<String,Integer> a2 = f->"这个数字是:"\+f;  
79.             t.test2(a2);  
80.         \}  
81.         **public** **void** test1(Action1 a)\{  
82.             a.run();  
83.         \}  
84.         **public** **void** test2(Action2<String,Integer> a)\{  
85.             System.out.println(a.run(3));  
86.         \}  
87.           
88.     \}  
89.     //这个注解不加也可以,加上只是为了让编译器检查  
90.     @FunctionalInterface  
91.     **interface** Action1\{  
92.         **public** **void** run();  
93.     \}  
94.       
95.     //这个注解不加也可以,加上只是为了让编译器检查  
96.     @FunctionalInterface  
97.     **interface** Action2<T,F>\{  
98.         **public** T run(F f);  
99.     \}  
100.       
101.   
102.     注意:lambda表达式无法访问接口的默认方法  
103.   
104.     2.3 方法与构造函数引用  
105.     Java 8 允许你使用 :: 关键字来传递方法(静态方法和非静态方法)  
106.     例如:  
107.     **public** **class** LambdaTest3 \{  
108.         **public** **static** **void** main(String\[\] args) \{  
109.               
110.             LambdaTest3 t = **new** LambdaTest3();  
111.             //使用Lambda引用类的静态方法  
112.             //能引用Integer类中的静态方法toBinaryString的原因是:  
113.             //Action3接口中只有一个方法且方法的参数类型和返回值类型  
114.             //与Integer类中的静态方法toBinaryString的参数类型、返回类型是一致的  
115.             Action3 a3 = Integer::toBinaryString;  
116.             System.out.println(a3.run(4));  
117.               
118.             //使用Lambda引用对象的非静态方法  
119.             //能引用对象t中的非静态方法test的原因是和上面的描述是一致的  
120.             Action3 aa3 = t::test;  
121.             System.out.println(aa3.run(4));  
122.         \}  
123.           
124.         **public** String test(**int** i)\{  
125.             **return** "i="\+i;  
126.         \}  
127.     \}  
128.   
129.     @FunctionalInterface  
130.     **interface** Action3\{  
131.         **public** String run(**int** Integer);  
132.     \}  
133.   
134.   
135.     下面是一个接口中带泛型的时候特殊例子: 可以使用  类名::非静态方法  的形式引用方法  
136.     **public** **class** LambdaTest6 \{  
137.       
138.         **public** **static** **void** main(String\[\] args) \{  
139.               
140.             Model m = **new** Model();  
141.               
142.             //方法有一个参数，然后没返回类型,这里参数类型会自动识别  
143.             Action<Model> a1 = (s)->System.out.println("hello");  
144.             a1.run(m);  
145.               
146.             //注意:如果这里泛型类型不是Model 那么就不能引用Model中的方法  
147.             //可以引用Model类中任意方法 只要满足一点:该方法没有参数  
148.             //将来run方法中就会调用Model类型对象m的此处引用的方法  
149.             Action<Model> a2 = Model::test3;  
150.             a2.run(m);  
151.               
152.             //引用对象m中的test2方法  
153.             //因为test2方法的参数和返回类型和Action接口的方法完全一致  
154.             Action<Model> a3 = m::test2;  
155.             a3.run(m);  
156.         \}  
157.           
158.     \}  
159.   
160.     **interface** Action<T>\{  
161.         **public** **void** run(T t);  
162.     \}  
163.   
164.     **class** Model\{  
165.           
166.         **public** **void** test1()\{  
167.             System.out.println("test1");  
168.         \}  
169.         **public** **void** test2(Model a)\{  
170.             System.out.println("test2");  
171.         \}  
172.         **public** **int** test3()\{  
173.             System.out.println("test3");  
174.             **return** 1;  
175.         \}  
176.     \}  
177.       
178.   
179.     Java 8 允许你使用 :: 关键字来引用构造函数  
180.     **public** **class** LambdaTest4 \{  
181.           
182.         **public** **static** **void** main(String\[\] args) \{  
183.               
184.             //Lambda表达式引用构造函数  
185.             //根据构造器的参数来自动匹配使用哪一个构造器  
186.             Action4Creater creater = Action4::**new**;  
187.             Action4 a4 = creater.create("zhangsan");  
188.             a4.say();  
189.               
190.               
191.         \}  
192.           
193.     \}  
194.   
195.     **class** Action4\{  
196.         **private** String name;  
197.         **public** Action4() \{  
198.               
199.         \}  
200.         **public** Action4(String name) \{  
201.             **this**.name = name;  
202.         \}  
203.         **public** **void** say()\{  
204.             System.out.println("name = "\+name);  
205.         \}  
206.     \}  
207.   
208.     **interface** Action4Creater\{  
209.         **public** Action4 create(String name);  
210.     \}  
211.   
212.     2.4 lambda表达式中的变量访问  
213.     **public** **class** LambdaTest5 \{  
214.         **private** **static** **int** j;  
215.         **private** **int** k;  
216.         **public** **static** **void** main(String\[\] args) \{  
217.             LambdaTest5 t = **new** LambdaTest5();  
218.             t.test();  
219.         \}  
220.           
221.         **public** **void** test()\{  
222.             **int** num = 10;  
223.             j = 20;  
224.             k = 30;  
225.               
226.             //lambda表达式中可以访问成员变量也可以方法局部变量  
227.             Action5 a5 = (i)->System.out.println("操作后:i="\+(i+num+j+k));  
228.             a5.run(1);  
229.               
230.             //但是这个被访问的变量默认变为final修饰的 不可再改变 否则编译不通过  
231.             //num = 60;  
232.             j = 50;  
233.             k = 70;  
234.         \}  
235.           
236.     \}  
237.   
238.     **interface** Action5\{  
239.         **public** **void** run(**int** i);  
240.     \}  
241.       
242.       
243.     2.5 Predicate接口和lambda表达式  
244.     java.util.function.Predicate接口是用来支持java函数式编程新增的一个接口,使用这个接口和lamb表达式就可以以更少的代码为API方法添加更多的动态行为。   
245.     **public** **class** LambdaTest6 \{  
246.         **public** **static** **void** main(String\[\] args) \{  
247.             List<String> languages = Arrays.asList("Java", "html5","JavaScript", "C++", "hibernate", "PHP");  
248.               
249.             //开头是J的语言  
250.             filter(languages,(name)->name.startsWith("J"));  
251.             //5结尾的  
252.             filter(languages,(name)->name.endsWith("5"));  
253.             //所有的语言  
254.             filter(languages,(name)->**true**);  
255.             //一个都不显示  
256.             filter(languages,(name)->**false**);  
257.             //显示名字长度大于4  
258.             filter(languages,(name)->name.length()>4);  
259.             System.out.println("-----------------------");  
260.             //名字以J开头并且长度大于4的  
261.             Predicate<String> c1 = (name)->name.startsWith("J");  
262.             Predicate<String> c2 = (name)->name.length()>4;  
263.             filter(languages,c1.and(c2));  
264.               
265.             //名字不是以J开头  
266.             Predicate<String> c3 = (name)->name.startsWith("J");  
267.             filter(languages,c3.negate());  
268.               
269.             //名字以J开头或者长度小于4的  
270.             Predicate<String> c4 = (name)->name.startsWith("J");  
271.             Predicate<String> c5 = (name)->name.length()<4;  
272.             filter(languages,c4.or(c5));  
273.               
274.             //名字为Java的  
275.             filter(languages,Predicate.isEqual("Java"));  
276.               
277.             //判断俩个字符串是否相等  
278.             **boolean** test = Predicate.isEqual("hello").test("world");  
279.             System.out.println(test);  
280.         \}  
281.         **public** **static** **void** filter(List<String> languages, Predicate<String> condition) \{    
282.             **for**(String name: languages) \{    
283.                 **if**(condition.test(name)) \{    
284.                     System.out.println(name + " ");    
285.                 \}    
286.             \}    
287.         \}    
288.           
289.     \}  
290.       
291.     2.6 Function 接口  
292.          Function有一个参数并且返回一个结果，并附带了一些可以和其他函数组合的默认方法  
293.          compose方法表示在某个方法之前执行  
294.          andThen方法表示在某个方法之后执行  
295.          注意：compose和andThen方法调用之后都会把对象自己本身返回，这可以方便链式编程  
296.          **default** <V> Function<T,V> andThen(Function<? **super** R,? **extends** V> after) 返回一个先执行当前函数对象apply方法再执行after函数对象apply方法的函数对象。  
297.   
298.         **default** <V> Function<T,V> compose(Function<? **super** V,? **extends** T> before)返回一个先执行before函数对象apply方法再执行当前函数对象apply方法的函数对象。  
299.   
300.         **static** <T> Function<T,T> identity() 返回一个执行了apply()方法之后只会返回输入参数的函数对象。  
301.     **public** **interface** Function<T, R> \{  
302.   
303.         R apply(T t);  
304.   
305.         **default** <V> Function<V, R> compose(Function<? **super** V, ? **extends** T> before) \{  
306.             Objects.requireNonNull(before);  
307.             **return** (V v) -> apply(before.apply(v));  
308.         \}  
309.   
310.         **default** <V> Function<T, V> andThen(Function<? **super** R, ? **extends** V> after) \{  
311.             Objects.requireNonNull(after);  
312.             **return** (T t) -> after.apply(apply(t));  
313.         \}  
314.           
315.         //注意: t->t是(t)->t的简写  
316.         //t->t是作为方法identity的返回值的,也就是Function类型对象  
317.         //类似于这样的写法:Function<Object, Object> f = t->t;  
318.         //那么f.apply("test") 返回字符串"test"  
319.         //传入什么则返回什么  
320.         **static** <T> Function<T, T> identity() \{  
321.             **return** t -> t;  
322.         \}  
323.     \}  
324.   
325.     例如:  
326.     **public** **class** LambdaTest7 \{  
327.         //静态内部类  
328.         **private** **static** **class** Student\{  
329.             **private** String name;  
330.             **public** Student(String name)\{  
331.                 **this**.name = name;  
332.             \}  
333.             **public** String getName() \{  
334.                 **return** name;  
335.             \}  
336.               
337.         \}  
338.         **public** **static** **void** main(String\[\] args) \{  
339.             /\*用户注册输入一个名字tom\*/  
340.             String name = "tom";  
341.               
342.             /\*使用用户的输入的名字创建一个对象\*/  
343.             Function<String, Student> f1 =(s)->**new** Student(s);  
344.             //注意上面的代码也可以写出这样，引用类中的构造器  
345.             //Function<String, Student> f1 =Student::new;  
346.             Student stu1 = f1.apply(name);  
347.             System.out.println(stu1.getName());  
348.               
349.             /\*需求改变,使用name创建Student对象之前需要给name加一个前缀\*/  
350.             Function<String,String> before = (s)->"briup\_"\+s;  
351.             //表示f1调用之前先执行before对象的方法,把before对象的方法返回结果作为f1对象方法的参数  
352.             Student stu2 = f1.compose(before).apply(name);  
353.             System.out.println(stu2.getName());  
354.               
355.             /\*获得创建好的对象中的名字的长度\*/  
356.             Function<Student,Integer> after = (stu)->stu.getName().length();  
357.             //before先调用方法,结果作为参数传给f1来调用方法,结果再作为参数传给after,结果就是我们接收的数据  
358.             **int** len = f1.compose(before).andThen(after).apply(name);  
359.             System.out.println(len);  
360.               
361.         \}  
362.           
363.     \}          
364.   
365.   
366.   
367.     2.7 Supplier接口  
368.     Supplier接口返回一个任意范型的值，和Function接口不同的是该接口没有任何参数  
369.     **public** **interface** Supplier<T> \{  
370.         T get();  
371.     \}  
372.     例如:  
373.     **public** **class** LambdaTest8 \{  
374.         **public** **static** **void** main(String\[\] args) \{  
375.             //生成一个八位的随机字符串  
376.             Supplier<String> f = ()->\{  
377.                 String base = "abcdefghijklmnopqrstuvwxyz0123456789";       
378.                 Random random = **new** Random();       
379.                 StringBuffer sb = **new** StringBuffer();       
380.                 **for** (**int** i = 0; i < 8; i++) \{    
381.                     //生成\[0,base.length)之间的随机数  
382.                     **int** number = random.nextInt(base.length());       
383.                     sb.append(base.charAt(number));       
384.                 \}       
385.                 **return** sb.toString();     
386.             \};  
387.             System.out.println(f.get());  
388.         \}  
389.           
390.     \}  
391.   
392.   
393.     2.8 Consumer接口  
394.     Consumer接口接收一个任意范型的值，和Function接口不同的是该接口没有任何值  
395.     **public** **interface** Consumer<T> \{  
396.   
397.         **void** accept(T t);  
398.   
399.         **default** Consumer<T> andThen(Consumer<? **super** T> after) \{  
400.             Objects.requireNonNull(after);  
401.             **return** (T t) -> \{ accept(t); after.accept(t); \};  
402.         \}  
403.     \}  
404.     例如:  
405.     **public** **class** LambdaTest9 \{  
406.         //静态内部类  
407.         **private** **static** **class** Student\{  
408.             **private** String name;  
409.   
410.             **public** String getName() \{  
411.                 **return** name;  
412.             \}  
413.   
414.             **public** **void** setName(String name) \{  
415.                 **this**.name = name;  
416.             \}  
417.         \}  
418.           
419.         **public** **static** **void** main(String\[\] args) \{  
420.             Student s = **new** Student();  
421.             s.setName("tom");  
422.               
423.             Consumer<Student> c =   
424.             stu->System.out.println("hello!"\+stu.getName());  
425.             c.accept(s);  
426.               
427.         \}  
428.           
429.     \}  
430.   
431.     总结:  
432.         Function<T, R>  接口   R apply(T t);       有参数有返回值  
433.         Supplier<T>       接口   T get();         没参数有返回值  
434.         Consumer<T>    接口   **void** accept(T t); 有参数没返回值  
435.   
436.         另外需要注意的接口: 其用法和上面介绍的接口使用方式类同  
437.         BinaryOperator<T>接口    T apply(T t, T t)  将两个T作为输入，返回一个T作为输出  
438.         BiFunction<T, U, R>接口  R apply(T t, U u)  将一个T和一个U输入，返回一个R作为输出  
439.         BinaryOperator接口继承了BiFunction接口  
440.         **public** **interface** BinaryOperator<T> **extends** BiFunction<T,T,T>  
441.   
442.         BiConsumer<T, U>接口  **void** accept(T t, U u) 将俩个参数传入，没有返回值  
443.   
444.           
445.   
446.     2.9 Optional类  
447.     Optional 不是接口而是一个类，这是个用来防止NullPointerException异常的辅助类型  
448.     Optional 被定义为一个简单的容器，其值可能是**null**或者不是**null**。  
449.     在Java8之前一般某个函数应该返回非空对象但是偶尔却可能返回了**null**，而在Java 8中，不推荐你返回**null**而是返回Optional。  
450.     这是一个可以为**null**的容器对象。  
451.     如果值存在则isPresent()方法会返回**true**，调用get()方法会返回该对象。  
452.     **public** **class** Optotion \{  
453.       
454.     **public** **static** **void** main(String\[\] args) \{  
455.           
456.         /\*of方法 为非null的值创建一个Optional\*/  
457.         //of方法通过工厂方法创建Optional类。  
458.         //需要注意的是，创建对象时传入的参数不能为null。  
459.         //如果传入参数为null，则抛出NullPointerException 。  
460.         Optional<String> op1 = Optional.of("hello");  
461.           
462.         /\*ofNullable方法 为指定的值创建一个Optional，如果指定的值为null，则返回一个空的Optional。\*/  
463.         //ofNullable与of方法相似，唯一的区别是可以接受参数为null的情况  
464.         Optional<String> op2 = Optional.ofNullable(**null**);  
465.           
466.         /\*isPresent方法 如果值存在返回true，否则返回false。\*/  
467.         /\*get方法 如果Optional有值则将其返回，否则抛出NoSuchElementException。\*/  
468.         **if**(op1.isPresent())\{  
469.             System.out.println(op1.get());  
470.         \}  
471.         **if**(op2.isPresent())\{  
472.             System.out.println(op2.get());  
473.         \}  
474.           
475.         /\*ifPresent方法 如果Optional实例有值则为其调用consumer，否则不做处理\*/  
476.         //consumer接口中的方法只有参数没有返回值  
477.         op1.ifPresent(str->System.out.println(str));  
478.         op2.ifPresent(str->System.out.println(str));//这个不执行 因为op2里面的值是null  
479.           
480.           
481.         /\*orElse方法 如果有值则将其返回，否则返回指定的其它值。\*/  
482.         System.out.println(op1.orElse("如果op1中的值为null则返回这句话,否则返回这个值"));  
483.         System.out.println(op2.orElse("如果op2中的值为null则返回这句话,否则返回这个值"));  
484.           
485.           
486.         /\*orElseGet方法 orElseGet与orElse方法类似，区别在于得到的默认值。orElse方法将传入的字符串作为默认值，orElseGet方法可以接受Supplier接口的实现用来生成默认值。\*/  
487.         //Supplier接口中的方法没有参数但是有返回值  
488.         System.out.println(op1.orElseGet(()->"自己定义的返回值"));  
489.         System.out.println(op2.orElseGet(()->"自己定义的返回值"));  
490.           
491.           
492.         /\*orElseThrow方法 如果有值则将其返回，否则抛出supplier接口创建的异常。\*/  
493.         //在orElseThrow中我们可以传入一个lambda表达式或方法，如果值不存在来抛出异常。  
494.         //orElseThrow方法的声明如下 所有只能返回一个Throwable类型对象  
495.         //public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X  
496.         **try** \{  
497.             System.out.println(op1.orElseThrow(Exception::**new**));;  
498.             //System.out.println(op2.orElseThrow(Exception::new));;这个会抛出异常  
499.         \} **catch** (Exception e) \{  
500.             e.printStackTrace();  
501.         \}  
502.           
503.           
504.         /\*map方法 如果有值，则对其执行调用mapper函数得到返回值。\*/  
505.         //返回值并且依然Optional包裹起来,其泛型和你返回值的类型一致  
506.         //public Optional map(Function<? super T, ? extends U> mapper)  
507.         Optional<Integer> map1 = op1.map(str->1);  
508.         System.out.println(map1.get());  
509.         Optional<Double> map2 = op2.map(str->1.2);  
510.         System.out.println(map2.orElse(0.0));  
511.           
512.           
513.         /\*flatMap方法 如果有值，为其执行mapper函数返回Optional类型返回值，否则返回空Optional。\*/  
514.         //flatMap与map方法类似，区别在于flatMap中的mapper返回值必须是Optional。调用结束时，flatMap不会对结果用Optional封装。  
515.         //需要我们自己把返回值封装为Optional  
516.         //public Optional flatMap(Function<? super T, Optional> mapper)   
517.         System.out.println(op1.flatMap(str->Optional.of(str+"\_briup")).get());  
518.         //op1.flatMap(str->"");编译出错  
519.           
520.           
521.         /\*filter方法 如果有值并且满足断言条件返回包含该值的Optional，否则返回空Optional。\*/  
522.         //public Optional<T> filter(Predicate<? super T> predicate)   
523.         op1 = op1.filter(str->str.length()<10);  
524.         System.out.println(op1.orElse("值为null"));  
525.         op1 = op1.filter(str->str.length()>10);  
526.         System.out.println(op1.orElse("值为null"));  
527.     \}  
528.   
529.     2.10 Stream 接口  
530.     java.util.Stream 表示能应用在一组元素上一次执行的操作序列。  
531.     Stream 操作分为中间操作或者最终操作两种，最终操作返回一特定类型的计算结果，  
532.     而中间操作返回Stream本身，这样你就可以将多个操作依次串起来(链式编程)。  
533.     Stream 的创建需要指定一个数据源，比如 java.util.Collection的子类，List或者Set， Map不支持。  
534.     Stream的操作可以串行执行或者并行执行。  
535.     Stream 作为 Java 8 的一大亮点，它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念。  
536.     Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、  
537.     高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation)。  
538.     Stream API 借助于同样新出现的Lambda表达式，极大的提高编程效率和程序可读性。  
539.     同时它提供串行和并行两种模式进行汇聚操作  
540.   
541.     2.10.1 Stream对象的构建:  
542.     // 1.使用值构建  
543.     Stream<String> stream = Stream.of("a", "b", "c");  
544.     // 2. 使用数组构建  
545.     String\[\] strArray = **new** String\[\] \{ "a", "b", "c"\};  
546.     Stream<String> stream = Stream.of(strArray);  
547.     Stream<String> stream = Arrays.stream(strArray);  
548.     // 3. 利用集合构建(不支持Map集合)  
549.     List<String> list = Arrays.asList(strArray);  
550.     stream = list.stream();  
551.   
552.     对于基本数值型，目前有三种对应的包装类型 Stream：IntStream、LongStream、DoubleStream。  
553.     当然我们也可以用 Stream<Integer>、Stream<Long> 、Stream<Double>，但是 自动拆箱装箱会很耗时，所以特别为这三种基本数值型提供了对应的 Stream。  
554.     Java 8 中还没有提供其它基本类型数值的Stream  
555.   
556.     2.10.2 数值Stream的构建:  
557.     IntStream stream1 = IntStream.of(**new** **int**\[\]\{ 1, 2, 3\});  
558.     //\[1,3)  
559.     IntStream stream2 = IntStream.range(1, 3);  
560.     //\[1,3\]  
561.     IntStream stream3 = IntStream.rangeClosed(1, 3);  
562.   
563.     2.10.3 Stream转换为其它类型:  
564.     Stream<String> stream = Stream.of("hello","world","tom");  
565.     // 1. 转换为Array  
566.     String\[\] strArray  = stream.toArray(String\[\]::**new**);  
567.     // 2. 转换为Collection  
568.     List<String> list1 = stream.collect(Collectors.toList());  
569.     List<String> list2 = stream.collect(Collectors.toCollection(ArrayList::**new**));  
570.     Set<String> set3 = stream.collect(Collectors.toSet());  
571.     Set<String> set4 = stream.collect(Collectors.toCollection(HashSet::**new**));  
572.     // 3. 转换为String  
573.     String str = stream.collect(Collectors.joining()).toString();  
574.   
575.     特别注意 : 一个 Stream 只可以使用一次，上面的代码为了简洁而重复使用了多次。  
576.     这个代码直接运行会抛出异常的:  
577.     java.lang.IllegalStateException: stream has already been operated upon or closed  
578.   
579.   
580.     2.10.4 Stream操作  
581.     当把一个数据结构包装成Stream后，就要开始对里面的元素进行各类操作了。常见的操作可以归类如下。  
582.   
583.     Intermediate：中间操作  
584.     map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered  
585.   
586.     Terminal： 最终操作  
587.     forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator  
588.   
589.     Short-circuiting： 短路操作  
590.     anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit  
591.   
592.   
593.     map/flatMap映射 把 Stream中 的每一个元素，映射成另外一个元素。  
594.     例子:  
595.     转换大写  
596.     Stream<String> wordList = Stream.of("hello","world","tom");  
597.     List<String> output = wordList.  
598.                     map(String::toUpperCase).  
599.                     collect(Collectors.toList());  
600.     //也可以直接使用forEach循环输出  
601.     wordList.map(String::toUpperCase).collect(Collectors.toList()).forEach(System.out::println);  
602.   
603.     例子:  
604.     计算平方数  
605.     List<Integer> nums = Arrays.asList(1, 2, 3, 4);  
606.     List<Integer> squareNums =   
607.                 nums.stream().  
608.                 map(n -> n \* n).  
609.                 collect(Collectors.toList());  
610.     map生成的是个1:1映射，每个输入元素，都按照规则转换成为另外一个元素。还有一些场景，是一对多映射关系的，这时需要 flatMap。  
611.     map和flatMap的方法声明是不一样的  
612.     <R> Stream<R>      map(Function<? **super** T, ? **extends** R> mapper);  
613.     <R> Stream<R> flatMap(Function<? **super** T, ? **extends** Stream<? **extends** R>> mapper);  
614.   
615.     例子:  
616.     //stream1中的每个元素都是一个List集合对象  
617.     Stream<List<Integer>> stream1 = Stream.of(  
618.                      Arrays.asList(1),  
619.                      Arrays.asList(2, 3),  
620.                      Arrays.asList(4, 5, 6)  
621.                  );  
622.                 Stream<Integer> stream2 = stream1.  
623.                 flatMap((e) -> e.stream());  
624.                   
625.     stream2.forEach(e->System.out.println(e));//输出1 2 3 4 5 6  
626.     flatMap 把 stream1 中的层级结构扁平化，就是将最底层元素抽出来放到一起，最终新的 stream2 里面已经没有 List 了，都是直接的数字。  
627.   
628.     例子:  
629.     Stream<String> stream1 = Stream.of("tom.Li","lucy.Liu");  
630.     //flatMap方法把stream1中的每一个字符串都用\[.\]分割成了俩个字符串  
631.     //最后返回了一个包含4个字符串的stream2  
632.     Stream<String> stream2 = stream1.flatMap(s->Stream.of(s.split("\[.\]")));  
633.     stream2.forEach(System.out::println);  
634.     输出结果:  
635.         tom  
636.         Li  
637.         lucy  
638.         Liu  
639.   
640.   
641.   
642.     forEach 遍历 接收一个 Lambda 表达式，然后在 Stream 的每一个元素上执行该表达式。  
643.     forEach 是 terminal 操作，执行完stream就不能再用了  
644.     例子:  
645.     List<String> list = Arrays.asList("test","hello","world","java","tom","C","javascript");  
646.     list.stream().forEach(System.out::println);  
647.   
648.   
649.     filter 过滤 对原始 Stream 进行某项测试，通过测试的元素被留下来生成一个新 Stream。  
650.     通过一个predicate接口来过滤并只保留符合条件的元素，该操作属于中间操作，所以我们可以在过滤后的结果来应用其他Stream操作（比如forEach）。forEach需要一个函数来对过滤后的元素依次执行。forEach是一个最终操作，所以我们不能在forEach之后来执行其他Stream操作  
651.     例子:  
652.     List<String> list = Arrays.asList("test","hello","world","java","tom","C","javascript");  
653.     list.stream().filter(s->s.length()>4).forEach(System.out::println);  
654.     注意:System.out::println 这个是lambda表达式中对静态方法的引用  
655.   
656.   
657.     peek 对每个元素执行操作并返回一个新的 Stream  
658.     注意:调用peek之后,一定要有一个最终操作  
659.     peek是一个intermediate 操作  
660.     例子:  
661.     List<String> list = Arrays.asList("one", "two", "three", "four");  
662.     List<String> list2 = list.stream()  
663.                  .filter(e -> e.length() > 3)  
664.                  .peek(e -> System.out.println("第一次符合条件的值为: " + e))  
665.                  .filter(e->e.length()>4)  
666.                  .peek(e -> System.out.println("第二次符合条件的值为: " + e))  
667.                  .collect(Collectors.toList());  
668.     System.out.println(list2.size());//打印结果为 1  
669.     最后list2中就存放的筛选出来的元素  
670.   
671.   
672.     findFirst 总是返回 Stream 的第一个元素，或者空，返回值类型：Optional。  
673.     如果集中什么都没有,那么list.stream().findFirst()返回一个Optional<String>对象,  
674.         但是里面封装的是一个**null**。  
675.     例子:  
676.     List<String> list = Arrays.asList("test","hello","world");  
677.     Optional<String> first = list.stream().findFirst();  
678.     System.out.println(first.orElse("值为null"));  
679.   
680.   
681.     sort 排序  
682.     排序是一个中间操作，返回的是排序好后的Stream。如果你不指定一个自定义的Comparator则会使用默认排序。  
683.     对 Stream 的排序通过 sorted 进行，它比数组的排序更强之处在于你可以首先对 Stream 进行各类 map、filter、limit、skip 甚至 distinct 来减少元素数量后，再排序，这能帮助程序明显缩短执行时间。  
684.     例子:  
685.     List<String> list = Arrays.asList("test","hello","world","java","tom","C","javascript");  
686.     list.stream().sorted().filter(s->s.startsWith("j")).forEach(System.out::println);  
687.     //按照字符串的长短排序  
688.     list.stream().sorted((s1,s2)->s1.length()-s2.length()).forEach(System.out::println);  
689.     需要注意的是，排序只创建了一个排列好后的Stream，而不会影响原有的数据源，排序之后原数据list是不会被修改的：  
690.   
691.   
692.     Map 映射  
693.     中间操作map会将元素根据指定的Function接口来依次将元素转成另外的对象，  
694.         下面的示例展示了将字符串转换为大写字符串。  
695.         你也可以通过map来讲对象转换成其他类型，  
696.         map返回的Stream类型是根据你map传递进去的函数的返回值决定的。  
697.     例子:  
698.     List<String> list = Arrays.asList("test","hello","world","java","tom","C","javascript");  
699.     list.stream().map(s->s.toUpperCase()).forEach(System.out::println);  
700.   
701.   
702.     Match 匹配  
703.     Stream提供了多种匹配操作，允许检测指定的Predicate是否匹配整个Stream。  
704.     所有的匹配操作都是最终操作，并返回一个**boolean**类型的值。  
705.     //所有元素匹配成功才返回true 否则返回false  
706.     例子:  
707.     List<String> list = Arrays.asList("test","hello","world","java","tom","C","javascript");  
708.     **boolean** allMatch = list.stream().allMatch((s)->s.startsWith("j"));  
709.     System.out.println(allMatch);  
710.   
711.     //任意一个匹配成功就返回true 否则返回false  
712.     例子:  
713.     List<String> list = Arrays.asList("test","hello","world","java","tom","C","javascript");  
714.     **boolean** anyMatch = list.stream().anyMatch((s)->s.startsWith("j"));  
715.     System.out.println(anyMatch);  
716.   
717.     //没有一个匹配的就返回true 否则返回false  
718.     例子:  
719.     List<String> list = Arrays.asList("test","hello","world","java","tom","C","javascript");  
720.     **boolean** noneMatch = list.stream().noneMatch((s)->s.startsWith("j"));  
721.     System.out.println(noneMatch);  
722.   
723.   
724.     Count 计数  
725.     计数是一个最终操作，返回Stream中元素的个数，返回值类型是**long**。  
726.     例子:  
727.     List<String> list = Arrays.asList("test","hello","world","java","tom","C","javascript");  
728.     **long** count = list.stream().filter(s->s.startsWith("j")).count();  
729.     System.out.println(count);  
730.   
731.   
732.     Reduce 规约/合并  
733.     这是一个最终操作，允许通过指定的函数来将stream中的多个元素规约合并为一个元素.  
734.     它提供一个起始值（种子），然后依照运算规则（BinaryOperator），  
735.         和前面 Stream 的第一个、第二个、第 n 个元素组合。Stream.reduce，  
736.         常用的方法有average, sum, min, max, and count，返回单个的结果值，  
737.         并且reduce操作每处理一个元素总是创建一个新值.  
738.         从这个意义上说，字符串拼接、数值的 sum、min、max等都是特殊的 reduce。  
739.         例如 Stream 的 sum 就相当于  
740.     IntStream integers = IntStream.range(1, 10);  
741.     Integer sum = integers.reduce(0, (a, b) -> a+b); 或  
742.     Integer sum = integers.reduce(0, Integer::sum);  
743.     也有没有起始值的情况，这时会把 Stream 的前面两个元素组合起来，返回的是 Optional。  
744.     OptionalInt min = integers.reduce((a, b) -> a<b?a:b);  
745.     // 字符串连接，concat = "ABCD"  
746.     String concat        = Stream.of("A", "B", "C", "D").reduce("", String::concat);   
747.     Optional<String> opStr = Stream.of("A", "B", "C", "D").reduce(String::concat);   
748.   
749.     例子:  
750.     List<String> list = Arrays.asList("test","javap","hello","world","java","tom","C","javascript");  
751.     Optional<String> reduce = list.stream().sorted((s1,s2)->s2.length()-s1.length()).filter(s->s.startsWith("j")).map(s->s+"\_briup").reduce((s1,s2)->s1+"|"\+s2);  
752.     System.out.println(reduce.orElse("值为空"));//打印结果为: javascript\_briup|javap\_briup|java\_briup  
753.     整个代码有点长，可以换行看下:  
754.     Optional<String> reduce    =  list.stream()  
755.                       .sorted((s1,s2)->s2.length()-s1.length())  
756.                       .filter(s->s.startsWith("j"))  
757.                       .map(s->s+"\_briup")  
758.                       .reduce((s1,s2)->s1+"|"\+s2);  
759.         1.先调用stream方法  
760.         2.再排序，按照字符串的长度进行排序，长的在前短的再后  
761.         3.再过滤，字符串必须是以字符'j'开头的  
762.         4.再进行映射，把每个字符串后面拼接上"\_briup"  
763.         5.再调用reduce进行合并数据,使用"|"连接字符串  
764.         6.最后返回Optional<String>类型数据，处理好的字符串数据就封装在这个对象中                 
765.   
766.   
767.   
768.     limit/skip   
769.     limit 返回 Stream 的前面 n 个元素；skip 则是跳过前 n 个元素只要后面的元素  
770.     例子:  
771.     List<String> list = Arrays.asList("test","javap","hello","world","java","tom","C","javascript");  
772.     list.stream().limit(5).forEach(System.out::println);  
773.     list.stream().skip(5).forEach(System.out::println);  
774.   
775.   
776.   
777.   
778.     min/max/distinct  
779.     例子:  
780.     找出字符文件中字符字符最长的一行  
781.     BufferedReader br = **new** BufferedReader(**new** FileReader("src/com/briup/test/a.txt"));  
782.     **int** maxLen = br.lines().  
783.             mapToInt(String::length).  
784.             max().  
785.             getAsInt();  
786.   
787.     System.out.println(maxLen);    
788.     注意:lines方法把文件中所有行都返回并且转换为一个Stream<String>类型对象,因为每行读出的String类型数据,同时String::length是使用方法引用的特殊方式(因为泛型的缘故),上面的笔记中已经介绍过了,max()方法执行后返回的时候OptionalInt类型对象,所以接着调用了getAsInt方法来获得这次运行结果的**int**值  
789.   
790.     例子:  
791.     找出全文的单词，转小写，去掉空字符,去除重复单词并排序  
792.     BufferedReader br = **new** BufferedReader(**new** FileReader("src/com/briup/test4/day17.txt"));  
793.     br.lines().  
794.        flatMap(s->Stream.of(s.split(" "))).  
795.        filter(s->s.length()>0).  
796.        map(s->s.toLowerCase()).  
797.        distinct().  
798.        sorted().  
799.        forEach(System.out::println);  
800.       
801.   
802.   
803.     Stream.generate  
804.     通过Supplier接口，可以自己来控制Stream的生成。这种情形通常用于随机数、常量的 Stream，或者需要前后元素间维持着某种状态信息的 Stream。把 Supplier 实例传递给 Stream.generate() 生成的 Stream，由于它是无限的，在管道中，必须利用limit之类的操作限制Stream大小。可以使用此方式制造出海量的测试数据  
805.     **public** **static**<T> Stream<T> generate(Supplier<T> s);  
806.     例子:  
807.     生成100个随机数并由此创建出Stream实例  
808.     Stream.generate(()->(**int**)(Math.random()\*100)).limit(100).forEach(System.out::println);  
809.           
810.   
811.   
812.     Stream.iterate  
813.     iterate 跟 reduce 操作很像，接受一个种子值，和一个 UnaryOperator（假设是 f）。  
814.         然后种子值成为 Stream 的第一个元素，f(seed) 为第二个，f(f(seed)) 第三个，  
815.         f(f(f(seed))) 第四个,以此类推。  
816.     该方法的声明为:  
817.     **public** **static**<T> Stream<T> iterate(**final** T seed, **final** UnaryOperator<T> f)  
818.   
819.     UnaryOperator接口继承了Function接口:  
820.     **public** **interface** UnaryOperator<T> **extends** Function<T, T>  
821.     例子:  
822.     生成一个等差数列  
823.     Stream.iterate(0, n -> n + 3).  
824.                 limit(10).   
825.                 forEach(x -> System.out.print(x + " "));  
826.     打印结果:  
827.     0 3 6 9 12 15 18 21 24 27   
828.   
829.   
830.   
831.   
832.     Collectors   
833.     java.util.stream.Collectors 类的主要作用就是辅助进行各类有用的操作。  
834.     例如把Stream转变输出为 Collection，或者把 Stream 元素进行分组。  
835.     例子:  
836.     把Stream中的元素进行过滤然后再转为List集合  
837.     List<String> list = Arrays.asList("test","hello","world","java","tom","C","javascript");  
838.     List<String> result = list.stream().filter(s->s.length()>4).collect(Collectors.toList());  
839.   
840.     //分组:按照字符串的长度分组  
841.     List<String> list = Arrays.asList("test","hello","world","java","tom","C","javascript");  
842.     //相同长度的字符串放到一个List集合中作为Map的value,字符串的长度作为Map的Key  
843.     Map<Integer, List<String>> collect = list.stream().collect(Collectors.groupingBy(String::length));  
844.     //注意下面写法可能写到s->s.length()的时候Eclipse里面有可能不会代码提示，这个要看你先的是=号的哪一边  
845.     //最终原因还是泛型的事情  
846.     Map<Integer, List<String>> collect = list.stream().collect(Collectors.groupingBy(s->s.length()));  
847.           
848.     //分割:按照字符串是否包含java进行划分  partitioning分割划分的意思  
849.     Map<Boolean, List<String>> collect =   
850.             list.stream().collect(Collectors.partitioningBy(s->s.indexOf("java")!=-1));  
851.     **for**(Boolean b:collect.keySet())\{  
852.         System.out.println(b+" : "\+collect.get(b).size());  
853.     \}  
854.   
855.   
856.     2.11 并行Streams  
857.     Stream有串行和并行两种，串行Stream上的操作是在一个线程中依次完成，而并行Stream则是在多个线程上同时执行。  
858.     例子:  
859.     **public** **class** LambdaTest12 \{  
860.       
861.         **public** **static** **void** main(String\[\] args) \{  
862.               
863.             //生成100万个不同的字符串放到集合中  
864.             **int** max = 1000000;  
865.             List<String> values = **new** ArrayList<String>(max);  
866.             **for** (**int** i = 0; i < max; i++) \{  
867.                 UUID uuid = UUID.randomUUID();  
868.                 values.add(uuid.toString());  
869.             \}  
870.   
871.   
872.             //1纳秒\*10^9=1秒   
873.             **long** t0 = System.nanoTime();  
874.             //串行stream   
875.             **long** count = values.stream().sorted().count();  
876.             //并行stream  
877.             //long count = values.parallelStream().sorted().count();  
878.             **long** t1 = System.nanoTime();  
879.   
880.             **long** time = t1 - t0;  
881.             System.out.println(count);  
882.             System.out.println(time);  
883.         \}  
884.           
885.     \}  
886.   
887.     结论:对100万个字符串进行排序和计数操作，串行和并行运算的用时差别还是很明显的  
888.   
889.   
890.   
891.     2.12 Map集合  
892.     Map类型不支持stream，不过Map提供了一些新的有用的方法来处理一些日常任务。  
893.     Java8为Map新增的方法：  
894.   
895.     Object compute(Object key, BiFunction remappingFunction):该方法使用remappingFunction根据原key-value对计算一个新的value。只要新的value不为**null**，就使用新的value覆盖原value；如果新的value为**null**，则删除原key-value对；  
896.   
897.     Object computeIfAbsent(Object key, Function mappingFunction):如果传入的key参数在Map中对应的value为**null**，该方法将使用mappingFunction根据原key、value计算一个新的结果，则用该计算结果覆盖原value；如果传入的key参数在Map中对应的value为**null**，则该方法不做任何事情；如果原Map原来不包括该key，该方法可能会添加一组key-value对。  
898.   
899.     Object computeIfPresent(Object key, BiFunction remappingFunction):如果传给该方法的key参数在Map中对应的value不为**null**，该方法将使用remappingFunction根据原key、value计算一个新结果，并且该计算结果不为**null**，则使用该结果覆盖原来的value；如果计算结果为**null**，则删除原key-value对。  
900.   
901.     **void** forEach(BiConsumer action):该方法是Java8为Map新增的一个遍历key-value对的方法。  
902.   
903.     Object getOrDefault(Object key, V defaultValue):获取指定的key对应的value。如果该key不存在，则返回defaultValue。  
904.   
905.     Object merge(Object key, Object value, BiFunction remappingFunction):该方法会先根据key参数获取该Map中对应的value。如果获取的value为**null**，则直接使用传入的value覆盖原value（在这种情况下，可能会添加一组key-value）；如果获取的value不为**null**，则使用remappingFunction函数根据原value、新value计算一个新的结果，并用新的结果去覆盖原有的value。  
906.   
907.     Object putIfAbsent(Object key, Object value):该方法会自动检测指定的key对应的value是否为**null**，如果该key对应的value为**null**，则使用传入的新value代替原来的**null**。如果该key对应的value不是**null**，那么该方法不做任何事情。  
908.   
909.     Object replace(Object key, Object value):将Map中指定key对应的value替换成新value并把被替换掉的旧值返回。如果key在Map中不存在，该方法不会添加key-value对，而是返回**null**。  
910.   
911.     Boolean replace(K key, V oldValue, V newValue):将Map中指定的key-value对的原value替换成新value。如果在Map中找到指定的key-value对，则执行替换并返回**true**，否则返回**false**。  
912.   
913.     replaceAll(BiFunction function):该方法使用function对原key-value对执行计算，并将计算结果作为key-value对的value值

**dubbo技术学习，更多知识请访问[https://www.itkc8.com][https_www.itkc8.com]**

[https_www.itkc8.com]: https://www.itkc8.com/