Java——Lambda表达式

Lambda表达式

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

Lambda语法格式

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

(参数列表)：使用逗号分隔参数；参数类型可省略；单参数括号可省略

实现语句：单行直接写；多行用{}包括

Lambda表达式只能实现有且只有一个抽象方法的接口,Java称为"函数式接口"

案例：

MathOperation.java 四则运算接口

package lambda;

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

LambdaSample.java

package lambda;

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

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

        //3. 单行实现代码可以忽略大括号和return
        MathOperation multiplication = (a, b) -> a * b + 0f;
        System.out.println(multiplication.operate(3, 4));

    }
}

函数式编程

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

函数式接口

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

JDK8常用函数式接口

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

Predicate函数式接口

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

LambdaSample.java

package lambda;

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

/**
 * 理解函数式编程
 * Predicate函数式接口的使用方法
 */
public class PredicateSample {
    public static void main(String[] args) {
        //筛选list中数字,只需要传入lambda表达式的条件即可,比如奇数,偶数,大于4...
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        filter(list, n -> n % 2 == 1);
    }

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

}

Consumer函数式接口

ConsumerSample.java

package lambda;

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));
        output(s->{
            System.out.println("向XXX网站发送数据包: " + s);
        });
    }
}

Function函数式接口

FunctionSample.java

package lambda;

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

/**
 * 利用Function函数式接口生成定长随机字符串
 */
public class FunctionSample {
    public static void main(String[] args) {
        Function<Integer, String> randomStringFunction = len -> {
            String chars = "abcdefghijklmnopqrstuvwxyz0123456789";
            StringBuffer stringBuffer = new StringBuffer();
            Random random = new Random();
            for (int i = 0; i < len; 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

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

Stream流式处理

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

Stream常用方法

https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html

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

Stream流对象的五种创建方式

package stream;

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 {
    public static void main(String[] args) {
        generator1();
        generator2();
        generator3();
        generator4();
        generator5();
    }

    //1. 基于数组进行创建  @Test说明这是一个测试用例
    public static void generator1(){
        String[] arr = {"Lily","Andy","Jackson","Smith"};
        Stream<String> stream = Stream.of(arr);     //Stream.of通过数组生成流对象
        stream.forEach(s -> System.out.println(s));
    }

    //2. 基于集合进行创建
    public static void generator2(){
        List 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. 利用generator创建无限长度流
    public static void generator3(){
        Stream<Integer> stream = Stream.generate(() -> new Random().nextInt(100000));
//        stream.forEach(i -> System.out.println(i));
        stream.limit(10).forEach(i -> System.out.println(i));
    }

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

    //5. 基于字符序列创建数据流
    public static void generator5(){
        String str = "abcdefg你好";
        IntStream intStream = str.chars();
        intStream.forEach(c-> System.out.println((char) c));
    }

}

Stream常用方法案例演示

package stream;

import org.junit.Test;

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

public class StreamMethod {
    public static void main(String[] args) {
        case1();
        case2();
        case3();
    }

    public static void case1() {
        //获取集合中的所欲偶数并求和
        List<String> list = Arrays.asList("1", "2", "3", "4", "5");
        int sum = list.stream()   //获取stream对象
                .mapToInt(s -> Integer.parseInt(s))   //mapToInt是将流中的每一个数据转换为整数
                .filter(n -> n % 2 == 0)   //filter是对数据流进行过滤
                .sum();
        System.out.println(sum);
    }

    //所有名字首字母大写
    public static void case2() {
        List<String> list = Arrays.asList("liLy","smith","jackson");
//        list.stream()
        List newlist = list.stream()
                .map(s ->s.substring(0,1).toUpperCase()+s.substring(1))
//                .forEach(s-> System.out.println(s));
                .collect(Collectors.toList());
        System.out.println(newlist);
    }

    //将所有奇数从小到大进行排序且不能重复
    public static void case3(){
        List<Integer> list = Arrays.asList(32,54,87,97,59,38,74,54,93);
        List newlist = list.stream().distinct()   //去除重复的流数据
                .filter(n->n%2 == 1)
                .sorted((a,b)->(b-a))
                .collect((Collectors.toList()));   //数据流排序
        System.out.println(newlist);
    }
}