lambda 表达式高级

知其所_以然

已于 2024-01-07 21:36:10 修改

阅读量54

点赞数 1

文章标签： java 开发语言

于 2023-10-21 22:06:49 首次发布

本文链接：https://blog.csdn.net/m0_52542073/article/details/133966795

版权

1、函数式接口

只有一个抽象方法的接口我们称之为函数接口。

JDK的函数式接口都加上了 @FunctionalInterface 注解进行标识。但是无论是否加上该注解只要接口中只有一个抽象方法，都是函数式接口。

2、方法引用

我们在使用lambda时不需要考虑什么时候用方法引用，用哪种方法引用，方法引用的格式是什么。我们只需要在写完lambda方法发现方法体只有一行代码，并且是方法的调用时使用快捷键尝试是否能够转换成方法引用即可。当我们方法引用使用的多了慢慢的也可以直接写出方法引用。

基本格式：类名/对象名::方法名

2.1、引用类的静态方法

使用前提：如果我们在重写方法的时候，方法体中只有一行代码，并且这行代码是调用了某个类的静态方法，并且我们把要重写的抽象方法中所有的参数都按照顺序传入了这个静态方法中，这个时候我们就可以引用类的静态方法。

例如：

如下代码就可以用方法引用进行简化

List<Author> authors = getAuthors();
Stream<Author> authorStream = authors.stream();
authorStream.map(author -> author.getAge())
                .map(age->String.valueOf(age));

注意，如果我们所重写的方法是没有参数的，调用的方法也是没有参数的也相当于符合以上规则。

优化后如下：

List<Author> authors = getAuthors();
Stream<Author> authorStream = authors.stream();
authorStream.map(author -> author.getAge())
                .map(String::valueOf);

2.2、引用对象的实例方法

格式：对象名::方法名

使用前提：如果我们在重写方法的时候，方法体中只有一行代码，并且这行代码是调用了某个对象的成员方法，并且我们把要重写的抽象方法中所有的参数都按照顺序传入了这个成员方法中，这个时候我们就可以引用对象的实例方法。

例如：

List<Author> authors = getAuthors();
Stream<Author> authorStream = authors.stream();
StringBuilder sb = new StringBuilder();
authorStream.map(author -> author.getName())
                .forEach(name->sb.append(name));

优化后：

List<Author> authors = getAuthors();
Stream<Author> authorStream = authors.stream();
StringBuilder sb = new StringBuilder();
authorStream.map(author -> author.getName())
                .forEach(sb::append);

2.3、引用类的实例方法

格式：类名::方法名

使用前提：如果我们在重写方法的时候，方法体中只有一行代码，并且这行代码是调用了第一个参数的成员方法，并且我们把要重写的抽象方法中剩余的所有的参数都按照顺序传入了这个成员方法中，这个时候我们就可以引用类的实例方法。

例如：

interface UseString{
     String use(String str,int start,int length);
}
public static String subAuthorName(String str, UseString useString){
      int start = 0;
      int length = 1;
      return useString.use(str,start,length);
}
public static void main(String[] args) {
     subAuthorName("上了年纪的小男孩", new UseString() {
        @Override
        public String use(String str, int start, int length) {
            return str.substring(start,length);
        }
     });
}

优化后如下：

public static void main(String[] args) {
    subAuthorName("上了年纪的小男孩", String::substring);
}

2.4、构造器引用

如果方法体中的一行代码是构造器的话就可以使用构造器引用。

格式：类名::new

使用前提：如果我们在重写方法的时候，方法体中只有一行代码，并且这行代码是调用了某个类的构造方法，并且我们把要重写的抽象方法中的所有的参数都按照顺序传入了这个构造方法中，这个时候我们就可以引用构造器。

例如：

List<Author> authors = getAuthors();
authors.stream().map(author -> author.getName())
       .map(name->new StringBuilder(name))
       .map(sb->sb.append("-上了年纪的小男孩").toString())
       .forEach(str-> System.out.println(str));

优化后：

List<Author> authors = getAuthors();
authors.stream().map(author -> author.getName())
       .map(StringBuilder::new)
       .map(sb->sb.append("-三更").toString())
       .forEach(str-> System.out.println(str));

3、高级用法

3.1、基本数据类型优化

Stream还提供了很多专门针对基本数据类型的方法。

例如：mapToInt,mapToLong,mapToDouble,flatMapToInt,flatMapToDouble等。

private static void test27() {
    List<Author> authors = getAuthors();
    authors.stream().map(author -> author.getAge())
           .map(age -> age + 10)
           .filter(age->age>18)
           .map(age->age+2)
           .forEach(System.out::println);
    authors.stream().mapToInt(author -> author.getAge())
           .map(age -> age + 10)
           .filter(age->age>18)
           .map(age->age+2)
           .forEach(System.out::println);
}

3.2、并行流

当流中有大量元素时，我们可以使用并行流去提高操作的效率。其实并行流就是把任务分配给多个线程去完全。如果我们自己去用代码实现的话其实会非常的复杂，并且要求你对并发编程有足够的理解和认识。而如果我们使用Stream的话，我们只需要修改一个方法的调用就可以使用并行流来帮我们实现，从而提高效率。

parallel方法可以把串行流转换成并行流。

private static void test28() {
    Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    Integer sum = stream.parallel().peek(new Consumer<Integer>() {
              @Override
              public void accept(Integer num) {
                   System.out.println(num+Thread.currentThread().getName());
              }
    })
              .filter(num -> num > 5)
              .reduce((result, ele) -> result + ele)
              .get();
    System.out.println(sum);
}

也可以通过parallelStream直接获取并行流对象。

List<Author> authors = getAuthors();
authors.parallelStream().map(author -> author.getAge())
       .map(age -> age + 10)
       .filter(age->age>18)
       .map(age->age+2)
       .forEach(System.out::println);