一、Lambda表达式说明

1、什么是Lambda表达式

JDK8开始支持Lambda表达式，用来让程序编写更加优雅

利用Lambda可以更简洁的**实现匿名内部类**与**函数式声明与调用**

基于Lambda提供Stream流失处理极大简化对集合的操作

Lambda语法格式

(参数列表)  -> 实现语句
   ↓               ↓
使用逗号分割参数   单行直接写
参数类型可省略     多行用{}包括
单参数括号课省略

新建一个demo尝试一下

首先新建一个接口

package com.xmaven.lambda;

/**
 * @ClassName MathOperation
 * @Description TODO 四则运算接口
 * @Author Ambition
 * @Date 2021/2/7 20:30
 * @Version 1.0.0
 **/
public interface MathOperation {

    public Float operate(Integer a,Integer b);

}

编写lambda测试用例

package com.xmaven.lambda;

/**
 * @ClassName LambdaSample
 * @Description TODO
 * @Author Ambition
 * @Date 2021/2/7 20:31
 * @Version 1.0.0
 **/
public class LambdaSample {

    public static void main(String[] args) {
        /**
         * lambda约束条件:lambda表达式只能实现有且只有一个抽象方法的接口，java称为函数式接口
         * 也就是说，有且只有一个的抽象方法
         */
        // 1、标准lambda使用方式
        MathOperation addition = (Integer a, Integer b) -> {
            System.out.println("加法运算");
            return a + b + 0f;
        };
        System.out.println(addition.operate(5, 3));

        // 2、Lambda允许忽略参数类型
        MathOperation substraction = (a, b) -> {
            return a - b + 0f;
        };
        System.out.println(substraction.operate(5, 3));

        // 3、当行实现代码可以省略大括号和return
        MathOperation multiplication = (a, b) -> a * b * 1f;
        System.out.println(multiplication.operate(5, 3));
    }

}

二、基于Lambda实现函数式编程

1、什么是函数式编程

函数式编程是基于函数式接口并使用lambda表达的编程方式

函数式编程理念就是将代码作为可重用数据代入到程序运行中去

函数式编程强调"你想做什么",而不是"你想怎么做"

2、什么是函数式接口

函数式接口有且只有一个抽象方法的接口

java中拥有大量的函数式接口，如java.lang.Runnable

JDK8后提供了一系列的新的函数式接口，位于java.util.function

学习最简单的函数式接口Predicate

Predicate是新增的函数式接口，位于java.util.function

Predicate是用于测试传入的数据是否满足判断的要求

Predicate接口需要实现test()方法进行逻辑判断

编写demo

package com.xmaven.lambda;

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

/**
 * @ClassName PredicateSample
 * @Description TODO 理解函数式编程 Predicate函数式接口的使用方法
 * @Author Ambition
 * @Date 2021/2/7 20:52
 * @Version 1.0.0
 **/
public class PredicateSample {

    public static void main(String[] args) {
        Predicate<Integer> predicate = n -> n > 4;
        boolean result = predicate.test(3);
        System.out.println(result);
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        /*for (Integer num : list) {
            if (num % 2 == 1) {
                System.out.println(num);
            }
        }*/
        filter(list, n -> n % 2 == 1); // 取所有的奇数

        filter(list, n -> n % 2 == 0); // 取所有的偶数
    }

    public static void filter(List<Integer> list, Predicate<Integer> predicate) {
        for (Integer num : list) {
            if (predicate.test(num)) {
                System.out.print(num + " ");
            }
        }
        System.out.println();
    }

}

3、Java8常用函数式接口

接口	用途
Consumer	对应有一个输入参数无输出的功能代码
Function<T,R>	对应有一个输入参数且需要返回数据的功能代码
Predicate	用于条件判断，固定返回布尔值

3.1Consumer接口测试

package com.xmaven.lambda;

import java.util.function.Consumer;

/**
 * @ClassName ConsumerSample
 * @Description TODO Consumer接口的使用
 * @Author Ambition
 * @Date 2021/2/7 21:17
 * @Version 1.0.0
 **/
public class ConsumerSample {

    public static void output(Consumer<String> consumer) {
        String text = "Hello,World";
        consumer.accept(text);
    }

    public static void main(String[] args) {
        output(s -> System.out.println("向控制台打印:" + s));
        output(s -> {
            // 模拟，具体逻辑自己手动编写
            System.out.println("向xxx网站发送数据包" + s);
        });

    }

}

3.2Function接口测试

package com.xmaven.lambda;

import java.util.Random;
import java.util.function.Function;

/**
 * @ClassName FunctionSample
 * @Description TODO 利用Function函数式接口生成定长随机字符串
 * @Author Ambition
 * @Date 2021/2/7 21:27
 * @Version 1.0.0
 **/
public class FunctionSample {

    public static void main(String[] args) {
        Function<Integer,String> randomFunction = l -> {
          String chars = "abcdefhigklmnopqrstuvwxyz0123456789";
          StringBuffer stringBuffer = new StringBuffer();
            Random random = new Random();
            for (int i = 0; i < l; i++) {
                int position = random.nextInt(chars.length());
                stringBuffer.append(chars.charAt(position));
            }
            return stringBuffer.toString();
        };
        String randomString = randomFunction.apply(16);
        System.out.println(randomString);
    }

}

注意：

java中对函数式编程有一个特殊的注解@FunctionalInterface
这个注解会通知编译器这是一个函数式接口，进行抽象方法检查
这个是作用于只有一个抽象方法的接口
如下代码:

package com.xmaven.lambda;

/**
 * @ClassName MathOperation
 * @Description TODO 四则运算接口
 * @Author Ambition
 * @Date 2021/2/7 20:30
 * @Version 1.0.0
 **/
@FunctionalInterface
public interface MathOperation {

    public Float operate(Integer a,Integer b);

}

4、函数式编程和面向对象编程的比较

	面向对象编程	函数式编程
设计思路	面向对象	面向过程
开发侧重	侧重过程，重分析，重设计	侧重结果，快速实现
可读性	结构复杂，相对较差	更适合人眼阅读，可读性好
代码量	多	少
并发问题	设计不当，会出现线程安全问题	不会出现线程安全问题
健壮性	好	差
使用场景	中大型/大型项目，多人协作工程	小型应用，要求快速实现

三、Stream流式处理

Stream流式处理是建立在lambda基础上的多数据处理技术

Stream对集合数据处理进行高度抽象，极大简化代码

Stream可对集合进行迭代、去重、筛选、排序、聚合等一系列处理

1、Stream常用方法

接口	用途
forEach	循环遍历
map	map方法用于映射每个元素到对应的结果
filter	filter方法用于通过设置的条件过滤出元素
limit	limit方法用于获取指定数量的流
sorted	sorted方法用于对流进行排序
Collectors	Collectors类实现将流转换成集合和聚合元素

2、Stream操作实例

package com.xmaven.stream;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Random;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * @ClassName StreamGenerator
 * @Description TODO Stream 流对象的五种创建方式
 * @Author Ambition
 * @Date 2021/2/7 22:01
 * @Version 1.0.0
 **/
public class StreamGenerator {
    //1、基于数据创建
    @Test
    public void generator1() {
        String[] arr = {"Lily", "Andy", "Tom", "Smith"};
        Stream<String> stream = Stream.of(arr);
        stream.forEach(s -> System.out.println(s));
    }

    //2、基于集合进行创建
    @Test
    public void generator2() {
        ArrayList<String> list = new ArrayList<>();
        list.add("Lily");
        list.add("Andy");
        list.add("Tom");
        list.add("Smith");
        Stream<String> stream = list.stream();
        stream.forEach(s -> System.out.println(s));
    }

    //3、利用generator方法创建无限长度的流
    @Test
    public void generator3() {
        Stream<Integer> stream = Stream.generate(() -> new Random().nextInt(100000));
        // limit() 可以限制流的长度
        stream.limit(10).forEach(integer -> System.out.println(integer));
    }

    //4、基于迭代器创建流
    @Test
    public void generator4() {
        Stream<Integer> stream = Stream.iterate(1, n -> n + 1);
        stream.limit(100).forEach(integer -> System.out.println(integer));
    }

    //5、基于字符序列创建流
    @Test
    public void generator5() {
        String str = "abcdefg我的";
        IntStream stream = str.chars();
        // 如果要原字符输出就使用(char)c
        stream.forEach(c -> System.out.println(c));
    }
}

3、Stream常用方法

package com.xmaven.stream;

import org.junit.Test;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @ClassName StreamMethod
 * @Description TODO
 * @Author Ambition
 * @Date 2021/2/7 22:18
 * @Version 1.0.0
 **/
public class StreamMethod {

    //提取集合中所有的偶数并求和
    @Test
    public void case1(){
        List<String> list = Arrays.asList("1", "2", "3", "4", "5", "6");
        int sum = list.stream() //获取Stream对象
                .mapToInt(s -> Integer.parseInt(s)) // mapToInt把String转Int
                .filter(n -> n % 2 == 0)
                .sum();
        System.out.println(sum);
    }

    //所有名字首字母大写
    @Test
    public void case2(){
        List<String> list = Arrays.asList("c", "java", "python", "go", "ruby");
        List<String> newList = list.stream()
                // 按照跪着对每一个流数据进行转换
                .map(s -> s.substring(0, 1).toUpperCase() + s.substring(1))
//                .forEach(s -> System.out.println(s));
                //collect对流数据进行收集，生成新的List/Set
                .collect(Collectors.toList());
        newList.forEach(s -> System.out.println(s));
    }

    // 将所有奇数从小到大进行排序，切不许出现重复
    @Test
    public void case3(){
        List<Integer> list = Arrays.asList(1, 60, 38, 32, 21, 53, 77, 60, 53, 73);
        List<Integer> newList = list.stream().distinct() //去除重复的流数据
                .filter(n -> n % 2 == 1)
                .sorted((a, b) -> a - b)
                .collect(Collectors.toList());
        System.out.println(newList);
    }

}