Lambda 表达式

• JDK8 开始支持，用来让程序编写更优雅
• 可以简洁的实现匿名内部类与函数声明与调用
• 基于 Lambda 提供的 stream 流式处理极大简化对集合的操作

语法格式

(参数列表) -> 实现语句

• 参数列表使用逗号分隔参数
  • 参数类型可省略
  • 单参数括号可省略
• ->：Lambda 表达式操作符
• 实现语句单行直接写，多行用 {} 包裹

package com.imooc.lambda;

public class LambdaSample {

    public static void main(String[] args) {
        //1.标准Lambda使用方式
        //约束条件:Lambda表达式只能实现有且只有一个抽象方法的接口,Java称为"函数式接口"
        MathOperation addition = (Integer a, Integer b) -> {
            System.out.println("加法运算");
            return a + b + 0f;
        };
        System.out.println(addition.operate(5, 3));
        /* 等价代码
        class Addition implements MathOperation{
            @Override
            public Float operate(Integer a, Integer b) {
                System.out.println("加法运算");
                return a+b+0f;
            }
        }
        Addition addition = new Addition();
        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 + 0f;
        System.out.println(multiplication.operate(5, 3));
    }
}

函数式编程

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

• 将代码作为可重用数据代入到程序中
• 强调 你想做什么 而不是 你想怎么做

函数式接口

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

• Java 中拥有大量函数式接口，如 java.lang.Runnable
• JDK8 后提供了一系列的函数式接口，位于 java.util.function

Predicate

测试传入数据是否满足判断要求，用于条件判断，固定返回布尔值

• 需要实现 test() 方法进行逻辑判断

package com.imooc.lambda;

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

/**
 * 理解函数式编程
 * Predicate函数式接口的使用方法
 */
public class PredicateSample {
    public static void main(String[] args) {
        Predicate<Integer> predicate = n->n<4;
        boolean result = predicate.test(10);
        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); //取所有偶数
        filter(list,n->n>5 && n%2==0); //取所有大于5的偶数
    }
    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("");
    }
}

Consumer

Consumer<T>：对应有一个输入参数无输出的功能代码

package com.imooc.lambda;

import java.util.function.Consumer;

/**
 * Consumer接口的使用
 */
public class ConsumerSample {
    public static void main(String[] args) {
        output(s-> System.out.println("向控制台打印:" + s));
        output(s->{
            System.out.println("向XXX网站发送数据包:" + s);
        });
    }
    public static void output(Consumer<String> consumer){
        String text = "天将降大任于是人也，必先苦其心志，劳其筋骨，饿其体肤，空乏其身，行拂乱其所为。";
        consumer.accept(text);
    }
}

Function

Function<T,R>：对应有一个输入参数且需要返回数据的功能代码

package com.imooc.lambda;

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

/**
 * 利用Function函数式接口生成定长随机字符串
 */
public class FunctionSample {
    public static void main(String[] args) {
        Function<Integer, String> randomStringFunction = l -> {
            String chars = "abcdefghijklmnopqrstuvxwyz0123456789";
            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 = randomStringFunction.apply(32);
        System.out.println(randomString);
    }
}

Stream 流式处理

• 建立在 Lambda 基础上的多数据处理技术
• 对集合数据处理进行高度抽象，极大简化代码量
• 可对集合进行迭代、去重、筛选、排序、聚合等一系列处理

// 简单示例
package com.imooc.lambda;

import java.util.Arrays;
import java.util.Optional;

/**
 * 利用Function函数式接口生成定长随机字符串
 */
public class FunctionSample {
    public static void main(String[] args) {
        Optional<Integer> op = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9).stream()
          .filter(x -> x % 2 == 0)
          .sorted((a, b) -> b - a)
          .findFirst();
        System.out.println(op.get());
    }
}

常用方法

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

package com.imooc.stream;

import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

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将流中每一个数据转为整数
                .filter(n -> n % 2 == 0) //filter对流数据进行过滤
                .sum();//求和
        System.out.println(sum);
    }

    //所有名字首字母大写
    @Test
    public void case2() {
        List<String> list = Arrays.asList("lily", "smith", "jackson");
        List 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());
        System.out.println(newList);
    }

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

创建方式

package com.imooc.lambda;

import org.junit.Test;

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

/**
 * Stream流对象的五种创建方式
 */
public class StreamGenerator {
    //1.基于数组进行创建
    @Test
    public void generator1() {
        String[] arr = {"Lily", "Andy", "Jackson", "Smith"};
        Stream<String> stream = Stream.of(arr);
        stream.forEach(s -> System.out.println(s));
    }

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

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

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

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