Java Lambda学习

Java Lambda学习

1. 前言

最近开放项目的时候总感觉许多时候代码冗余，所以打算好好研究研究lamdba来让代码看起来更简介

2. 初探Lambda

最经典的莫过于集合排序

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {

    public static void main(String[] args) {
        List goods = new ArrayList<>();
        goods.add(new Good("Apple", 30));
        goods.add(new Good("Pear", 10));
        goods.add(new Good("Banana", 20));
        System.out.println("before sort");
        goods.forEach(g -> System.out.println(g));

        /**
        **通过lambda进行比较排序，代替Compator的作用
        */
        Collections.sort(goods, (p1, p2) -> Integer.compare(p1.value, p2.value));
        System.out.println("after sort");
        goods.forEach(g -> System.out.println(g));

    }

    private static class Good {
        String name;
        int value;

        public Good(String name, int value) {
            this.name = name;
            this.value = value;
        }
        @Override
        public String toString() {
            return name + "->" + value;
        }
    }
}

• 当lambda的参数为1个的时候可以省略小括号，当lambda的函数体只有一条的时候也可以省略大括号

• 在编译器可以推断出类型的时候，可以省略参数类型，因为这的compator的参数类型只能是Good,所以p1和p2的数据类型一定为Good,故可以省略参数类型。

• 不仅在编写compator的时候可以采用lambda表达式，例如list的foreach也可以使用lambda表达式，例如打印列表的每一个元素。

3.Lambad应用

首先定义一个筛选类

    private static class GoodFilter {
        public void printSomeGood(List goods, Predicate p) {
            /**
            * 列表的foreach+java.util.function的Predicate筛选
            */
            goods.forEach(g -> {
                if (p.test(g))
                    System.out.println(g);
            });
        }

    }

进行筛选操作

    Predicate expensive = g -> g.value >= 20;
    Predicate cheap = g -> g.value < 20;
    GoodFilter filter = new GoodFilter();
    System.out.println("Expensive Goods list");
    filter.printSomeGood(goods, expensive);
    System.out.println("Cheap Goods list");
    filter.printSomeGood(goods, cheap);

• Predicate为java.util.function包中函数，该包下的其他函数请自行百度学习
• 与以前定义接口和接口实现的大量代码相比较，无疑简洁很多。

4. Stream API 介绍

Stream 就如同一个迭代器（Iterator），单向，不可往复，数据只能遍历一次，遍历过一次后即用尽了，就好比流水从面前流过，一去不复返。而和迭代器又不同的是，Stream可以并行化操作，迭代器只能命令式地、串行化操作.

    /**
    * 流式操作，先筛选，再将符合条件的元素转化为其value值，最后相加打印
    */
    int sum = goods.stream()
                .filter(g -> g.value >= 20)
                .mapToInt(g -> g.value)
                .sum();
    System.out.println(sum);

     /**
    * 流式操作，先筛选，再将符合条件的商品转化为其姓名，最后应用变为小写的操作，最后通过foreach打印
    */

    List ret = goods.stream()
             .filter(g -> g.value >= 20)
             .map(g -> g.name)
             .map(String::toLowerCase)
             .collect(Collectors.toList());
    ret.forEach(p->System.out.println(p));

• 要注意的是goods的元素并没有改变，每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换）。