devbox
神奇cpp
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java函数式编程

作者：神奇cpp | 2024-07-30 12:40:54

赞

踩

java函数式编程

目录

一、Lambda 表达式

1、Lambda 表达式的标准格式

2、Lambda 表达式的使用前提

3、Lambda 表达式的练习

4、Lambda 表达式的省略模式

5、Lambda 表达式的注意事项

6、Lambda 表达式与匿名内部类的区别

二、方法引用

1、方法引用符

2、Lambda 表达式支持的方法引用

3、方法引用

3.1、引用类方法

3.2、引用对象的实例方法

3.3、引用类的实例方法

3.4、引用构造器

三、函数式接口

1、函数式接口概述

2、函数式接口作为方法的参数

3、函数式接口作为方法的返回值

4、常用的函数式接口

4.1、Supplier 接口

4.2、Consumer 接口

4.3、Predicate 接口

4.4、Function 接口

四、Stream 流

4.1、Stream 流的使用

4.2、Stream 流的生成方式

4.3、Stream 流的中间操作

4.4、Stream 流的终结操作

4.5、Stream 流的收集操作

五、Optional

1、创建对象

2、消费值

3、获取值

4、过滤数据

5、判断

6、数据转换

7、注意

一、Lambda 表达式

1、Lambda 表达式的标准格式

  • ( 形式参数 ) -> { 代码块 }
  • 形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可
  • ->：由英文中画线和大于符号组成，固定写法。代表指向动作
  • 代码块：是我们具体要做的事情，也就是以前我们写的方法体内容

2、Lambda 表达式的使用前提

使用前提：

  • 有一个接口
  • 接口中有且仅有一个抽象方法

3、Lambda 表达式的练习

练习一

  • 定义一个接口（Eatable），里面定义一个抽象方法：void eat()
  • 定义一个测试类（EatableDemo），在测试类中提供两个方法
    • 一个方法是：useEatable(Eatable e)
    • 一个方法是主方法，在主方法中调用 useEatable 方法

代码如下：

  1. public interface Eatable {
  2.     void eat();
  3. }
  1. public class EatableDemo {
  2.     public static void main(String[] args) {
  3.         useEatable(() -> {
  4.             System.out.println("一天一苹果,医生远离我");
  5.         });
  6.     }
  7.  
  8.     private static void useEatable(Eatable e) {
  9.         e.eat();
  10.     }
  11. }

运行结果：

练习二

  • 定义一个接口（Flyable），里面定义一个抽象方法：void fly(String s)
  • 定义一个测试类（FlyableDemo），在测试类中提供两个方法
    • 一个方法是：useFlyable(Flyable f)
    • 一个方法是主方法，在主方法中调用 useFlyable 方法

代码如下：

  1. public interface Flyable {
  2.     void fly(String s);
  3. }
  1. public class FlyableDemo {
  2.     public static void main(String[] args) {
  3.         useFlyable((String s) -> {
  4.             System.out.println(s);
  5.         });
  6.     }
  7.  
  8.     public static void useFlyable(Flyable f) {
  9.         f.fly("风和日丽,晴空万里");
  10.     }
  11. }

运行结果：

练习三

  • 定义一个接口（Add able），里面定义一个抽象方法：int add(int x, int y)
  • 定义一个测试类（AddableDemo），在测试类中提供两个方法
    • 一个方法是：useAddable(Addable a)
    • 一个方法是主方法，在主方法中调用 useAddable 方法

代码如下：

  1. public interface Addable {
  2.     int add(int x, int y);
  3. }
  1. public class AddableDemo {
  2.     public static void main(String[] args) {
  3.         useAddable((int x, int y) -> {
  4.             return x + y;
  5.         });
  6.     }
  7.  
  8.     public static void useAddable(Addable a) {
  9.         int sum = a.add(10, 20);
  10.         System.out.println(sum);
  11.     }
  12. }

运行结果：

4、Lambda 表达式的省略模式

省略规则：

  • 参数类型可以省略。但是有多个参数的情况下，不能只省略一个
  • 如果参数有且仅有一个，那么小括号可以省略
  • 如果代码块的语句只有一条，那么可以省略大括号和分号，甚至是 return

5、Lambda 表达式的注意事项

注意事项：

  • 使用 Lambda 必须要有接口，并且要求接口中有且仅有一个抽象方法
  • 必须有上下文环境，才能推导出 Lambda 对应的接口
    • 根据局部变量的赋值得知 Lambda 对应的接口：Runnable r = () -> System.out.println("Lambda表达式“);
    • 根据调用方法的参数得知 Lambda 对应的接口：new Thread(() -> System.out.println("Lambda表达式")).start();

6、Lambda 表达式与匿名内部类的区别

所需类型不同

  • 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
  • Lambda 表达式：只能是接口

使用限制不同

  • 如果接口中有且仅有一个抽象方法，可以使用 Lambda 表达式，也可以使用匿名内部类
  • 如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用 Lambda 表达式

实现原理不同

  • 匿名内部类：编译之后，产生一个单独的 .class 字节码文件
  • Lambda 表达式：编译之后，没有一个单独的 .class 字节码文件。对应的字节码会在运行的时候动态生成

二、方法引用

1、方法引用符

方法引用符

  • :: 该符号为引用运算符，而它所在的表达式被称为方法引用

推导与省略

  • 如果使用 Lambda，那么根据 "可推导就是可省略" 的原则，无需指定参数类型，也无需指定重载形式，他们都将被自动推导
  • 如果使用方法引用，也是同样可以根据上下文进行推导
  • 方法引用是 Lambda 的孪生兄弟

2、Lambda 表达式支持的方法引用

常见的引用方法：

  • 引用类方法
  • 引用对象的实例方法
  • 引用类的实例方法
  • 引用构造器

3、方法引用

3.1、引用类方法

引用类方法，其实就是引用类的静态方法

  • 格式：类名::静态方法
  • 范例：Integer::parseInt
    • Integer 类的方法：public static int parseInt(String s) 将此 String 转换为 int 类型数据

练习：

  • 定义一个接口（Converter），里面定义一个抽象方法
    • int convert(String s)
  • 定义一个测试类（ConverterDemo），在测试类中提供两个方法
    • 一个方法是：useConverter(Converter c)
    • 一个方法是主方法，在主方法中调用 useConverter 方法

代码如下：

  1. public interface Converter {
  2.     int convert(String s);
  3. }
  1. public class ConverterDemo {
  2.     public static void main(String[] args) {
  3.         useConverter(Integer::parseInt);
  4.     }
  5.  
  6.     private static void useConverter(Converter c) {
  7.         int number = c.convert("665") + 1;
  8.         System.out.println(number);
  9.     }
  10. }

运行结果：

3.2、引用对象的实例方法

引用对象的实例方法，其实就是引用类中的成员方法

  • 格式：对象::成员方法
  • 范例："HelloWorld"::toUpperCase
    • String 类中的方法：public String toUpperCase() 将此 String 所有字符转换为大写

练习：

  • 定义一个类（PrintString），里面定义一个方法
    • public void printUpper(String s)：把字符串参数变成大写的数据，然后在控制台输出
  • 定义一个接口（Printer），里面定义一个抽象方法
    • void printUpperCase(String s)
  • 定义一个测试类（PrinterDemo），在测试类中提供两个方法
    • 一个方法是：usePrinter(Printer p)
    • 一个方法是主方法，在主方法中调用 usePrinter 方法

代码如下：

  1. public class PrintString {
  2.     public void printUpper(String s) {
  3.         System.out.println(s.toUpperCase());
  4.     }
  5. }
  1. public interface Printer {
  2.     void printUpperCase(String s);
  3. }
  1. public class PrinterDemo {
  2.     public static void main(String[] args) {
  3.         PrintString ps = new PrintString();
  4.         usePrinter(ps::printUpper);
  5.     }
  6.  
  7.     private static void usePrinter(Printer p) {
  8.         p.printUpperCase("helloWorld");
  9.     }
  10. }

运行结果：

3.3、引用类的实例方法

引用类的实例方法，其实就是引用类中的成员方法

  • 格式：类名::成员方法
  • 范例：String::substring
    • String 类中的方法：public String substring(int beginIndex, int endIndex)，从 beginIndex 开始到 endIndex 结束，截取字符串。返回一个字串，字串的长度为 endIndex-beginIndex

练习：

  • 定义一个接口（MyString），里面定义一个抽象方法
    • String mySubString(String s, int x, int y);
  • 定义一个测试类（MyStringDemo），在测试类中提供两个方法
    • 一个方法是：useMyString(MyString my)
    • 一个方法是主方法，在主方法中调用 useMyString 方法

代码如下：

  1. public interface MyString {
  2.     String mySubString(String s, int x, int y);
  3. }
  1. public class MyStringDemo {
  2.     public static void main(String[] args) {
  3.         useMyString(String::substring);
  4.     }
  5.  
  6.     private static void useMyString(MyString my) {
  7.         String s = my.mySubString("HelloWorld", 2, 5);
  8.         System.out.println(s);
  9.     }
  10. }

运行结果：

3.4、引用构造器

引用构造器，其实就是引用构造方法

  • 格式：类名::new
  • 范例：Student::new

练习：

  •  定义一个类（Student），里面有两个成员变量（name，age）
    • 并提供无参构造方法和带参构造方法，以及成员变量对应的 get 和 set 方法
  • 定义一个接口（StudentBuilder），里面定义一个抽象方法
    • Student build(String name, int age)
  • 定义一个测试类（StudentDemo），在测试类中提供两个方法
    • 一个方法是：useStudentBuilder(StringBuilder s)
    • 一个方法是主方法，在主方法中调用 useStudentBuilder 方法

代码如下：

  1. public class Student {
  2.     private String name;
  3.     private int age;
  4.  
  5.     // 省略get/set/满参构造方法
  6. }
  1. public interface StudentBuilder {
  2.     Student build(String name, int age);
  3. }
  1. public class StudentDemo {
  2.     public static void main(String[] args) {
  3.         useStudentBuilder(Student::new);
  4.     }
  5.  
  6.     private static void useStudentBuilder(StudentBuilder sb) {
  7.         Student student = sb.build("张三", 18);
  8.         System.out.println(student.getName() + "," + student.getAge());
  9.     }
  10. }

运行结果：

三、函数式接口

1、函数式接口概述

函数式接口：有且仅有一个抽象方法的接口

  • Java 中的函数式编程体现就是 Lambda 表达式，所以函数式接口就是可以适用于 Lambda 使用的接口
  • 只有确保接口中有且仅有一个抽象方法，Java 中的 Lambda 才能顺利地进行推导

如何检测一个接口是不是函数式接口呢？

  • @FunctionalInterface
  • 放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败

注意：

  • 我们自己定义函数式接口的时候，@FunctionalInterface 是可选的，就算我不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口，但是，建议加上该注解

2、函数式接口作为方法的参数

需求：

  • 定义一个类（RunnableDemo），在类中提供两个方法
    • 一个方法是：startThread(Runnable r) 方法参数 Runnable 是一个函数式接口
    • 一个方法是主方法，在主方法中调用 startThread 方法

代码如下：

  1. public class RunnableDemo {
  2.     public static void main(String[] args) {
  3.         startThread(() -> System.out.println(Thread.currentThread().getName() + " 线程启动了"));
  4.     }
  5.  
  6.     private static void startThread(Runnable r) {
  7.         new Thread(r).start();
  8.     }
  9. }

运行结果：

3、函数式接口作为方法的返回值

 需求：

  • 定义一个类（ComparatorDemo），在类中提供两个方法
    • 一个方法是：Comparator <String> getComparator() 方法返回值 Comparator 是一个函数式接口
    • 一个方法是主方法，在主方法中调用 getComparator 方法

代码如下：

  1. public class ComparatorDemo {
  2.     public static void main(String[] args) {
  3.         ArrayList<String> array = new ArrayList<>();
  4.         array.add("ccc");
  5.         array.add("aa");
  6.         array.add("b");
  7.         array.add("ddd");
  8.  
  9.         System.out.println("排序前: " + array);
  10.  
  11.         array.sort(getComparator());
  12.         System.out.println("排序后: " + array);
  13.     }
  14.  
  15.     private static Comparator<String> getComparator() {
  16.         // 如果方法的返回值是一个函数式接口,我们可以使用 Lambda 表达式作为结果返回
  17.         return (s1, s2) -> s2.length() - s1.length();
  18.     }
  19. }

运行效果：

4、常用的函数式接口

Java 8 在 java.util.function 包下与定义了大量的函数式接口供我们使用

我们重点来学习下面的 4 个接口

  • Supplier 接口
  • Consumer 接口
  • Predicate 接口
  • Function 接口

4.1、Supplier 接口

Supplier<T>：包含一个无参的方法：

  • T get()：获得结果
  • 该方法不需要参数，它会按照某种实现逻辑（由 Lambda 表达式实现）返回一个数据
  • Supplier<T> 接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的 get 方法就会生产什么类型的数据供我们使用

 练习：

  • 定义一个类（SupplierTest），在类中提供两个方法
    • 一个方法是：int getMax(Supplier<Integer> sup) 用于返回一个 int 数组中的最大值
    • 一个方法是主方法，在主方法中调用 getMax 方法

代码如下：

  1. public class SupplierTest {
  2.     public static void main(String[] args) {
  3.         int[] arr = {1, 3, 4, 5, 2};
  4.  
  5.         int max = getMax(() -> {
  6.             Arrays.sort(arr);
  7.             return arr[arr.length - 1];
  8.         });
  9.         System.out.println(max);
  10.     }
  11.  
  12.     private static int getMax(Supplier<Integer> sup) {
  13.         return sup.get();
  14.     }
  15. }

运行效果：

4.2、Consumer 接口

Consumer<T>：包含两个方法

  • void accept(T t)：对给定的参数执行此操作
  • default Consumer<T> andThen(Consumer after)：返回一个组合的 Consumer，依次执行此操作，然后执行 after 操作
  • Consumer<T> 接口也被称为消费型接口，它消费的数据的数据类型由泛型指定

 练习：

  • String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33"};
  • 字符串数组中有多条信息，请按照格式："姓名: xx,年龄: xx" 的格式将信息打印出来
  • 要求：
    • 把打印姓名的动作作为第一个 Consumer 接口的 Lambda 实例
    • 把打印年龄的动作作为第二个 Consumer 接口的 Lambda 实例
    • 将两个 Consumer 接口按照顺序组合到一起使用 

代码如下：

  1. public class ConsumerTest {
  2.     public static void main(String[] args) {
  3.         operatorString(s1 -> System.out.print("姓名: " + s1.split(",")[0] + ", "), s2 -> System.out.println("年龄: " + s2.split(",")[1]));
  4.     }
  5.  
  6.     private static void operatorString(Consumer<String> con1, Consumer<String> con2) {
  7.         String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33"};
  8.         for (String s : strArray) {
  9.             con1.andThen(con2).accept(s);
  10.         }
  11.     }
  12. }

运行效果：

4.3、Predicate 接口

Predicate<T>：常用的四个方法

  • boolean test(T t)：对给定的参数进行判断（判断逻辑由 Lambda 表达式实现），返回一个布尔值
  • default Predicate<T> negate()：返回一个逻辑的否定，对应逻辑非
  • default Predicate<T> and(Predicate other)：返回一个组合判断，对应短路与
  • default Predicate<T> or(Predicate other)：返回一个组合判断，对应短路或
  • Predicate<T> 接口通常用于判断参数是否满足指定的条件

练习：

  1. public class PredicateDemo01 {
  2.     public static void main(String[] args) {
  3.         boolean b1 = checkString1(s -> s.length() > 8);
  4.         System.out.println("b1: " + b1);
  5.  
  6.         boolean b2 = checkString2(s -> s.length() > 8);
  7.         System.out.println("b2: " + b2);
  8.  
  9.         boolean b3 = checkString3(s -> s.contains("hello"), s -> s.length() > 5);
  10.         System.out.println("b3: " + b3);
  11.  
  12.         boolean b4 = checkString4(s -> s.contains("hello"), s -> s.length() > 20);
  13.         System.out.println("b4: " + b4);
  14.     }
  15.  
  16.     // 判断给定的字符串是否满足要求
  17.     private static boolean checkString1(Predicate<String> pre) {
  18.         return pre.test("hello");
  19.     }
  20.  
  21.     private static boolean checkString2(Predicate<String> pre) {
  22.         return pre.negate().test("hello");
  23.     }
  24.  
  25.  
  26.     // 同一个字符串给出两个不同的判断条件,最后把这两个判断的结果做逻辑与运算的结果作为最终的结果
  27.     private static boolean checkString3(Predicate<String> pre1, Predicate<String> pre2) {
  28.         String s = "hello,world";
  29.         return pre1.and(pre2).test(s);
  30.     }
  31.  
  32.     private static boolean checkString4(Predicate<String> pre1, Predicate<String> pre2) {
  33.         String s = "hello,world";
  34.         return pre1.or(pre2).test(s);
  35.     }
  36. }

运行结果：

4.4、Function 接口

Function<T，R>：常用的两个方法

  • R apply(T t)：将此函数应用于给定的参数
  • default <V> Function andThen(Function after)：返回一个组合函数，首先将该函数应用于输入，然后将 after 函数应用于结果
  • Function<T，R> 接口通常用于对参数进行处理，转换（处理逻辑由 Lambda 表达式实现），然后返回一个新的值

练习：

  • String s = "林青霞,30";
  • 请按照以下指定的要求进行操作:
    • 将字符串截取得到数字年龄部分
    • 将上一步的年龄字符串转换成 int 类型的数据
    • 将上一步的 int 数据加 70，得到一个 int 结果，在控制台输出
  • 请通过 Function 接口来实现函数拼接

代码如下：

  1. public class FunctionTest {
  2.     public static void main(String[] args) {
  3.         convert1(s -> s.split(",")[1], Integer::parseInt, i -> i + 70);
  4.     }
  5.  
  6.     private static void convert1(Function<String, String> fun1, Function<String, Integer> fun2, Function<Integer, Integer> fun3) {
  7.         String s = "林青霞,30";
  8.         Integer i = fun1.andThen(fun2).andThen(fun3).apply(s);
  9.         System.out.println(i);
  10.     }
  11. }

运行结果：

四、Stream 流

4.1、Stream 流的使用

  • 生成流
    • 通过数据源（集合，数组等）生成流
  • 中间操作
    • 一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流，交给下一个操作使用
  • 终结操作
    • 一个流只能有一个终结操作，当这个操作执行后，流就被使用 “光了” ，无法再被操作。所以这必定是流的最后一个操作

4.2、Stream 流的生成方式

Stream 流的常见生成方式

  • Collection 体系的集合可以使用两个默认方法生成流
    • default Stream stream()：返回一个串行流
    • default Stream parallelStream()：返回一个并行流
  • 数组可以使用 Arrays 的静态方法 stream() 获取数组流
    • static Stream stream(T[] array)：返回一个流
    • public static IntStream stream(int[] array)
    • public static LongStream stream(long[] array)
    • public static DoubleStream stream(double[] array)
  • Stream 类的静态方法 of() 可以将显示值生成一个流
    • public static Stream of(T... values)：返回一个流
  • 可以使用静态方法 Stream.iterate() 和 Stream.generate() 创建无限流（了解）
    • 迭代：public static Stream iterate(final T seed, final UnaryOperator f)
    • 生成：public static Stream generate(Supplier s)

代码如下：

  • Collection 体系的集合可以使用两个默认方法生成流
  1.     @Test
  2.     public void test01() {
  3.         ArrayList<Object> list = new ArrayList<>();
  4.         Stream<Object> stream1 = list.stream(); // 串行流
  5.         Stream<Object> stream2 = list.parallelStream(); // 并行流
  6.     }
  • 数组可以使用 Arrays 的静态方法 stream() 获取数组流
  1.     @Test
  2.     public void test02() {
  3.         String[] arr1 = {"hello", "world"};
  4.         Stream<String> stream1 = Arrays.stream(arr1);
  5.  
  6.         int[] arr2 = {1, 2, 3};
  7.         IntStream stream2 = Arrays.stream(arr2);
  8.     }
  • Stream 类的静态方法 of() 可以将显示值生成一个流
  1.     @Test
  2.     public void test03() {
  3.         Stream<Integer> stream = Stream.of(1, 2, 3);
  4.     }
  • 可以使用静态方法 Stream.iterate() 和 Stream.generate() 创建无限流（了解）
  1.     @Test
  2.     public void test04() {
  3.         Stream<Integer> stream1 = Stream.iterate(0, x -> x + 2).limit(10);
  4.         Stream<Double> stream2 = Stream.generate(() -> Math.random() + 10).limit(10);
  5.     }

4.3、Stream 流的中间操作

  • Stream<T> filter(Predicate predicate)：筛选符合条件的元素，返回一个新的流
    • Predicate 接口中的方法        boolean test(T t)：对给定的参数进行判断，返回一个布尔值
  • Stream<T> limit(long maxSize)：返回此流中的元素组成的流，截取前指定参数个数的数据
  • Stream<T> skip(long n)：跳过指定参数个数的数据，返回由该流的剩余元素组成的流
  • Stream<T> distinct()：返回该流的不同元素（根据 Object.equals(Object)）组成的流
  • Stream<T> peek(Consumer action)：对流中的每个元素执行指定的操作，不改变流中的元素
  • <T> Stream<R> map(Function mapper)：返回由给定函数应用于此流的元素的结果组成的流
    • Function 接口中的方法        R apply(T t)
  • IntStream mapToInt(ToIntFunction mapper)：返回一个 IntStream，其中包含将给定函数应用于此流的元素的结果
  • <R> Stream<R> flatMap(Function mapper)：把一个对象转换成多个对象作为流中的元素
  • IntStream flatMapToInt(Function mapper)：将一个 Stream 中的元素分解成基本的 int 值并返回一个表示这些值的 IntStream
  • Stream<T> sorted()：返回由此流的元素组成的流，根据自然顺序排序
  • Stream<T> sorted(Comparator comparator)：返回由该流的元素组成的流，根据提供的 Comparator 进行排序
  • static<T> Stream<T> concat(Stream a, Stream b)：合并 a 和 b 两个流为一个流
  • Stream<T> paraller()：将串行流转为并行流
  • boolean isParallel()：判断一个流是否是一个并行流，返回一个布尔值
  • Stream<T> sequential()：返回一个串行流
  • Stream<T> unordered()：返回一个无序流（如果你想要一个无序的流，请使用无序集合作为数据源）

代码如下：

  • Stream<T> filter(Predicate predicate)：筛选符合条件的元素，返回一个新的流
  1.     @Test
  2.     public void test() {
  3.         int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
  4.         // 保留偶数
  5.         Arrays.stream(arr).filter(x -> x % 2 == 0).forEach(System.out::println);
  6.     }

运行结果：

  • Stream<T> limit(long maxSize)：返回此流中的元素组成的流，截取前指定参数个数的数据
  1.     @Test
  2.     public void test() {
  3.         int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
  4.         // 截取前三个元素
  5.         Arrays.stream(arr).limit(3).forEach(System.out::println);
  6.     }

运行结果：

  • Stream<T> skip(long n)：跳过指定参数个数的数据，返回由该流的剩余元素组成的流
  1.     @Test
  2.     public void test() {
  3.         int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
  4.         // 跳过前三个元素
  5.         Arrays.stream(arr).skip(3).forEach(System.out::println);
  6.     }

 运行结果：

  • Stream<T> distinct()：返回该流的不同元素（根据 Object.equals(Object)）组成的流
  1.     @Test
  2.     public void test() {
  3.         int[] arr = {1, 1, 2, 2, 3, 3};
  4.         Arrays.stream(arr).distinct().forEach(System.out::println);
  5.     }

运行结果：

  • Stream<T> peek(Consumer action)：对流中的每个元素执行指定的操作，不改变流中的元素
  1.     @Test
  2.     public void test() {
  3.         int[] arr = {1, 2, 3};
  4.         IntStream stream = Arrays.stream(arr);
  5.         stream.peek(n -> System.out.println(n + 10)).count();
  6.     }

运行结果：

  • <T> Stream<R> map(Function mapper)：返回由给定函数应用于此流的元素的结果组成的流
  1.     @Test
  2.     public void test() {
  3.         String[] numbers = {"1", "2", "3"};
  4.         Stream<Integer> stream = Arrays.stream(numbers).map(Integer::parseInt);
  5.     }
  • IntStream mapToInt(ToIntFunction mapper)：返回一个 IntStream，其中包含将给定函数应用于此流的元素的结果
  1.     @Test
  2.     public void test() {
  3.         // 类似的还有mapToLong、mapToDouble
  4.         String[] number = {"1", "2", "3"};
  5.         IntStream stream = Arrays.stream(number).mapToInt(Integer::parseInt);
  6.     }
  • <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)：把一个对象转换成多个对象作为流中的元素
  1.     @Test
  2.     public void test() {
  3.         class User {
  4.             public String[] hobby;
  5.  
  6.             public User(String[] hobby) {
  7.                 this.hobby = hobby;
  8.             }
  9.         }
  10.  
  11.         ArrayList<User> list = new ArrayList<>();
  12.         Collections.addAll(list, new User("溜冰,滑雪,篮球".split(",")), new User("乒乓球,足球,网球".split(",")));
  13.  
  14.         Stream<String> stream = list.stream().flatMap(user -> Arrays.stream(user.hobby));
  15.         stream.forEach(System.out::println);
  16.     }

运行结果：

  • IntStream flatMapToInt(Function mapper)：将一个 Stream 中的元素分解成基本的 int 值并返回一个表示这些值的 IntStream
  1.     @Test
  2.     public void test() {
  3.         class Number {
  4.             public int[] nums;
  5.  
  6.             public Number(int[] nums) {
  7.                 this.nums = nums;
  8.             }
  9.         }
  10.  
  11.         ArrayList<Number> list = new ArrayList<>();
  12.         Collections.addAll(list, new Number(new int[]{1, 2, 3}), new Number(new int[]{4, 5, 6}));
  13.  
  14.         // 类似的还有flatMapToLong、flatMapToDouble
  15.         IntStream stream = list.stream().flatMapToInt(n -> Arrays.stream(n.nums));
  16.         stream.forEach(System.out::println);
  17.     }

运行结果：

  • Stream<T> sorted()：返回由此流的元素组成的流，根据自然顺序排序
  1.     @Test
  2.     public void test() {
  3.         Stream.of(3, 1, 2).sorted().forEach(System.out::println);
  4.     }

运行结果：

  • Stream<T> sorted(Comparator comparator)：返回由该流的元素组成的流，根据提供的 Comparator 进行排序
  1.     @Test
  2.     public void test() {
  3.         class Student {
  4.             public String name;
  5.             public int chinese;
  6.             public int mathematics;
  7.             public int english;
  8.  
  9.             // 省略满参构造和toString方法
  10.         }
  11.  
  12.         ArrayList<Student> list = new ArrayList<>();
  13.         Collections.addAll(list, new Student("lisi", 90, 85, 70), new Student("zhangsan", 90, 85, 60), new Student("wangwu", 99, 75, 75));
  14.  
  15.         // 如果语文成绩相等,就比较数学成绩,如果数学成绩相等,就比较英语成绩
  16.         list.stream().sorted((n1, n2) -> n1.chinese == n2.chinese ? n1.mathematics == n2.mathematics ? n1.english - n2.english : n1.mathematics - n2.mathematics : n1.chinese - n2.chinese).forEach(System.out::println);
  17.     }

运行结果：

  • static<T> Stream<T> concat(Stream a, Stream b)：合并 a 和 b 两个流为一个流
  1.     @Test
  2.     public void test() {
  3.         Stream<Integer> stream1 = Stream.of(1, 2, 3);
  4.         Stream<Integer> stream2 = Stream.of(3, 2, 1);
  5.         
  6.         Stream.concat(stream1, stream2).forEach(System.out::println);
  7.     }

运行结果：

  • Stream<T> paraller()：将串行流转为并行流
  1.     @Test
  2.     public void test() {
  3.         Stream<Integer> parallelStream = Stream.of(1, 2, 3).parallel();
  4.     }
  • boolean isParallel()：判断一个流是否是一个并行流，返回一个布尔值
  1.     @Test
  2.     public void test() {
  3.         int[] arr = {1, 2, 3};
  4.  
  5.         System.out.println(Arrays.stream(arr).isParallel()); // 串行流
  6.         System.out.println(Arrays.stream(arr).parallel().isParallel()); // 并行流
  7.     }

运行结果：

  • Stream<T> sequential()：返回一个串行流
  1.     @Test
  2.     public void test() {
  3.         ArrayList<Integer> list = new ArrayList<>();
  4.         Stream<Integer> stream = list.parallelStream().sequential();
  5.         System.out.println(stream.isParallel());
  6.     }

 运行结果：

  • Stream<T> unordered()：返回一个无序流（如果你想要一个无序的流，请使用无序集合作为数据源）
  1.     @Test
  2.     public void test() {
  3.         ArrayList<Integer> arrayList = new ArrayList<>();
  4.         Collections.addAll(arrayList, 1, 2, 3);
  5.  
  6.         Stream<Integer> stream1 = arrayList.stream().unordered();
  7.         stream1.forEach(System.out::println); // 输出 1 2 3
  8.         System.out.println();
  9.  
  10.         // unordered()方法并不能保证输出的结果一定是无序的，而只是告诉Stream类，在进行后续操作时，可以不保留元素的原始顺序，以提高并行处理性能。
  11.         LinkedList<Object> linkedList = new LinkedList<>();
  12.         Collections.addAll(linkedList, 1, 2, 3);
  13.         Stream<Object> stream2 = linkedList.stream().unordered();
  14.         stream2.forEach(System.out::println);
  15.     }

运行结果：

4.4、Stream 流的终结操作

  • void forEach(Consumer action)：对流中的每个元素执行此操作
  • <A> A[] toArray(IntFunction<A[]> generator)：将流中的元素转换为指定类型的数组
  • long count()：返回流中的元素总数
  • sum()：返回流中所有数值类型的总和，返回类型为 int 或 long 或 duble
  • boolean anyMatch(Predicate<? super T> predicate)：判断是否有任意符合匹配条件的元素
  • boolean allMatch(Predicate<? super T> predicate)：判断是否都符合匹配条件
  • boolean noneMatch(Predicate<? super T> predicate)：判断流中的元素是否都不符合匹配条件
  • Optional<T> max(Comparator<? super T> comparator)：根据比较器返回流中最大值的 Optional
  • Optional<T> min(Comparator<? super T> comparator)：根据比较器返回流中最小值的 Optional
  • Optional<T> findAny()：获取流中的任意一个元素
  • Optional<T> findFirst()：获取流中的第一个元素
  • Iterator<T> iterator()：返回一个迭代器
  • reduce 归并，对流中的数据按照你制定的计算方式计算出一个结果（缩减操作）
    • Optional reduce(BinaryOperator accumulator)
    • T reduce(T identity, BinaryOperator accumulator)

代码如下：

  • void forEach(Consumer action)：对流中的每个元素执行此操作
  1.     @Test
  2.     public void test() {
  3.         Stream.of(1, 2, 3).forEach(System.out::println);
  4.     }

运行结果：

  •  <A> A[] toArray(IntFunction<A[]> generator)：将流中的元素转换为指定类型的数组
  1.     @Test
  2.     public void test() {
  3.         Integer[] arr = Stream.of(1, 2, 3).toArray(Integer[]::new);
  4.     }
  • long count()：返回流中的元素总数
  1.     @Test
  2.     public void test() {
  3.         long count = Stream.of(1, 2, 3).count();
  4.         System.out.println(count);
  5.     }

运行结果：

  • sum()：返回流中所有数值类型的总和，返回类型为 int 或 long 或 duble
  1.     @Test
  2.     public void test() {
  3.         ArrayList<String> list = new ArrayList<>();
  4.         int sum1 = list.stream().mapToInt(Integer::valueOf).sum();
  5.         long sum2 = list.stream().mapToLong(Long::valueOf).sum();
  6.         double sum3 = list.stream().mapToDouble(Double::valueOf).sum();
  7.     }
  • boolean anyMatch(Predicate<? super T> predicate)：判断是否有任意符合匹配条件的元素
  1.     @Test
  2.     public void test() {
  3.         boolean b = Stream.of(1, 2, 3).anyMatch(n -> n == 2);
  4.         System.out.println(b);
  5.     }

运行结果：

  • boolean allMatch(Predicate<? super T> predicate)：判断是否都符合匹配条件
  1.     @Test
  2.     public void test() {
  3.         boolean b = Stream.of(1, 2, 3).allMatch(n -> n == 2);
  4.         System.out.println(b);
  5.     }

运行结果：

  • boolean noneMatch(Predicate<? super T> predicate)：判断流中的元素是否都不符合匹配条件
  1.     @Test
  2.     public void test() {
  3.         boolean b = Stream.of(1, 2, 3).allMatch(n -> n != 0);
  4.         System.out.println(b);
  5.     }

 运行结果：

  • Optional<T> max(Comparator<? super T> comparator)：根据比较器返回流中最大值的 Optional
  1.     @Test
  2.     public void test() {
  3.         class User {
  4.             public String name;
  5.             public int age;
  6.  
  7.             public User(String name, int age) {
  8.                 this.name = name;
  9.                 this.age = age;
  10.             }
  11.         }
  12.  
  13.         ArrayList<User> list = new ArrayList<>();
  14.         Collections.addAll(list, new User("zhangsan", 2), new User("lisi", 1), new User("wangwu", 3));
  15.  
  16.         Optional<User> maxOptional = list.stream().max((n1, n2) -> n1.age - n2.age);
  17.         System.out.println(maxOptional.get().name + " " + maxOptional.get().age);
  18.     }

 运行结果：

  • Optional<T> min(Comparator<? super T> comparator)：根据比较器返回流中最小值的 Optional
  1.     @Test
  2.     public void test() {
  3.         class User {
  4.             public String name;
  5.             public int age;
  6.  
  7.             public User(String name, int age) {
  8.                 this.name = name;
  9.                 this.age = age;
  10.             }
  11.         }
  12.  
  13.         ArrayList<User> list = new ArrayList<>();
  14.         Collections.addAll(list, new User("zhangsan", 2), new User("lisi", 1), new User("wangwu", 3));
  15.  
  16.         Optional<User> maxOptional = list.stream().min((n1, n2) -> n1.age - n2.age);
  17.         System.out.println(maxOptional.get().name + " " + maxOptional.get().age);
  18.     }

运行结果：

  • Optional<T> findAny()：获取流中的任意一个元素
  1.     @Test
  2.     public void test() {
  3.         Optional<Integer> optional = Stream.of(1, 2, 3, 4, 5, 6, 7).parallel().filter(i -> i % 2 == 0).findAny();
  4.         System.out.println(optional.get());
  5.     }

运行结果： 

  • Optional<T> findFirst()：获取流中的第一个元素
  1.     @Test
  2.     public void test() {
  3.         Optional<Integer> optional = Stream.of(1, 2, 3).findFirst();
  4.         System.out.println(optional.get());
  5.     }

运行结果：

  • Iterator<T> iterator()：返回一个迭代器
  1.     @Test
  2.     public void test() {
  3.         Iterator<Integer> iterator = Stream.of(1, 2, 3).iterator();
  4.         while (iterator.hasNext()) {
  5.             System.out.println(iterator.next());
  6.         }
  7.     }

运行结果：

  • reduce 归并，对流中的数据按照你制定的计算方式计算出一个结果（缩减操作）
  1.     @Test
  2.     public void test1() {
  3.         // Optional reduce(BinaryOperator accumulator)
  4.         Integer[] arr = {1, 2, 3};
  5.         Optional<Integer> optional = Arrays.stream(arr).reduce((n1, n2) -> n1 + n2);
  6.         System.out.println("sum: " + optional.get());
  7.     }
  8.  
  9.     @Test
  10.     public void test2() {
  11.         // T reduce(T identity, BinaryOperator accumulator)
  12.         Integer[] arr = {1, 2, 3};
  13.         Integer sum1 = Arrays.stream(arr).reduce(0, (n1, n2) -> n1 + n2);
  14.         Integer sum2 = Arrays.stream(arr).reduce(10, (n1, n2) -> n1 + n2);
  15.         System.out.println("sum1: " + sum1);
  16.         System.out.println("sum2: " + sum2);
  17.     }

运行结果：

4.5、Stream 流的收集操作

对数据使用 Stream 流的方式操作完毕后，我想把流中的数据收集到集合中，该怎么办呢？

Stream 流的收集方法

  • R collect(Collector collector)
  • 但是这个收集方法的参数是一个 Collector 接口

工具类 Collectors 提供了具体的收集方法

  • public static <T> Collector toList()：把元素收集到 List 集合中
  • public static <T> Collector toSet()：把元素收集到 Set 集合中
  • public static Collector toMap(Function keyMapper, Function valueMapper)：把元素收集到 Map 集合中
  • public static Collector toCollection(Supplier<C> collectionFactory)：把元素收集到创建的集合
  • public static <T> Collector counting()：计算流中元素的个数
  • public static <T> Collector summingInt(ToIntFunction<? super T> mapper) ：对流中的整数属性求和
  • public static <T> Collector averagingInt(ToIntFunction<? super T> mapper)：计算流中元素 Integer 属性的平均值
  • public static <T> Collector summarizingInt(ToIntFunction<? super T> mapper)：收集流中 Integer 属性的统计值。如最大值、最小值等等
  • public static Collector joining()：连接流中每个字符串
  • public static <T> Collector maxBy(Comparator<? super T> comparator)：根据比较器选择最大值
  • public static <T> Collector minBy(Comparator<? super T> comparator)：根据比较器选择最小值
  • public static <T> Collector reducing(T identity, BinaryOperator<T> op)：从一个累加器的初始值开始，利用 BinaryOperator 与流中元素逐个结合，从而归约成单个值
  • public static<T,A,R,RR> Collector<T,A,RR> collectingAndThen(Collector<T,A,R> downstream,Function<R,RR> finisher)：它是一个将流中的元素先进行收集，然后再对收集的结果执行一些操作的收集器
  • public static <T, K> Collector groupingBy(Function<? super T, ? extends K> classifier)：根据某属性对流分组，属性为 K，结果为 V
  • public static <T> Collector partitioningBy(Predicate<? super T> predicate)：根据 true 或 false 进行分区

代码如下：

  • public static <T> Collector toList()：把元素收集到 List 集合中
  1.     @Test
  2.     public void test() {
  3.         String[] arr = {"1", "1", "2", "2", "3", "3"};
  4.         List<Integer> list = Arrays.stream(arr).map(Integer::valueOf).map(n -> n + 10).collect(Collectors.toList());
  5.         System.out.println(list);
  6.     }

运行结果：

  • public static <T> Collector toSet()：把元素收集到 Set 集合中
  1.     @Test
  2.     public void test() {
  3.         String[] arr = {"1", "1", "2", "2", "3", "3"};
  4.         Set<Integer> set = Arrays.stream(arr).map(Integer::valueOf).map(n -> n + 10).collect(Collectors.toSet());
  5.         System.out.println(set);
  6.     }

运行结果：

  • public static Collector toMap(Function keyMapper, Function valueMapper)：把元素收集到 Map 集合中
  1.     @Test
  2.     public void test() {
  3.         String[] arr = {"1", "2", "3"};
  4.         Map<String, String> map = Arrays.stream(arr).map(Integer::valueOf).map(n -> n + 10).collect(Collectors.toMap(n -> "key: " + n, n -> "value: " + n));
  5.         System.out.println(map);
  6.     }

 运行结果：

  • public static Collector toCollection(Supplier<C> collectionFactory)：把元素收集到创建的集合
  1.     @Test
  2.     public void test() {
  3.         String[] arr = {"1", "2", "3"};
  4.         ArrayList<Integer> arrayList = Arrays.stream(arr).map(Integer::valueOf).map(n -> n + 10).collect(Collectors.toCollection(ArrayList::new));
  5.         LinkedList<Integer> linkedList = Arrays.stream(arr).map(Integer::valueOf).map(n -> n + 10).collect(Collectors.toCollection(LinkedList::new));
  6.     }
  • public static <T> Collector<T, ?, Long> counting()：计算流中元素的个数
  1.     @Test
  2.     public void test() {
  3.         String[] arr = {"1", "2", "3"};
  4.         Long count = Arrays.stream(arr).collect(Collectors.counting());
  5.         System.out.println(count);
  6.     }

运行结果：

  • public static <T> Collector<T, ?, Integer> summingInt(ToIntFunction<? super T> mapper) ：对流中的整数属性求和
  1.     @Test
  2.     public void test() {
  3.         class User {
  4.             public String name;
  5.             public int age;
  6.  
  7.             public User(String name, int age) {
  8.                 this.name = name;
  9.                 this.age = age;
  10.             }
  11.         }
  12.  
  13.         User[] users = {new User("jack", 18), new User("tom", 19), new User("rose", 20)};
  14.         // 类似的还有summingDouble、summingLong
  15.         Integer sum = Arrays.stream(users).collect(Collectors.summingInt(user -> user.age));
  16.         System.out.println(sum);
  17.     }

运行结果：

  • public static <T> Collector averagingInt(ToIntFunction<? super T> mapper)：计算流中元素 Integer 属性的平均值
  1.     @Test
  2.     public void test() {
  3.         class User {
  4.             public String name;
  5.             public int age;
  6.  
  7.             public User(String name, int age) {
  8.                 this.name = name;
  9.                 this.age = age;
  10.             }
  11.         }
  12.  
  13.         User[] users = {new User("jack", 18), new User("tom", 19), new User("rose", 20)};
  14.         // 类似的还有averagingDouble、averagingLong
  15.         Double avg = Arrays.stream(users).collect(Collectors.averagingInt(user -> user.age));
  16.         System.out.println(avg);
  17.     }

运行结果：

  • public static <T> Collector summarizingInt(ToIntFunction<? super T> mapper)：收集流中 Integer 属性的统计值。如最大值、最小值等等
  1.     @Test
  2.     public void test() {
  3.         class User {
  4.             public String name;
  5.             public int age;
  6.  
  7.             public User(String name, int age) {
  8.                 this.name = name;
  9.                 this.age = age;
  10.             }
  11.         }
  12.  
  13.         ArrayList<User> list = new ArrayList<>();
  14.         Collections.addAll(list, new User("jack", 18), new User("tom", 19), new User("rose", 20));
  15.         // 类似的还有 summarizingDouble、summarizingLong
  16.         IntSummaryStatistics intSummaryStatistics = list.stream().collect(Collectors.summarizingInt(u -> u.age));
  17.         System.out.println(intSummaryStatistics);
  18.     }

运行结果：

  • public static Collector joining()：连接流中每个字符串
  1.     @Test
  2.     public void test() {
  3.         class User {
  4.             public String name;
  5.             public int age;
  6.  
  7.             public User(String name, int age) {
  8.                 this.name = name;
  9.                 this.age = age;
  10.             }
  11.         }
  12.  
  13.         ArrayList<User> list = new ArrayList<>();
  14.         Collections.addAll(list, new User("jack", 18), new User("tom", 19), new User("rose", 20));
  15.         String str = list.stream().map(u -> u.name).collect(Collectors.joining());
  16.         System.out.println(str);
  17.     }

运行结果：

  • public static <T> Collector maxBy(Comparator<? super T> comparator)：根据比较器选择最大值
  1.     @Test
  2.     public void test() {
  3.         Optional<Integer> optional = Stream.of(2, 3, 1).collect(Collectors.maxBy((n1, n2) -> n1 - n2));
  4.         System.out.println(optional.get());
  5.     }

运行结果：

  •  public static <T> Collector minBy(Comparator<? super T> comparator)：根据比较器选择最小值
  1.     @Test
  2.     public void test() {
  3.         Optional<Integer> optional = Stream.of(2, 3, 1).collect(Collectors.minBy((n1, n2) -> n1 - n2));
  4.         System.out.println(optional.get());
  5.     }

运行结果：

  • public static <T> Collector reducing(T identity, BinaryOperator<T> op)：从一个累加器的初始值开始，利用 BinaryOperator 与流中元素逐个结合，从而归约成单个值
  1.     @Test
  2.     public void test() {
  3.         Integer sum = Stream.of(1, 2, 3).collect(Collectors.reducing(0, Integer::sum));
  4.         System.out.println(sum);
  5.     }

运行结果：

  • public static<T,A,R,RR> Collector<T,A,RR> collectingAndThen(Collector<T,A,R> downstream,Function<R,RR> finisher)：它是一个将流中的元素先进行收集，然后再对收集的结果执行一些操作的收集器
  1.     @Test
  2.     public void test() {
  3.         Integer size = Stream.of(1, 2, 3).collect(Collectors.collectingAndThen(Collectors.toList(), list -> list.size()));
  4.         System.out.println(size);
  5.     }

运行结果：

  • public static <T, K> Collector groupingBy(Function<? super T, ? extends K> classifier)：根据某属性对流分组，属性为 K，结果为 V
  1.     @Test
  2.     public void test() {
  3.         Map<Integer, List<Integer>> map = Stream.of(1, 2, 3).collect(Collectors.groupingBy(n -> n));
  4.         System.out.println(map);
  5.     }

运行结果：

  • public static <T> Collector partitioningBy(Predicate<? super T> predicate)：根据 true 或 false 进行分区
  1.     @Test
  2.     public void test() {
  3.         Map<Boolean, List<Integer>> map = Stream.of(1, 2, 3).collect(Collectors.partitioningBy(n -> n % 2 == 0));
  4.         System.out.println(map);
  5.     }

 运行结果：

五、Optional

我们在编写代码的时候出现最多的就是空指针异常。所以在很多情况下我们需要做各种非空的判断。例如：

  1. if (xxx!=null){
  2.             
  3. }

而过多的判断语句会让我们的代码显得臃肿不堪。

所以在 JDK8 引入了 Optional，养成使用 Optional 的习惯后你可以写出更优雅的代码来避免空指针异常。

1、创建对象

  • Optional.of(T t)：创建一个 Optional 实例，t 必须非空
  • Optional.empty()：创建一个空的 Optional 实例
  • Optional.ofNullable(T t)：t 可以为 null

代码如下：

  1. Cat cat = new Cat("tom", 3);
  2.  
  3. Optional<Cat> optionalCat1 = Optional.of(cat);
  4. Optional<Cat> optionalCat2 = Optional.empty();
  5. Optional<Cat> optionalCat3 = Optional.ofNullable(cat);

2、消费值

  • void ifPresent(Consumer<? super T> consumer)：如果有值，就执行 Consumer 接口的实现代码，并且该值会作为参数传给它

代码如下：

  1. Cat cat = new Cat("tom", 3);
  2.  
  3. Optional<Cat> optionalCat = Optional.ofNullable(cat);
  4. optionalCat.ifPresent(s -> System.out.println("name: " + s.getName()));

运行结果：

3、获取值

  • T get()：如果调用对象包含值，返回该值，否则抛异常（不推荐）
  • T orElse(T other)：如果有值则将其返回，否则返回指定的 other 对象
  • T orElseGet(Supplier<? extends T> other)：如果有值则将其返回，否则返回由 Supplier 接口实现提供的对象
  • T orElseThrow(Supplier<? extends X> exceptionSupplier)：如果有值则将其返回，否则抛出由 Supplier 接口实现提供的异常

代码如下：

  • T get()：如果调用对象包含值，返回该值，否则抛异常（不推荐）
  1. System.out.println(Optional.ofNullable(new Cat("tom", 3)).get());
  2. System.out.println(Optional.ofNullable(null).get());

 运行结果：

  • T orElse(T other)：如果有值则将其返回，否则返回指定的 other 对象
  1. System.out.println(Optional.ofNullable(new Cat("tom", 3)).orElse(new Cat("rose", 4)));
  2. System.out.println(Optional.ofNullable(null).orElse(new Cat("rose", 4)));

 运行结果：

  •  T orElseGet(Supplier<? extends T> other)：如果有值则将其返回，否则返回由 Supplier 接口实现提供的对象
  1. System.out.println(Optional.ofNullable(new Cat("tom", 3)).orElseGet(() -> new Cat("rose", 4)));
  2. System.out.println(Optional.ofNullable(null).orElseGet(() -> new Cat("rose", 4)));

运行结果：

  •  T orElseThrow(Supplier<? extends X> exceptionSupplier)：如果有值则将其返回，否则抛出由 Supplier 接口实现提供的异常
  1. System.out.println(Optional.ofNullable(new Cat("tom", 3)).orElseThrow(() -> new RuntimeException("cat为空")));
  2. System.out.println(Optional.ofNullable(null).orElseThrow(() -> new RuntimeException("cat为空")));

运行结果：

4、过滤数据

我们可以使用 filer 方法对数据进行过滤。如果原本是有数据的，但是不符合判断，也会变成一个无数据的 Optional 对象

代码如下：

Optional.ofNullable(new Cat("tom", 3)).filter(c -> c.getAge() > 5).ifPresent(System.out::println);

 运行结果：

5、判断

  • boolean isPresent()：判断是否包含对象

代码如下：

System.out.println(Optional.ofNullable(null).isPresent());

 运行结果：

6、数据转换

  • Optional<U> map(Function<? super Object,? extends U> mapper)：对数据进行转换
  • Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper)：对数据进行转换

代码如下：

  1.     @Test
  2.     public void test() {
  3.         String str = "hello";
  4.  
  5.         // map() 方法用于将 Optional 对象中的值进行转换，而 flatMap() 方法用于将 Optional 对象中的值进行转换，并返回一个包含值的 Optional 对象
  6.         Optional<String> s1 = Optional.ofNullable(str).map(String::toUpperCase);
  7.         Optional<String> s2 = Optional.ofNullable(str).flatMap(s -> Optional.of(s.toUpperCase()));
  8.     }

7、注意

  • 无论 Optional 对象中的值是否为空，orElse() 函数都会执行，而 orElseGet() 函数只有在 Optional 对象中的值为空时，orElseGet() 中的 Supplier 方法才会执行
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/神奇cpp/article/detail/903798
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号