java8之Stream数据流介绍(3)

 XML Code 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

package com.lyzx.day03;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.function.BinaryOperator;

import org.junit.Test;

/**
 * Stream 的终止操作
 * 终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如： List、 Integer，甚至是 void
 *
 */
public class T3 {

    /**
     * 查找与匹配 
     * 方 法 描 述
     * allMatch(Predicate p) 检查是否匹配所有元素
     * anyMatch(Predicate p) 检查是否至少匹配一个元素
     * noneMatch(Predicate p) 检查是否没有匹配所有元素
     * findFirst() 返回第一个元素
     */
    private static List<String> data = Arrays.asList("a","b","AB","BC","ABCDEF");
    @Test
    public void test1(){
        boolean match = data.stream()
            //.sorted()
            //.allMatch(item->{return item.length()>2;});
            //.anyMatch(item->item.length()>2);
            .noneMatch(item->item.length()>4);
        System.out.println(match);
            
    }
    
    @Test
    public void test2(){
        Optional<String> first = data.stream()
            //.sorted()
            //.findFirst();
            .findAny();
        System.out.println(first.get());
    }
    
    
    /**
     * count() 返回流中元素总数
     * max(Comparator c) 返回流中最大值
     * min(Comparator c) 返回流中最小值
     */
    @Test
    public void test3(){
        long count = data.stream()
            .sorted()
            .count();
        System.out.println(count);
    }
    
    @Test
    public void test4(){
        Optional<String> value = data.stream()
            .sorted()
            .max((x,y)->{
                if(x.length()>y.length()) return 1;
                if(x.length()<y.length()) return  -1;
                return 0;
            });
        System.out.println(value.get());
    }
    
    
    /**
     *  精简，规约
     *  reduce(T identity, BinaryOperator<T> accumulator)
     *       可以将流中元素反复结合起来,得到一个值。返回 T类型的值
     *       identity是一个初始值
     *       accumulator累加器 是一个二元操作，只有一个泛型，就是传入两个T类型的值，返回一个T类型的值
     *  
     */
    @Test
    public void test5(){
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Integer sum = list.stream()
             //0是初始值,先把0赋值给x然后把第一项赋值给给y，再计算x+y
             //然后把计算出来的结果赋值给x，再把第二项赋值给y，再次计算x+y
             //以此类推
             .reduce(0,(x,y)->x+y);
        System.out.println(sum);
    }
    
    /**
     * reduce(BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。返回 Optional<T>
     */
    @Test
    public void test6(){
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Optional<Integer> op = list.stream()
            //没有初始值,所以结果有可能为空
            .reduce((x,y)->x+y);
        System.out.println(op.get());
    }
    
    
    /**
     * 计算名字中包含
     */
    @Test
    public void test7(){
        List<Emp> emps = Arrays.asList(
                  new Emp("雷军",50,91.0),
                  new Emp("罗永浩a",45,92.0),
                  new Emp("黄章b",47,100.00),
                  new Emp("绿巨人a",9,88.0),
                  new Emp("蜘蛛man",28,800));
        
        long count = emps.stream()
            .mapToInt(item->{
                        String name = item.getName();
                        return (name.contains("a"))?1:0;
                    })
            .reduce(0,(x,y)->x+y);
            //也可以知己使用sum函数计算包含a的员工个数
            //.sum();
        System.out.println(count);  
    }
}