【Stream流、方法引用】

最新推荐文章于 2024-07-17 15:01:56 发布

五岁能抬头1995

最新推荐文章于 2024-07-17 15:01:56 发布

阅读量160

点赞数

分类专栏： javase 文章标签： stream java

本文链接：https://blog.csdn.net/weixin_46932548/article/details/106401650

版权

javase 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

【Stream流、方法引用】

Stream流

循环遍历的弊端

几乎所有的集合（如Collectins接口或者Map接口等）都直接支持或间接支持遍历操作。而我们需要对集合中的元素进行操作的时候，除了必需的添加、删除、获取外，最典型的就是集合遍历。

Java 8的Lambda让我们可以更加专注于做什么（What），而不是怎么做（How），这点此前已经结合内部类进行了说明和对比。我们仔细体会会发现：

for循环的语法就是"怎么做"；
for循环的循环体才是"做什么"

为什么使用循环？因为要进行遍历。但是循环时遍历的唯一方式？遍历是指对每一个元素逐一进行处理，**而并不是从第一个到最后一个顺次处理的循环。**前者是目的，后者是方式。

如果希望对集合中的元素进行过滤：

将集合A根据条件一过滤为子集B；
再根据条件二过滤为子集C；

在Java 8之前，做法可能为：

import java.util.ArrayList;
import java.util.List;

public class Demo01NormalFilter {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");

        List<String> listB = new ArrayList<>();
        for (String s : list) {
            if (s.startsWith("张")) {
                listB.add(s);
            }
        }

        List<String> listC = new ArrayList<>();
        for (String s : listB) {
            if (s.length() == 3) {
                listC.add(s);
            }
        }

        for (String s : listC) {
            System.out.println(s);
        }
    }
}

每当我们需要对集合中的元素进行操作的时候，总是需要进行循环、循环、再循环。这是理所当然的么？**不是。**循环时做事情的方式，不是目的。使用线性循环就意味着只能遍历一次。如果希望再次遍历，只能再使用另一个循环从头开始。

Stream的更优写法

借助Java 8的Stream API，可以使代码更加优雅：

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class Demo01StreamFilter {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");

        Stream<String> stream = list.stream();

        stream.filter(name -> name.startsWith("张") && name.length() == 3).forEach(name -> System.out.println(name));

    }
}

流式思想

注意：请暂时忘记对传统IO流的固有印象!

整体来看，流式思想类似于工厂车间的“生产流水线”。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QL7yvb5R-1590637958003)(C:\Users\hp\Desktop\javaLearning\笔记\picture\流式思想.png)]

当需要对多个元素进行操作(特别是多步操作)的时候，考虑到性能及便利性，我们应该首先拼好一个“模型”步骤方案，然后再按照方案去执行它。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s75PsBCN-1590637958005)(C:\Users\hp\Desktop\javaLearning\笔记\picture\流式模型.png)]

这张图中展示了过滤、映射、跳过、计数等多步操作，这是一种集合元素的处理方案，而方案就是一种“函数模型”。图中的每一个方框都是一个“流”，调用指定的方法，可以从一个流模型转换为另一个流模型。而最右侧的数字 3是最终结果。

这里的filter、map、skip都是在对函数模型进行操作，集合元素并没有真正被处理。只有当终结方法count执行的时候，整个模型才会按照指定策略执行操作。而这得益于Lambda的延迟执行特性。

注意：“Stream流”其实是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素(或其地址值)。

Stream(流)是一个来自数据源的元素队列。

元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
数据源：流的来源。可以是集合，数组等。

和以前的Collection操作不同， Stream操作还有两个基础的特征：

Pipelining：中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道，如同流式风格(fluent style)。这样做可以对操作进行优化，比如延迟执行(laziness)和短路( short-circuiting)。
内部迭代：以前对集合遍历都是通过Iterator或者增强for的方式，显式的在集合外部进行迭代，这叫做外部迭代。 Stream提供了内部迭代的方式，流可以直接调用遍历方法。

当使用一个流的时候，通常包括三个基本步骤:获取一个数据源(source)→ 数据转换→执行操作获取想要的结果，每次转换原有Stream 对象不改变，返回一个新的 Stream 对象(可以有多次转换)，这就允许对其操作可以像链条一样排列，变成一个管道。

获取流

java.util.stream.Stream<T>是Java 8新加入的最常用的流接口。(这并不是一个函数式接口。)

根据Collection获取流

java.util.Collection接口中加入了default方法stream用来获取流，所以其所有实现类均可获取流。

import java.util.*;
import java.util.stream.Stream;

public class Demo01StreamObtain {
    public static void main(String[] args) {
        //获取List集合的流
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();

        //获取Set集合的流
        Set<String> set = new HashSet<>();
        Stream<String> stream2 = set.stream();

        //获取Map集合的键的流
        Map<String,Integer> map = new HashMap<>();
        Set<String> keySet = map.keySet();
        Stream<String> stream3 = keySet.stream();

        //获取Map集合的值的流
        Collection<Integer> valuesColl = map.values();
        Stream<Integer> stream4 = valuesColl.stream();

        //获取Map集合的键值对的流
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        Stream<Map.Entry<String, Integer>> stream5 = entrySet.stream();
        
    }
}

根据数组获取流

Stream接口的静态方法of可以获取数组对应的流。

import java.util.stream.Stream;

public class Demo01StreamObtain {
    public static void main(String[] args) {
        //根据数组获取流1
        String[] arrString = {"1", "2", "3"};
        Stream<String> stream1 = Stream.of(arrString);

        //根据数组获取流2
        Stream<Integer> stream2 = Stream.of(1, 2, 3);


    }
}

常用方法

**终结方法：**返回值不是steam接口自身类型的方法，不再支持链式调用，终结方法包括count和foreach方法等。

**延迟方法：**除终结方法之外，都是延迟方法。

统一处理：`forEach`

void forEach(Consumer<? super T> action);

该方法接收一个Consumer接口函数，会将每一个流元素交给该函数进行处理。

Consumer接口是一个消费型的函数式接口,可以传递Lambda表达式，消费数据。

import java.util.ArrayList;
import java.util.Collections;
import java.util.stream.Stream;

public class Demo01StreamforEach {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张三丰","黄子韬","杰克逊");
        //获取Stream流
        Stream<String> stream = list.stream();
        //使用forEach方法
        stream.forEach(name -> System.out.println(name));
    }
}

过滤：`filter`

Stream<T> filter(Predicate<? super T> predicate);

filter方法的参数Predicate是一个函数式接口，所以可以传递Lambda表达式，对数据进行过滤。

Predicate中的抽象方法: boolean test(T t);

import java.util.ArrayList;
import java.util.Collections;
import java.util.stream.Stream;

public class Demo01StreamforEach {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张三丰","黄子韬","杰克逊");
        //获取Stream流
        Stream<String> stream = list.stream();
        //使用filter方法，过滤出姓”张“的姓名,获取一个新的流
        Stream<String> stream1 = stream.filter(name -> name.startsWith("张"));
    }
}

映射：`map`

如果需要将流中的元素映射到另一个流中，可以使用map方法。

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流。

Function中的抽象方法：R apply(T t);

import java.util.ArrayList;
import java.util.Collections;
import java.util.stream.Stream;

public class Demo01StreamforEach {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张三丰","黄子韬","杰克逊");
        //获取Stream流
        Stream<String> stream = list.stream();
        //使用map方法，将集合元素反转，返回一个新的流
        Stream<String> stream2 = stream.map(name -> new StringBuffer(name).reverse()).map(name -> name.toString());
    }
}

统计个数：`count`

long count();

count方法是一个终结方法，返回值是一个long类型的整数,，所以不能再继续调用Stream流中的其他方法了

import java.util.ArrayList;
import java.util.Collections;
import java.util.stream.Stream;

public class Demo01StreamforEach {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张三丰","黄子韬","杰克逊","科比");
        //获取Stream流
        Stream<String> stream = list.stream();
        //使用count方法，统计姓名3个字的名字个数,返回long类型的整数
        long count = stream.filter(name -> name.length() == 3).count();
        System.out.println(count);
    }
}

取用前几个：`limit`

limit方法可以对流进行截取，只取用前n个。

Stream<T> limit(long maxSize);

参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作

limit方法是一个延迟方法,只是对流中的元素进行截取,返回的是一个新的流,所以可以继续调用Stream流中的其他方法

import java.util.ArrayList;
import java.util.Collections;
import java.util.stream.Stream;

public class Demo01StreamforEach {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张三丰","黄子韬","杰克逊","科比");
        //获取Stream流
        Stream<String> stream = list.stream();
        //使用limit方法，获得前三个名字的集合的流
        Stream<String> stream3 = stream.limit(3);
    }
}

跳过前几个：`skip`

如果希望跳过前几个元素，可以使用skip方法获取一个截取之后的新流：

Stream<T> skip(long n);

如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。

import java.util.ArrayList;
import java.util.Collections;
import java.util.stream.Stream;

public class Demo01StreamforEach {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张三丰","黄子韬","杰克逊","科比");
        //获取Stream流
        Stream<String> stream = list.stream();
        //使用skip方法，跳过第一个名字，获得新流
        Stream<String> stream4 = stream.skip(1);
    }
}

组合：`concat`

如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat：

static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)

备注：这是一个静态方法，与java.lang.String当中的concat方法是不同的。

import java.util.ArrayList;
import java.util.Collections;
import java.util.stream.Stream;

public class Demo01StreamforEach {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();
        Collections.addAll(list1,"张三丰","黄子韬","杰克逊","科比");
        Collections.addAll(list2,"张无忌","谢霆锋","约翰逊","三毛");
        //获取Stream流
        Stream<String> stream5 = list1.stream();
        Stream<String> stream6 = list2.stream();

        //使用concat方法，拼接两个流，获得新流
        Stream<String> stream7 = Stream.concat(stream5,stream6);
    }
}

练习：集合元素处理(Stream方式)

现在有两个ArrayList集合存储队伍当中的多个成员姓名，要求使用传统的for循环（或增强for循环）依次进行以下若干操作步骤：

第一个队伍只要名字为3个字的成员姓名；存储到一个新集合中。
第一个队伍筛选之后只要前3个人；存储到一个新集合中。
第二个队伍只要姓张的成员姓名；存储到一个新集合中。
第二个队伍筛选之后不要前2个人；存储到一个新集合中。
将两个队伍合并为一个队伍；存储到一个新集合中。
根据姓名创建Person对象；存储到一个新集合中。
打印整个队伍的Person对象信息。

import java.util.ArrayList;
import java.util.stream.Stream;

public class Demo01Stream {
    public static void main(String[] args) {
        ArrayList<String> one = new ArrayList<>();
        one.add("迪丽热巴");
        one.add("宋远桥");
        one.add("苏星河");
        one.add("石破天");
        one.add("石中玉");
        one.add("老子");
        one.add("庄子");
        one.add("洪七公");

        ArrayList<String> two = new ArrayList<>();
        two.add("古力娜扎");
        two.add("张无忌");
        two.add("赵丽颖");
        two.add("张三丰");
        two.add("尼古拉斯赵四");
        two.add("张天爱");
        two.add("张二狗");

        //1. 第一个队伍只要名字为3个字的成员姓名；存储到一个新集合中。
        //2. 第一个队伍筛选之后只要前3个人；存储到一个新集合中。
        Stream<String> oneStream = one.stream().filter(name -> name.length() == 3).limit(3);
        //3. 第二个队伍只要姓张的成员姓名；存储到一个新集合中。
        //4. 第二个队伍筛选之后不要前2个人；存储到一个新集合中。
        Stream<String> twoStream = two.stream().filter(name -> name.startsWith("张")).skip(2);
        //5.将两个队伍合并为一个队伍；存储到一个新集合中。
        Stream<String> stream = Stream.concat(oneStream, twoStream);
        //6.根据姓名创建Person对象；存储到一个新集合中。
        ArrayList<Person> persons = new ArrayList<>();
        stream.forEach((name)->{
            Person person = new Person(name);
            persons.add(person);
        });
        //7.打印整个队伍的Person对象信息。
        persons.stream().forEach(person -> System.out.println(person));


    }
}

方法引用【了解】

在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿什么参数做什么操作，那么考虑一种情况，如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑？

冗余的Lambda场景

对于一个函数式接口：

@FunctionalInterface
public interface Printable {
    void print(String str);
}

在Printable接口当中唯一的抽象方法print接收一个字符串参数，目的是为了打印显示它。那么通过Lamnda来使用它的代码很简单：

public class Demo01PrintSimple {
    private static void printString(Printable data){
        data.print("HelloWorld");
    }

    public static void main(String[] args) {
        printString(s-> System.out.println(s));
    }
}

用方法引用改进代码

Lambda表达式的目的，是为了打印参数传递的字符串。

把参数s，传递给System.out对象，调用out对象中的方法println对字符串进行了输出。

注意：

1. `System.out`对象是已经存在的;
2. `println`方法也是已经存在的。

所以我们可以使用方法引用来优化Lambda表达式，可以使用System.out对象直接引用(调用)println方法。

public class Demo01PrintSimple {
    private static void printString(Printable data){
        data.print("HelloWorld");
    }

    public static void main(String[] args) {
        printString(System.out::println);
    }
}

方法引用符

双冒号::为引用运算符，而他所在的表达式成为方法引用。如果Lambda要表达的函数方案已经存在于某个方法的实现中，那么则可以通过双冒号来引用该方法作为Lambda的替代者。

语义分析

例如上例中，System.out对象中有一个重载的println(String)方法恰好就是我们需要的。那么对于printString方法的函数式接口参数，对于下面两种写法，完全等效：

Lambda表达式写法：s -> System.out.println(s);
方法引用写法：System.out::println

第一种语义是指：拿到参数之后经Lambda之后，继而传递给System.out.println方法去处理。

第二种等效写法的语义是指：直接让System.out中的println方法来取代Lambda。

第二种方法引用的写法复用了已有方案，更加简洁。

注：Lambda中传递的参数一定是方法引用中的那个方法可以接受的类型，否则会抛出异常。

推导和省略

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

函数式接口是Lambda的基础，而方法引用是Lambda的孪生兄弟。

常用的方法引用

对象名::成员方法

如果一个类中已经存在一个成员方法：

public class MethodRefObject {
    public void printUpperCase(String str) {
        System.out.println(str.toUpperCase());

    }
}

函数式接口仍然定义为：

@FunctionalInterface
public interface Printable {
    void print(String str);
}

使用Lambda表达式与方法引用的对比：

public class Demo02ObjectMethodReference {
    private static void printString(Printable printable){
        printable.print("HelloWorld");
    }

    public static void main(String[] args) {
        //创建对象
        MethodRefObject obj = new MethodRefObject();
        //使用Lambda表达式，规定如何打印
        printString(s->obj.printUpperCase(s));
        //使用方法引用简化
        printString(obj::printUpperCase);
    }
}

类名::静态成员方法

import java.util.function.Function;

public class Demo02StaticMethodReference {
    private static int method(Function<Integer,Integer> func,int num){
        return func.apply(num);
    }
    public static void main(String[] args) {
        //使用Lambda表达式
        int num1 = method((n) -> Math.abs(n), -10);
        System.out.println(num1);
        //使用方法引用
        int num2 = method(Math::abs,-20);
        System.out.println(num2);
    }
}

super::父类成员方法

public class Father {
    public void methodF(String str){
        System.out.println(str);
    }
}

import java.util.function.Consumer;

public class Son extends Father{
    private  void methodZ(Consumer<String> con){
        con.accept("你好");
    }
    public void show(){
        //使用Lambda表达式
        methodZ((s)->super.methodF(s));
        //使用方法引用
        methodZ(super::methodF);
    }

    public static void main(String[] args) {
        new Son().show();
    }

}

this::本类成员方法

import java.util.function.Consumer;

public class Son {
    private  void methodZ(Consumer<String> con){
        con.accept("Hello");
    }
    public void printUpperCase(String str){
        System.out.println(str.toUpperCase());
    }
    public void show(){
        //使用Lambda表达式
        methodZ((s)-> this.printUpperCase(s));
        //使用方法引用
        methodZ(this::printUpperCase);
    }

    public static void main(String[] args) {
        new Son().show();
    }

}

类名称::new

新建一个Person类：

public class Person {
    private String name;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Person(String name) {
        this.name = name;
    }
}

然后创建一个用来创建Person对象的函数式接口：

@FunctionalInterface
public interface PersonBuilder {
    Person personBuilder(String name);
}

创建测试类，静态成员方法传递函数式接口为参数：

public class Demo {
    public static void printName(String name,PersonBuilder personBuilder){
        Person person = personBuilder.personBuilder(name);
        System.out.println(person.getName());
    }

    public static void main(String[] args) {
        //使用匿名内部类
        printName("迪丽热巴", new PersonBuilder() {
            @Override
            public Person personBuilder(String name) {
                return new Person(name);
            }
        });
        //使用Lambda表达式
        printName("古力娜扎",name -> new Person(name));
        //使用方法引用
        printName("马尔扎哈",Person::new);
    }
}

数组类名称::new

创建一个用来创建指定长度的int数组的接口：

@FunctionalInterface
public interface ArrayBuilder {
    //创建int类型数组的方法,参数传递数组的长度，返回创建好的数组
    int[] intArrayBuilder(int length);
}

创建测试类，静态成员方法传递函数式接口为参数：

public class Demo {
    private static int[] method(int length,ArrayBuilder arrayBuilder){
        return arrayBuilder.intArrayBuilder(length);

    }

    public static void main(String[] args) {
        //匿名内部类
        int[] ints1 = method(3, new ArrayBuilder() {
            @Override
            public int[] intArrayBuilder(int length) {
                return new int[length];
            }
        });
        //Lambda表达式
        int[] ints2 = method(4, length -> new int[length]);
        //方法引用
        int[] ints3 = method(4, int[]::new);

    }
}

terface ArrayBuilder {
//创建int类型数组的方法,参数传递数组的长度，返回创建好的数组
int[] intArrayBuilder(int length);
}


创建测试类，静态成员方法传递函数式接口为参数：

```java
public class Demo {
    private static int[] method(int length,ArrayBuilder arrayBuilder){
        return arrayBuilder.intArrayBuilder(length);

    }

    public static void main(String[] args) {
        //匿名内部类
        int[] ints1 = method(3, new ArrayBuilder() {
            @Override
            public int[] intArrayBuilder(int length) {
                return new int[length];
            }
        });
        //Lambda表达式
        int[] ints2 = method(4, length -> new int[length]);
        //方法引用
        int[] ints3 = method(4, int[]::new);

    }
}