Lambda表达式

最新推荐文章于 2024-09-21 10:38:43 发布

Rex·Lin

最新推荐文章于 2024-09-21 10:38:43 发布

阅读量111

点赞数 1

分类专栏： Lambda 文章标签： lambda java 编程语言

本文链接：https://blog.csdn.net/GiantApe/article/details/109253705

版权

Lambda 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Lambda表达式

什么是Lambda表达式

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

Lambda表达式语法格式：

说明：

在这里插入图片描述

代码示例：

MathOperation.java

package com.imooc.lambda;

/**
 * 四则运算接口
 * @author CubeMonkey
 * @create 2020-10-23 17:39
 */
@FunctionalInterface //通知编译器这是函数式接口，进行抽象方法检查
public interface MathOperation {
    public Float operate(Integer a, Integer b);
}

LambdaSample.java

package com.imooc.lambda;

/**
 * @author CubeMonkey
 * @create 2020-10-23 17:42
 */
public class LambdaSample {
    public static void main(String[] args) {
        //1.标准的使用方式
        //约束条件：Lambda表达式只能实现有且只有一个抽象方法的接口，Java称为"函数式接口"
        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+0f;
        System.out.println(multiplication.operate(5, 3));

        //test
        MathOperation division = (a, b) ->{
            System.out.println("除法运算");
            return a * 1.0f / b;
        };
        System.out.println(division.operate(5, 3));
    }
}

函数式编程

什么是函数式编程

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

什么是函数式接口

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

JDK8常用函数式接口

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

一、函数式接口Predicate

说明：

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

代码示例：

package com.imooc.lambda;

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

/**
 * 理解函数式编程
 * Predicate函数式接口的使用方法
 * @author CubeMonkey
 * @create 2020-10-23 18:20
 */
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

代码示例：

package com.imooc.lambda;

import java.util.function.Consumer;

/**
 * Consumer接口的使用
 * @author CubeMonkey
 * @create 2020-10-23 18:57
 */
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

代码示例：

package com.imooc.lambda;

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

/**
 * 利用Function函数式接口生成定长随机字符串
 * @author CubeMonkey
 * @create 2020-10-23 19:07
 */
public class FunctionSample {
    public static void main(String[] args) {
        Function<Integer, String> randomStringFunction = 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();
        };
        System.out.println(randomStringFunction.apply(32));
    }
}

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

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

Stream流式处理

什么是Stream流式处理

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

Stream常用方法

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

Stream流的五种创建方式

package com.imooc.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流对象的五种创建方式
 * @author CubeMonkey
 * @create 2020-10-23 19:50
 */
public class StreamGenerator {

    //基于数组进行创建
    @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(c));
    }

}

Stream常用方法代码示例

package com.imooc.stream;

import org.junit.Test;

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

/**
 * @author CubeMonkey
 * @create 2020-10-23 20:29
 */
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(num -> num % 2 == 0)//filter对流数据进行过滤
                .sum();//求和
        System.out.println(sum);
    }
    //所有名字首字母大写
    @Test
    public void case2(){
        List<String> list = Arrays.asList("lily", "smith", "jackson");
        Stream<String> stream = list.stream();
        //按规则对每一个流进行转化
        List<String> collect = stream.map(s -> s.substring(0, 1).toUpperCase() + s.substring(1))
                //collect对流数据进行收集，生成新的List/Set
                .collect(Collectors.toList());
        for (String s : collect) {
            System.out.println(s);
        }
    }

    //将所有奇数从大到小进行排序，且不许出现重复
    @Test
    public void case3(){
        List<Integer> list = Arrays.asList(1, 60, 38, 21, 51, 60, 51, 73);

        List<Integer> newList = list.stream().filter(num -> num % 2 == 1)
                .distinct()
                .sorted((a, b) -> b - a)
                .collect(Collectors.toList());
        System.out.println(newList);

    }
}