Java Lamada

Collection：

->stream：返回一个以 colleciotn 元素为数据源的数据流。

-->map: 入参 Function 对象，将此流中的元素依次作用于传入的 Function，然后返回新的数据流。

示例：

List<String> list = new ArrayList<>();
        list.add("1");
        list.add("10");
        list.add("100");
        List<Integer> ilist = list
                .stream() //流对象
                .map(Integer::valueOf) //对元素应用 Integer.valueOf 函数，String 转换为 Integer 
                .collect(Collectors.toList());

输出：[1, 10, 100]

--peak: 入参 Function 对象，无返回值（void 函数），将此流中的元素依次作用于传入的 Function，然后返回新的数据流

class TOBJ {
            String ele;

            public String getEle() {
                return ele;
            }

            public void setEle(String ele) {
                this.ele = ele;
            }

            TOBJ(String value) {
                this.ele = value;
            }

            @Override
            public String toString() {
                return "TOBJ{" +
                        "ele='" + ele + '\'' +
                        '}';
            }
        }
        List<TOBJ> list = new ArrayList<>();
        list.add(new TOBJ("a"));
        list.add(new TOBJ("b"));
        list.add(new TOBJ("c"));
        List<TOBJ> slist = list
                .stream() //流对象
                .peek(item -> item.setEle(item.getEle().toUpperCase()))
                .collect(Collectors.toList());

输出：[TOBJ{ele='A'}, TOBJ{ele='B'}, TOBJ{ele='C'}]

--flatMap: 入参 Function 对象，将此流中的元素依次作用于传入的 Function，产生每个对象的流，然后合并各元素的流返回新的数据流。流合并操作。

示例：

List<String> list = new ArrayList<>();
        list.add("1|2|3");
        list.add("10|2|30");
        list.add("1|200|300");
        List<Integer> ilist = list
                .stream() //流对象
                .map(item -> item .split("\\|")) //分割元素为数组
                .flatMap(Arrays::stream)
                .map(Integer::valueOf)
                .collect(Collectors.toList());

输出：[1, 2, 3, 10, 2, 30, 1, 200, 300]

-->distinct: 去重

 List<String> list = new ArrayList<>();
        list.add("1|2|3");
        list.add("10|2|30");
        list.add("1|200|300");
        List<Integer> ilist = list
                .stream() //流对象
                .map(item -> item .split("\\|")) //分割元素为数组
                .flatMap(Arrays::stream)
                .map(Integer::valueOf)
                .distinct()
                .collect(Collectors.toList());

输出：[1, 2, 3, 10, 30, 200, 300]

-->sorted：入参 Comparator，根据传入的Comparator排序。

class TOBJ {
            String ele;

            public String getEle() {
                return ele;
            }

            public void setEle(String ele) {
                this.ele = ele;
            }

            TOBJ(String value) {
                this.ele = value;
            }

            @Override
            public String toString() {
                return "TOBJ{" +
                        "ele='" + ele + '\'' +
                        '}';
            }
        }
        List<TOBJ> list = new ArrayList<>();
        list.add(new TOBJ("d"));
        list.add(new TOBJ("b"));
        list.add(new TOBJ("c"));
        List<TOBJ> slist = list
                .stream() //流对象
                .sorted(Comparator.comparing(TOBJ::getEle)) //根据 ele 元素排序
                .collect(Collectors.toList());

输出：[TOBJ{ele='b'}, TOBJ{ele='c'}, TOBJ{ele='d'}]

--reduce: 入参 BinaryOperator，对流元素做连续两两运算，最后返回与流元素相同类型结果：

List<Integer> ilist = new ArrayList(){{
            add(100);
            add(2);
            add(5);
            add(2);
        }};
        Optional<Integer> sum = ilist.stream().reduce(Integer::sum);

输出：Optional[109]

--> ... ...