Java 8新特性探究（Lambda 表达式、Stream API）

前言

最近在查漏补缺Java的基础知识，过程中看到了有视频提及一个Java 8 新特性，所以特意查了一下到底是什么，结果找到了下面的内容，感兴趣的可以自行看一下，下面我对里面的Lambda 表达式、Stream API进行一些演示操作。

学习内容

Lambda 表达式

什么是Lambda表达式

Lambda 表达式，也可称为闭包，Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。使用 Lambda 表达式可以使代码变的更加简洁紧凑。

Lambda与传统方式对比

传统的列表排序：

public class ListSort {
    public static void main(String[] args) {
        List<Integer> names = Arrays.asList(2, 43, 51, 8, 10, 99);
        //实现集合排序
        Collections.sort(names, new Comparator<Integer>() {
            @Override
            public int compare(Integer a, Integer b) {
                return b.compareTo(a);
            }
        });
        System.out.println(names);
    }
}

使用Lambda 表达式的列表排序：

public class ListSort {
    public static void main(String[] args) {
        List<Integer> names = Arrays.asList(2, 43, 51, 8, 10, 99);
        //实现集合排序
        Collections.sort(names, (a, b) -> b.compareTo(a));
        System.out.println(names);
    }
}

Lambda 表达式标准格式

(参数列表) -> {     
	//TODO
	//实现语句
	}

Lambda 表达式五种写法

为了更好的演示这几种写法的区别，我们定义一个计算接口，然后通过实现这个接口的抽象方法演示几种写法，代码如下：

Tip:Lambda 表达式只能实现有且只有一个抽象方法的接口，在Java中称为“函数式接口”。

---

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

1. 标准写法(参数列表、参数列表括号、实现语句的括号均不省略)

//1.标准写法
MathOperation operation1 = (Integer a, Integer b) -> {
    System.out.print("加法运算：");
    return a + b + 0f;
};
System.out.println(operation1.operate(5, 5));

2. 省略参数类型

//2.省略参数类型
MathOperation operation2 = (a, b) -> {
    System.out.print("减法运算：");
    return a - b + 0f;
};
System.out.println(operation2.operate(8, 5));

3. 省略实现语句的{}(实现语句必须是单行)

//3.实现语句为单行可以省略{}
MathOperation operation3 = (a, b) ->a * b + 0f;
System.out.println(operation3.operate(8, 5));

4. 单个参数可以忽略()

//        参数 -> {
//            //TODO
//        }

5. 不需要参数，直接返回

//        () -> 5

函数式编程

函数式编程属于"结构化编程"的一种，主要思想是把运算过程尽量写成一系列嵌套的函数调用。

什么是函数式编程

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

什么是函数式接口

• 函数式接口有且只有一个抽象方法
• Java中拥有大量函数式接口，例如：java.lang.Runanle
• JDK 8后提供了一系列新的函数式接口，位于java.util.function
  官方文档地址

Predicate函数式接口

用于条件判断，返回一个布尔值！

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

public class PredicatensSample {
    public static void main(String[] args) {
        //判断是否大于4
        Predicate<Integer> predicate = n -> n>4;
        boolean result = predicate.test(8);
        System.out.println(result);
    }
}

//输出：true

Consumer函数式接口

对应有一个输入参数无输出的功能代码！

public class ConsumerSample {
    public static void main(String[] args) {
        output(s -> System.out.println("输出结果为：" + s));
    }

    public static void output(Consumer<String> consumer){
        String text = "我正在学习Java 8 新特性！";
        consumer.accept(text);
    }
}

Function函数式编程

对应有一个输入参数需要返回数据的功能代码！

public class FunctionSample {
    public static void main(String[] args) {
        /**
         * 生成随机字符串
         */
        Function<Integer, String> randomStringFuncton = x -> {
            String chars = "abcdefghijklmnopqrstuvwxyz0123456789";
            StringBuilder stringBuilder = new StringBuilder();
            Random random = new Random();
            for (int i=0;i<x;i++){
                int position = random.nextInt(chars.length());
                stringBuilder.append(chars.charAt(position));
            }
            return stringBuilder.toString();
        };
        String randomString = randomStringFuncton.apply(20);
        System.out.println(randomString);
    }
}

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

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

Stream

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。
这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。

什么是Stream

• Stream流式处理是建立在lambad基础上的多数据处理技术
• Stream对集合数据处理进行高度抽象，极大简化代码量
• Stream可以对集合进行迭代、去重、排序等操作
• 相关处理操作的文档

创建Stream的方式

1. 基于数组创建

    //1.基于数组创建
    @Test
    public void generator1(){
        String[] arr = {"aa", "bb", "cc", "dd", "ee"};
        Stream<String> stream = Stream.of(arr);
        stream.forEach(s -> System.out.println(s));
    }

2. 基于列表创建

    //2：基于列表创建
    @Test
    public void generator2() {
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd", "ee");
        Stream<String> stream = list.stream();
        stream.forEach(s -> System.out.println(s));
    }

Tip:这里还有三种方式，但是前面这两种比较常用，感兴趣的可以看一下这篇文章的介绍，很详细了！

原文地址

---

Stream常用方法

提供的方法很多，这里演示几个怎么使用。

public class Stream {
    @Test
    public void function1(){
        List<String> list = Arrays.asList("1", "2", "3", "4", "5", "6", "7", "8", "9", "10");
        int sum = list.stream()  //获取stream对象
                .mapToInt(s -> Integer.parseInt(s))  //转化为整型
                .filter(n -> n%2== 0)   //过滤偶数
                .sum();    //求和
        System.out.println(sum);
    }
}

查看其他常用方法

总结

花了一个小时差不多把上面一点内容整理完了，关于Java 8 的其他新特性，后面可能也会继续去看看，但是上面几个建议是掌握，因为可以在一定程度上加快我们的开发效率。
冲！！！

作者：专业bug开发
时间：2022年3月17日21:41:31