1 /**
 2 * collect Action: Collect - converts the stream to another form,
 3 * Receive the implementation of a Collection interface to summarize the elements in the Stream
 4 * Collectors.toList()/toSet()
 5 */
 6 Set<Integer> ageList = list.stream().collect(Collectors.toSet());
 7 ageList.stream().forEach(System.out::println);
 8 //Take a name and seal it into hashset
 9 HashSet<Integer> hs = list.stream()
10 .collect(Collectors.toCollection(HashSet::new));
11 System.err.println(hs.toString());

Functional interface:

1 @FunctionalInterfaceinterface GreetingService
2 {
3         void sayMessage(String message);
4 }
5  
6 // Then it can be used Lambda Expression to represent an implementation of the interface(Note: JAVA 8 Previously, it was generally implemented with anonymous classes): 
7 GreetingService greetService1 = message -> System.out.println("Hello " + message);

 1 /**
 2 * @MethodName: functionInterface
 3 * @Description: Four functional interface exercises
 4 * @param
 5 * @return
 6 * @author rongrong
 7 * @date 2019-12-23
 8 */
 9 public void functionInterface(){
10 /**
11 * 1.Consumer <T>: Consumption interface, with or without parameter return value
12 * Print:
13 * 222222
14 * hello
15 */
16 changeStr("hello",(str) -> System.err.println(str));
17  
18 /**
19 * 2.Supplier <T>: Supply type interface, no parameter return value
20 * Print:
21 * 111111
22 * str
23 */
24 String value = getValue(() -> "str");
25 System.err.println(value);
26  
27 /**
28 * 3. Function <T,R>: :Function interface with parameter and return value
29 * Print:
30 * 333333
31 * 20000
32 */
33 Long aLong = changeNum(100L, x -> x * 200);
34 System.err.println(aLong);
35 /**
36 * Predicate<T>:  Assertion type interface, with parameters and return values. The return value is boolean type
37 * Print:
38 * true
39 */
40 boolean rongrong = changeBoolean("rongrong", x -> x.equals("rongrong"));
41 System.err.println(rongrong);
42  
43 }
44  
45 /**
46 * Consumer<T> Consumer interface
47 * @param str
48 * @param con
49 */
50 public void changeStr(String str, Consumer<String> con){
51 System.err.println("222222");
52 con.accept(str);
53 }
54  
55 /**
56 * Supplier<T> Supply type interface
57 * @param sup
58 * @return
59 */
60 public String getValue(Supplier<String> sup){
61 System.err.println("111111");
62 return sup.get();
63 }
64  
65 /**
66 * Function<T,R> Functional interface
67 * @param num
68 * @param fun
69 * @return
70 */
71 public Long changeNum(Long num, Function<Long, Long> fun){
72 System.err.println("333333");
73 return fun.apply(num);
74 }
75  
76 /**
77 * Predicate<T> Assertion interface
78 * @param str
79 * @param pre
80 * @return
81 */
82 public boolean changeBoolean(String str, Predicate<String> pre){
83 return pre.test(str);
84 }

On the basis of the four core functional interfaces, it also provides extended functional interfaces such as BiFunction, BinaryOperation, toIntFunction, etc., which are all extended from these four functional interfaces, so we will not elaborate.

 1 // Constructor reference class name::new
 2 Supplier<String> sup = () -> new String();
 3 System.out.println(sup.get());
 4 Supplier<String> sup2 = String::new;
 5 System.out.println(sup2.get());
 6  
 7 // Constructor reference class name::new (With a parameter)
 8 //x The delegate is the parameter passed in, that is, the Integer type
 9 //new String(...) Represents the String type
10 Function<Integer, String> fun = x -> new String(String.valueOf(x));
11 System.err.println(fun.apply(100));
12 Function<String, String> fun3 = String::new;
13 System.out.println(fun3.apply("100"));

1 // Array reference
2 Function<Integer, String[]> arrayFun = (x) -> new String[x];
3 Function<Integer, String[]> arrayFun2 = String[]::new;
4 //to String The array has two lengths set. But the value is null
5 String[] strArray = arrayFun2.apply(2);
6 Arrays.stream(strArray).forEach(System.out::println);