Java入门之Lambda表达式的应用

Lambda表达式

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

Lambda语法格式

/**
 * 四则运算接口
 */
public interface MathOperation {
    public Float operate(Integer a, Integer b);
}
// Lambda语法测试类
public class LambdaSample {
    public static void main(String[] args) {
        // 1.标准Lambda语法使用方式
        // 约束条件:Lambda表达式只能实现有且只有一个抽象方法的接口, Java称为"函数式接口"
        MathOperation addition = (Integer a, Integer b) -> {
            System.out.println("加法运算");
            // 因为返回值为Float类型，+0f是隐式的转换为Float类型
            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+0f;
        System.out.println(multiplication.operate(5,  3));
    }

}

函数式编程

函数式编程是基于函数式接口并使用lambda表达的编程方式
函数式编程理念是将代码作为可重用数据代入到程序运行中
函数式编程强调"你想做什么",而不是"你想怎么做"

函数式接口

函数式接口是有且只有一个抽象方法的接口
Java中拥有大量函数式接口,如java.lang.Runnable
JDK8后提供了一系列新的函数式接口,位于java.util.function

函数式接口Predicate

Predicate是新增的函数式接口,位于java.util.function
Predicate用于测试传入的数据是否满足判断要求
Predicate接口需要实现test()方法进行逻辑判断

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

/**
 * 理解函数式编程
 * Predicate函数式接口的使用方法
 */
public class PredicateSample {
    public static void main(String[] args) {
        //Predicate接口的方法为test()，根据传入的值来判断是否满足条件
        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);

        filter(list, n->n%2==1); // 取所有奇数
        filter(list, n->n%2==0); // 取所有偶数
        filter(list, n->n%2==0 && n>5); // 取所有大于5的偶数
    }
    public static void filter(List<Integer> list, Predicate<Integer> predicate){
        for (Integer integer:list){
            if (predicate.test(integer)){
                System.out.println(integer);
            }
        }
    }
}

JDK8常用函数式接口

函数式接口Consumer

import java.util.function.Consumer;
public class ConsumerSample {
    public static void output(Consumer<String> consumer){
        String text = "天将降大任于是人也，必先苦其心志，劳其筋骨，饿其体肤，空乏其身，行拂乱其所为。";
        consumer.accept(text);
    }

    public static void main(String[] args) {
        output(s->System.out.println("向控制台打印:" + s));
    }
}

函数式接口Function

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);
    }
}

在自定义函数式接口时，如果加上@FunctionalInterface注解，则会通知编译器这是函数式接口,进行抽象方法检查

@FunctionalInterface
public interface MathOperation {
    public Float operate(Integer a, Integer b);
}

函数式编程与面向对象编程比较

Stream流式处理

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

Stream常用方法

Stream流的五种创建方法

import org.junit.Test;
import javax.swing.text.Style;
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 generate1(){
        String[] arr = {"Lily", "Andy", "Jackson", "Smith"};
        Stream<String> stream = Stream.of(arr);
        stream.forEach(s->System.out.println(s));
    }
    // 2.基于集合进行创建
    @Test
    public void generate2(){
        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方法创建无限长度流，也可以使用.limit()来限制长度
    @Test
    public void generate3(){
        Stream<Integer> stream = Stream.generate(()->new Random().nextInt(100000));
        stream.limit(10).forEach(i->System.out.println(i));
    }
    // 4.基于迭代器创建流，iterate第一个参数为初始数据，第二个参数为每次迭代的步长
    @Test
    public void generate4(){
        Stream<Integer> stream = Stream.iterate(1, n->n+1);
        stream.limit(100).forEach(i->System.out.println(i));
    }
    // 5.基于字符序列创建流，chars()返回每个字符的ASCII码
    @Test
    public void generate5(){
        String str = "abcdefg我的";
        IntStream stream = str.chars();
        stream.forEach(c->System.out.println(c));
    }
}

Stream流的常用方法

import org.junit.Test;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
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返回一个由传入函数结果组成的IntStream流
                .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))
                // 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<Integer> newList = list.stream().distinct() // 去除重复的流数据
                .filter(n->n%2==1)
                .sorted((a,b)->b-a) // 流数据排序a-b是从小到大排，b-a是从大到小排
                .collect(Collectors.toList());
        System.out.println(newList);
    }

Stream流的方法文档

https://docs.oracle.com/javase/9/docs/api/java/util/stream/package-summary.html