函数式编程概念-Lambda表达式

一、函数式编程概念

面向对象编程是对数据进行抽象，而函数式编程是对行为进行抽象。现实世界中，数据和行为并存，程序也是如此，因此这两种编程方式我们都得学，而学好这些编程思想并不是一天两天的事情。我们首先要关心的是如何应用现有知识写出质量更高的代码。而写好写出高质量的代码就又需要我们不断的更新自己的知识面，跟上新技术的节奏。前面我们在学RxJava的时候就常用到类似下面这种写法。

RxView.clicks(btn3)
        .throttleFirst(1000, TimeUnit.MILLISECONDS)
        .observeOn(Schedulers.io())
        .flatMap( o -> wanAndroidApi.getProject())
        .flatMap(projectBean -> Observable.fromIterable(projectBean.getData()))
        .flatMap(dataBean -> wanAndroidApi.getProjectItem(1,dataBean.getId()))
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(projectItem -> Log.i(TAG, "projectItem: " + projectItem));

这样的代码让人一眼看出来就狠舒服（当然是懂这种写法的人来看，不懂得人只会一脸懵逼）。那么这种写法就是我们今天要说得lambda(很多人纠结这个怎么念，今天就教你们：“那么大”)

二、什么是lambda表达式

Lambda是一个匿名函数，即没有函数名的函数(简化了匿名委托的使用，让你让代码更加简洁)

通常情况下我们如果想把一段函数赋值给一个变量该怎么做？（啥玩意，函数赋值给变量？我咋没见过呢？其实你每天都在见，但是就是不知道而已）。不会lambda表达式的人都是这样来做的：

//匿名内部类，是不是很熟悉，是不是每天都能见到，是不是每天都在写？
Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.print("hello toroot");
    }
};

而会lambda表达式的人是这样来写的：

//lambda   是不是一下简洁了好多？
Runnable r2 = ()->System.out.print("hello toroot");

但是lambda表达式到底要怎样来写呢？有什么语法规则呢？很多人和我一样都是懵逼的。

（1）、lambda表达式语法格式

• 语法格式一、无参数，无返回值

 ()->{System.out.print("hello toroot")};

前面的（）对应的是Runnable的run方法，由于run方法无参数，所以这里也不需要传参。后面的{}对应的是run方法中要执行的逻辑，如果只有一条逻辑语句这里的{}可以省略不写。

• 语法格式二：有一个参数，并且无返回值

 

(x) -> {System.out.println(x)}；

同上（）对应的是方法，（）内的x对应的是方法入参，{}对应的是方法内要执行的逻辑语句，如果逻辑语句只有一条的话{}可以省略。

扫描二维码关注公众号，回复： 9459016 查看本文章

• 语法格式三：有两个以上的参数，有返回值，并且 Lambda 体中有多条语句

Comparator<Integer> com = (x, y) -> {
   	 System.out.println("函数式接口");
   	 return Integer.compare(x, y);
};

同上（）对应的是方法，内部的x,y对应的是方法的入参。{}对应的是方法内部逻辑语句，return对应方法返回值，这里返回一个比较后的int值。如果方法内的逻辑语句只有一条的话，{}可以省略，就变成了下面这样

Comparator<Integer> com = (x, y) -> Integer.compare(x, y);

可能有人会问，为什么lambda表达式的参数都没有指定参数类型？那是因为JVM编译器通过上下文推断出，数据类型，即“类型推断”。

（2）、函数式接口

 Lambda 表达式需要“函数式接口”的支持 函数式接口：接口中只有一个抽象方法的接口，称为函数式接口。 可以使用注解 @FunctionalInterface 修饰可以检查是否是函数式接口

@FunctionalInterface
public interface MyFun<T> {
    public T getValue(T t);
}

public static void main(String[] args) {
//这里的第一个参数就可以使用lambda表达式
    String newStr = toUpperString((str)->str.toUpperCase(),"toroot");
    System.out.println(newStr);
}

public static String  toUpperString(MyFun<String> mf,String str) {
    return mf.getValue(str);
}

三、方法引用

 当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！（实现抽象方法的参数列表，必须与方法引用方法的参数列表保持一致！） 方法引用：使用操作符 “ ::” 将方法名和对象或类的名字分隔开来。 如下三种主要使用情况 

• 对象 :: 实例方法
• 类 :: 静态方法
• 类 :: 实例方法

（1）、什么时候可以用 ::方法引用（重点）

在我们使用Lambda表达式的时候，”->”右边部分是要执行的代码，即要完成的功能，可以把这部分称作Lambda体。有时候，当我们想要实现一个函数式接口的那个抽象方法，但是已经有类实现了我们想要的功能，这个时候我们就可以用方法引用来直接使用现有类的功能去实现。文字解释有点绕，我们直接上代码

        Person p1 = new Person("婧儿",18,90);
        Person p2 = new Person("宝宝",20,0);
        Person p3 = new Person("奶狗",17,100);
        List<Person> list = new ArrayList<>();
        list.add(p1);
        list.add(p2);
        list.add(p3);

//这里我们需要比较list里面的person,按照年龄排序，那么我们最常见的做法是：sort(List<T> list, Comparator<? super T> c)

• 1. 因为我们的sort方法的第二个参数是一个接口，所以我们需要实现一个匿名内部类

Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person person1, Person person2) {
                return person1.getAge().compareTo(person2.getAge());
            }
        });

• 2. 但仔细一看，会发现因为第二个参数是一个@FunctionalInterface的函数式接口，所以我们可以用lambda写法

  Collections.sort(list, (person1,person2) -> person1.getScore().compareTo(person2.getAge()));

• 3. 因为第二个参数我们可以用lambda的方式去实现，但是刚好又有一段代码(Comparator.comparing)已经实现了这个功能，这个时候我们就可以采用方法引用了

    /**
         * 重点：
         * 当我们想要实现一个函数式接口的那个抽象方法，但是已经有类实现了我们想要的功能，
         * 这个时候我们就可以用方法引用来直接使用现有类的功能去实现。但是我们自己在开发中最好还是不	要用这种写法。个人觉得这种写法会牺牲代码的可读性，最少对不是狠清楚方法引用的人来说理解起来会很烦。
         */
        Collections.sort(list, Comparator.comparing(Person::getAge));
        System.out.println(list);

注意： 当需要引用方法的第一个参数是调用对象，并且第二个参数是需要引 用方法的第二个 参数( ( 或无参数) ) 时 ： ClassName::methodName。

BiPredicate<String,String> bp = (str1, str2) ->str1.equals(str2);
BiPredicate<String,String> bp2 = String::equals;
try {
    bp.test("11","11");
    bp2.test("22","33");
} catch (Exception e) {
    e.printStackTrace();
}

（2）、构造器引用（非重点，但得看得懂）

 格式： ClassName :: new

与函数式接口相结合，自动与函数式接口中方法兼容。 可以把构造器引用赋值给定义的方法，与构造器参数列表要与接口中抽象方法的参数列表一致！

public static void main(String[] args) {
    Supplier<Person> x = ()->new Person();
    Supplier<Person> x2 = Person::new;//这里需要注意，new出来的对象需要用函数式接口（Supplier）来接收实例对象
}

public static void main(String[] args) {
    Function<String,Person> f  = x->new Person(x);
    Function<String,Person> f2 = Person::new;//可以发现，JVM会自行判断构造函数
}

 （3）、数组引用

非重点，但得看得懂 。格式： type[] :: new

public static void main(String[] args) {
    Function<Integer,Person[]> f  = x->new Person[x];
   Function<Integer,Person[]>  f2 = Person[]::new;
}

四、Stream API

 （1）、流 (Stream)是什么

Stream是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。 “集合讲的是数据，流讲的是计算！ ” 注意：

• Stream 自己不会存储元素。
• Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
• Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

（2）、Stream 操作实例

<1>、取出所有大于18岁人的姓名，按字典排序，并输出到控制台

 private static  List<Person> persons = Arrays.asList(
            new Person("CJK",19,"女"),
            new Person("BODUO",20,"女"),
            new Person("JZ",21,"女"),
            new Person("anglebabby",18,"女"),
            new Person("huangxiaoming",5,"男"),
            new Person("ROY",18,"男")
    );
public static void main(String[] args) throws IOException {
/*
*这里解释一下整条语句的调用逻辑：filter（）筛选出合格的Person，
*map将所有合格的Person的Name重新打包成一个List<String>数据流
*然后再调用sorted()进行自然排序，最后调用forEach()打印出排序后的name。
*/
 persons.stream().filter(x->x.getAge()>=18).map(Person::getName).sorted().forEach(System.out::println);
}

（3）、Stream 的操作三个步骤

1. 创建 Stream 一个数据源（如：集合、数组），获取一个流
2. 中间操作 一个中间操作链，对数据源的数据进行处理
3. 终止操作(终端操作) 一个终止操作，执行中间操作链，并产生结果

创建 Stream的四种方式

• Collection 提供了两个方法 stream() 与 parallelStream()
• 通过 Arrays 中的 stream() 获取一个数组流
• 通过 Stream 类中静态方法 of()
• 创建无限流

@Test
public void test1(){
    //1. Collection 提供了两个方法  stream() 与 parallelStream()
    List<String> list = new ArrayList<>();
    Stream<String> stream = list.stream(); //获取一个顺序流
    Stream<String> parallelStream = list.parallelStream(); //获取一个并行流

    //2. 通过 Arrays 中的 stream() 获取一个数组流
    Integer[] nums = new Integer[10];
    Stream<Integer> stream1 = Arrays.*stream*(nums);

    //3. 通过 Stream 类中静态方法 of()
    Stream<Integer> stream2 = Stream.of(1,2,3,4,5,6);
    
    //4. 创建无限流
    //迭代
    Stream<Integer> stream3 = Stream.iterate(0, (x) -> x + 2).limit(10);
    stream3.forEach(System.out::println);

    //生成
    Stream<Double> stream4 = Stream.generate(Math::random).limit(2);
    stream4.forEach(System.out::println);
}

中间操作

1. 筛选与切片

• filter——接收 Lambda ， 从流中排除某些元素。
• limit——截断流，使其元素不超过给定数量。
• skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
• distinct——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素

1. 映射

• map——接收 Lambda ， 将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
• flatMap——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

1. 排序

• sorted()——自然排序
• sorted(Comparator com)——定制排序

那么开发中过程中问题来了：

（1）、有个数组Integer[] ary = {1,2,3,4,5,6,7,8,9,10} ，现在需要取出中间的第三到第五个元素

List<Integer> collect = Arrays.stream(ary).skip(2).limit(3).collect(Collectors.toList());

（2）、有个数组Integer[] ary = {1,2,2,3,4,5,6,6,7,8,8,9,10}，取出里面的偶数，并去除重复

List<Integer> list = Arrays.stream(ary).filter(x -> x % 2 == 0).distinct().collect(Collectors.toList());//这种是List数据流实现，由于List不带去重功能，所以调用Stream的distinct去重。
Set<Integer> integerSet = Arrays.stream(ary).filter(x -> x % 2 == 0).collect(Collectors.toSet());//这种是Set数据流实现

 （3）、有个二维数组，要求把数组组合成一个一维数组，并排序（1，2，3，4，5……12）

Integer[][] ary = {{3,8,4,7,5}, {9,1,6,2}, {0,10,12,11} };
Arrays.stream(ary).flatMap(item->Arrays.stream(item)).sorted().forEach(System.out::println);

终止操作

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

（1）、查找与匹配

接口	说明
allMatch(Predicate p)	检查是否匹配所有元素
anyMatch(Predicate p)	检查是否至少匹配一个元素
noneMatch(Predicate p)	检查是否没有匹配到所有元素
findFirst()	返回第一个元素
findAny()	返回当前流中的任意元素
count()	返回流中元素总数
max(Comparator c)	返回流中最大值
min(Comparator c)	返回流中最小值
forEach(Consumer c)	迭代

那么问题又来了：有这样一个数组 Integer[] ary = {1,2,3,4,5,6,7,8,9,10}

<1>、检查是否所有元素都小于10

boolean b1 = Arrays.stream(ary).allMatch(s->s<10);

<2>、检查是否至少有一个元素小于2

boolean b2 = Arrays.stream(ary).anyMatch(s->s<2);

<3>、检查是不是没一个元素大于10

boolean b3 = Arrays.stream(ary).noneMatch(s->s>10);

 归约

reduce(T iden, BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。返回 T reduce(BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。返回 Optional<T>

问题：求数组Integer[] ary = {1,2,3,4,5,6,7,8,9,10}的总和

int b4 = Arrays.stream(ary).reduce((i,j)->i+j).get();

收集

 collect(Collector c) 将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法 Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到 List、Set、Map)。 Collectors实用类提供了很多静态方法，可以方便地创建常见收集器实例 具体方法与实例如下：

• toList List<T> 把流中元素收集到List

List<Person> emps= list.stream().collect(Collectors.toList());

•  toSet Set<T> 把流中元素收集到Set

Set<Person> emps= list.stream().collect(Collectors.toSet());

•  toCollection Collection<T> 把流中元素收集到创建的集合

Collection<Person> emps=list.stream().collect(Collectors.toCollection(ArrayList::new));

•  counting Long 计算流中元素的个数

long count = list.stream().collect(Collectors.counting());

•  summing Int Integer 对流中元素的整数属性求和

int total=list.stream().collect(Collectors.summingInt(Person::getAge));

•  averaging Int Double 计算流中元素Integer属性的平均值

double avg= list.stream().collect(Collectors.averagingInt(Person::getAge));

•  summarizingInt IntSummaryStatistics 收集流中Integer属性的统计值。如：平均值

Int SummaryStatisticsiss= list.stream().collect(Collectors.summarizingInt(Person::getAge));

•  joining String 连接流中每个字符串

String str= list.stream().map(Person::getName).collect(Collectors.joining());

•  maxBy Optional<T> 根据比较器选择最大值

Optional<Person> max= list.stream().collect(Collectors.maxBy(comparingInt(Person::getSalary)));

•  minBy Optional<T> 根据比较器选择最小值

Optional<Person> min = list.stream().collect(Collectors.minBy(comparingInt(Person::getSalary)));

•  reducing 归约产生的类型 从一个作为累加器的初始值开始，利用BinaryOperator与流中元素逐个结合，从而归约成单个值

int total=list.stream().collect(Collectors.reducing(0, Person::getSalar, Integer::sum));

•  collectingAndThen 转换函数返回的类型 包裹另一个收集器，对其结果转换函数

int how= list.stream().collect(Collectors.collectingAndThen(Collectors.toList(), List::size));

•  groupingBy Map<K, List<T>> 根据某属性值对流分组，属性为K，结果为V

Map<Person.Status,List<Person>> map= list.stream().collect(Collectors.groupingBy(Person::getStatus));

partitioningBy Map<Boolean, List<T>> // 根据true或false进行分区

Map<Boolean,List<Person>>vd= list.stream().collect(Collectors.partitioningBy(Person::getManage));