阿里二面:java8的stream api是迭代一次还是迭代多次

简介: 阿里二面:java8的stream api是迭代一次还是迭代多次

面试官:java8新增的stream api用过吗?
:这个必须用过啊。

面试官:给你下面一个字符串数组,如果用stream api来实现,找出以字符'a'开头长度最大的字符串,使用stream api该怎么实现呢?

{"abb","abcd","fegc","efe","adfes"}

:用下面这个方法来实现:

public static void maxLength(List<String> list){
    System.out.println(list.stream().filter(s -> s.startsWith("a")).mapToInt(r -> length(r)).max().orElse(0));;
}

面试官:这个操作是迭代一次还是迭代两次呢?也就是说是先迭代一遍,过滤出以字符'a'开头的字符串数组,然后再迭代一次,找出最大长度,还是一次迭代完成呢?
:这个是迭代一次完成,如果要是迭代多次,stream后面的操作函数很多的情况下效率会非常低。我们加个打印可以来验证结果,代码如下:

public static void main(String[] args) {
    List<String> list = Arrays.asList("abb", "abcd", "fegc", "efe", "adfes");
    int maxLength = list.stream().
          filter(s -> isStartWitha(s)).
    mapToInt(StreamTest1::length).
    max().orElse(0);
    System.out.println("以字符a开头的字符串最大长度:" + maxLength);
}
private static boolean isStartWitha(String a){
    System.out.println(a + " is start with a:" + a.startsWith("a"));
    return a.startsWith("a");
}
private static int length(String a){
    System.out.println("the length of" + a + ":" + a.length());
    return a.length();
}

打印结果如下:

abb is start with a:true
the length of abb:3
abcd is start with a:true
the length of abcd:4
fegc is start with a:false
efe is start with a:false
adfes is start with a:true
the length of adfes:5
以字符a开头的字符串最大长度:5

面试官:你确定只是迭代一次吗?有其他情况吗?
:有。filter是一个无状态的中间操作,对于这个中间操作来说,stream处理只需要迭代一次。但是对于有状态的中间操作,就需要迭代多次。

面试官:你刚刚提到有状态的操作和无状态的操作,这个是怎么区分呢?
:在stream api中,无状态的操作是指当前元素的操作不受前面元素的影响,主要包括如下方法:

filter(),flatMap(),flatMapToInt(),flatMapToLong(),flatMapToDouble(),map(),mapToInt(),mapToDouble(),mapToLong(),peek(),unordered()

而有状态的操作是指需要等所有元素处理完之后才能执行当前操作,主要包括下面方法:

distinct(),limit(),skip(),sorted(),sorted()

面试官:有状态的操作,能举个例子吗?
:比如下面这段代码:

public static void main(String[] args) {
    List<Integer> list = Arrays.asList(5, 2, 3, 1, 4);
    List<Integer> newArray = list.stream()
            .map(StreamTest2::map1)
            .sorted((o1, o2) -> o1 - o2)
            .map(StreamTest2::map2)
            .collect(Collectors.toList());
    System.out.println("新的有序数组:" + newArray);
}
private static Integer map1(Integer i) {
    int result = i * 10;
    System.out.println("线程:" + Thread.currentThread().getName() + " 方法map1入参:" + i + ",输出:" + result);
    return result;
}
private static Integer map2(Integer i) {
    int result = i * 10;
    System.out.println("线程:" + Thread.currentThread().getName() + " 方法map2入参:" + i + ",输出:" + result);
    return result;
}

上面代码中,对原始数组进行了两次迭代,第一次迭代对所有数组元素都调用了map1方法乘以10,然后对新数组进行排序,第二次迭代对排序后的数组元素调用map2方法,即对排序后的数组元素乘以10。方法输出如下:

线程:main 方法map1入参:5,输出:50
线程:main 方法map1入参:2,输出:20
线程:main 方法map1入参:3,输出:30
线程:main 方法map1入参:1,输出:10
线程:main 方法map1入参:4,输出:40
线程:main 方法map2入参:10,输出:100
线程:main 方法map2入参:20,输出:200
线程:main 方法map2入参:30,输出:300
线程:main 方法map2入参:40,输出:400
线程:main 方法map2入参:50,输出:500
新的有序数组:[100, 200, 300, 400, 500]

面试官:了解过底层原理吗?
:我来先画一下Stream的UML类图:

微信图片_20221212211517.png

这个类图说明以下几点:

  • AbstractPipeline有基本类型的子类,如LongPipeline和DoublePipeline,还有一个引用类型的子类ReferencePipeline。
  • 无论是ReferencePipeline,还是LongPipeline和DoublePipeline等基本类型的Pipeline,都有3个内部类来继承自己。
  • StatelessOp对应无状态的操作,StatefulOp对应有状态的操作,Head对应Collection.stream()方法返回结果。
  • 无论是StatelessOp、StatefulOp还是Head,都是一个Pipeline,这些Pipeline用双向链表串联起来,每个Pipeline节点被看作一个Stage,Head是链表的头结点。上面UML类图中AbstractPipeline类中previousStage和nextStage就代表双向链表当前节点指向前后节点的引用。如下图:

微信图片_20221212211541.png

面试官:上面用双向链表把所有操作都串联起来了,这样可以实现从Head节点开始依次执行所有的操作。但是这些操作怎么叠加在一起呢?比如下面这段代码有三个map方法,后面的方法要依赖前面的计算结果:

List<Integer> list = Arrays.asList(5, 2, 3, 1, 4);
List<Integer> newArray = list.stream().map(StreamTest2::map1).map(StreamTest2::map2).map(StreamTest2::map3).collect(Collectors.toList());

:Stream提供了Sink接口来处理操作的叠加。上面代码的map方法把操作封装到了Sink,每个节点执行操作时,调用Sink的accept方法就可以把操作结果传给下一个节点的Sink。比如map方法源代码如下:

public final <R> Stream<R> map(Function<? super P_OUT, ? extends R> mapper) {
    Objects.requireNonNull(mapper);
    return new StatelessOp<P_OUT, R>(this, StreamShape.REFERENCE,
                                 StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
  //返回包装成的Sink
        Sink<P_OUT> opWrapSink(int flags, Sink<R> sink) {
            return new Sink.ChainedReference<P_OUT, R>(sink) {
                @Override
                public void accept(P_OUT u) {
        //downstream是下游节点的Sink,把当前节点的执行结果传给下游节点
                    downstream.accept(mapper.apply(u));
                }
            };
        }
    };
}

面试官:能详细讲一下Sink吗?
:Sink主要提供了下面4个方法

//执行操作之前调用这个方法
void begin(long size)
//执行操作之后调用这个方法
void end()
//是否可以结束操作
boolean cancellationRequested()
//操作执行函数
void accept()

对于有状态的操作,必须实现begin和end两个方法,因为begin方法会创建一个存放中间结果的容器,accept方法将元素放入该容器,end方法负责对容器中元素处理,比如排序。

面试官:那cancellationRequested方法什么时候用呢?
:这个方法用于短路操作,比如stream.findAny。

面试官:你刚刚提到短路操作,怎么区分短路操作和非短路操作呢?
:短路操作和非短路操作都是Stream的结束操作,结束操作是针对中间操作来说的。短路操作是指不用处理全部元素就可以结束,包括下面的方法:

anyMatch(),allMatch(),noneMatch(),findFirst(),findAny()

非短路操作是指需要处理所有元素才能结束,包括下面的方法:

forEach(),forEachOrdered(),toArray(),reduce(),collect(),max(),min(),count()

总结一下Stream操作,如下图:

微信图片_20221212211608.png

在遇到结束操作时,所有Pipeline节点封装的Sink会串成一个链表,如下图:

微信图片_20221212211631.png

把Sink串成链表的过程可以参考下面这段源代码:

final <P_IN> Sink<P_IN> wrapSink(Sink<E_OUT> sink) {
    Objects.requireNonNull(sink);
    for ( @SuppressWarnings("rawtypes") AbstractPipeline p=AbstractPipeline.this; p.depth > 0; p=p.previousStage) {
        sink = p.opWrapSink(p.previousStage.combinedFlags, sink);
    }
    return (Sink<P_IN>) sink;
}

这样从Head节点开始依次调用每个节点封装的Sink中的begin,accept,cancellationRequested,end 四个方法就可以完成Steam流水线的执行。

面试官:上面提到了Sink会串成一个链,那对于有返回结果的操作,返回的结果是保存在什么地方呢?
:这里分三种情况:

  • 如果返回结果是boolean(比如 anyMatch、allMatch、noneMatch)和Optional(比如 findFirst、findAny),返回结果存放在对应的Sink。
  • collect, reduce等规约操作,返回结果存放在用户指定的容器中,比如如下代码返回结果放在Optional容器中:
Optional accResult = Stream.of(1, 2, 3, 4, 5).reduce((sum, item) -> {
    sum += item;
    return sum;
});

max 和 min也是规约操作,因为底层是通过调用 reduce 方法实现的。

  • 对于返回是数组的情况,返回数组之前,数据会存放在一种多叉树数据结构中,这种多叉树结构元素存储在树的叶子当中,一个叶子节点可以存放多个元素。

面试官:上面你提到返回数组的时候用到了多叉树的结构,这样做对于Stream处理有什么好处呢?
:按照官方的说法,这样做是为了避免在并行操作期间不必要地复制数据。

面试官:能简单介绍一下Stream的并行处理吗?
:Stream的并行处理用到了Fork/Join框架,如下图:

微信图片_20221212211657.png

计算过程中,先把任务拆解成子任务,并行计算。计算完成后再把子任务计算结果合并成结果集。

面试官:Fork/Join框架跟普通线程池相比,有什么优势吗?
:fork/join框架的优势是, 如果某个子任务需要等待另外一个子任务完成才能继续工作,那么处理线程会主动寻找其他未完成的子任务进行执行。跟普通线程池相比,减少了等待时间。

面试官:使用Stream并行流,一定会比串行快吗?
:这个不一定,使用的时候要考虑以下几个因素:

  • 要处理的元素数量,数据越多,性能提升越明显。
  • 数据结构的可分割性,数组、ArrayList支持随机读取,可分割性好,HashSet、TreeSet虽然可以分割,但不太容易分割均匀,LinkedList、Streams.iterate、BufferedReader.lines因为长度未知,可分解性差。
  • 尽量使用基本类型,避免装箱拆箱。
  • 单个子任务花费时间越长,带来的性能提升就会越大。

面试官:据说Stream api跟普通迭代相比有性能损耗,你怎么看?
:对于简单的处理操作,Stream api性能确实不如普通迭代。但是如果CPU性能好的话,使用Stream并行处理性能会明细提高。对于复杂处理操作,无论并行还是串行,Stream api有明显的优势。

对于并行处理,要考虑CPU的核数。

面试官:恭喜你,通过了。

目录
打赏
0
0
0
0
114
分享
相关文章
Java爬虫获取微店快递费用item_fee API接口数据实现
本文介绍如何使用Java开发爬虫程序,通过微店API接口获取商品快递费用(item_fee)数据。主要内容包括:微店API接口的使用方法、Java爬虫技术背景、需求分析和技术选型。具体实现步骤为:发送HTTP请求获取数据、解析JSON格式的响应并提取快递费用信息,最后将结果存储到本地文件中。文中还提供了完整的代码示例,并提醒开发者注意授权令牌、接口频率限制及数据合法性等问题。
Java爬虫获取微店店铺所有商品API接口设计与实现
本文介绍如何使用Java设计并实现一个爬虫程序,以获取微店店铺的所有商品信息。通过HttpClient发送HTTP请求,Jsoup解析HTML页面,提取商品名称、价格、图片链接等数据,并将其存储到本地文件或数据库中。文中详细描述了爬虫的设计思路、代码实现及注意事项,包括反爬虫机制、数据合法性和性能优化。此方法可帮助商家了解竞争对手,为消费者提供更全面的商品比较。
java语言后台管理若依框架-登录提示404-接口异常-系统接口404异常如何处理-登录验证码不显示prod-api/captchaImage 404 (Not Found) 如何处理-解决方案优雅草卓伊凡
java语言后台管理若依框架-登录提示404-接口异常-系统接口404异常如何处理-登录验证码不显示prod-api/captchaImage 404 (Not Found) 如何处理-解决方案优雅草卓伊凡
37 5
|
26天前
|
菜鸟之路Day06一一Java常用API
《菜鸟之路Day06——Java常用API》由blue编写,发布于2025年1月24日。本文详细介绍了Java中常用的API,包括JDK7的时间类(Date、SimpleDateFormat、Calendar)和JDK8新增的时间API(ZoneId、Instant、DateTimeFormatter等),以及包装类的使用。通过多个实例练习,如时间计算、字符串转整数、十进制转二进制等,帮助读者巩固所学内容,提升编程技能。文章强调了理论与实践结合的重要性,鼓励读者多做练习以提高学习效率。
77 28
利用 Java 代码获取淘宝关键字 API 接口
在数字化商业时代,精准把握市场动态与消费者需求是企业成功的关键。淘宝作为中国最大的电商平台之一,其海量数据中蕴含丰富的商业洞察。本文介绍如何通过Java代码高效、合规地获取淘宝关键字API接口数据,帮助商家优化产品布局、制定营销策略。主要内容包括: 1. **淘宝关键字API的价值**:洞察用户需求、优化产品标题与详情、制定营销策略。 2. **获取API接口的步骤**:注册账号、申请权限、搭建Java开发环境、编写调用代码、解析响应数据。 3. **注意事项**:遵守法律法规与平台规则,处理API调用限制。 通过这些步骤,商家可以在激烈的市场竞争中脱颖而出。
实战阿里qwen2.5-coder 32B,如何配置Cline的Ollama API接口。
阿里Qwen2.5大模型开源免费,适合编程应用。在Ollama平台下载时,推荐选择带有“cline”字样的Qwen2.5-Coder版本,仅需额外下载适配文件,无需重复下载模型文件。Ollama环境永久免费,配置简单,效果出色,适合开发者使用。
3237 77
Java基础-常用API-Object类
继承是面向对象编程的重要特性,允许从已有类派生新类。Java采用单继承机制,默认所有类继承自Object类。Object类提供了多个常用方法,如`clone()`用于复制对象,`equals()`判断对象是否相等,`hashCode()`计算哈希码,`toString()`返回对象的字符串表示,`wait()`、`notify()`和`notifyAll()`用于线程同步,`finalize()`在对象被垃圾回收时调用。掌握这些方法有助于更好地理解和使用Java中的对象行为。
AgentScope:阿里开源多智能体低代码开发平台,支持一键导出源码、多种模型API和本地模型部署
AgentScope是阿里巴巴集团开源的多智能体开发平台,旨在帮助开发者轻松构建和部署多智能体应用。该平台提供分布式支持,内置多种模型API和本地模型部署选项,支持多模态数据处理。
420 4
AgentScope:阿里开源多智能体低代码开发平台,支持一键导出源码、多种模型API和本地模型部署
Java Stream 使用指南
本文介绍了Java中Stream流的使用方法,包括如何创建Stream流、中间操作(如map、filter、sorted等)和终结操作(如collect、forEach等)。此外,还讲解了并行流的概念及其可能带来的线程安全问题,并给出了示例代码。
138 0
|
2月前
|
如何使用Java开发获得淘宝商品描述API接口?
本文详细介绍如何使用Java开发调用淘宝商品描述API接口,涵盖从注册淘宝开放平台账号、阅读平台规则、创建应用并申请接口权限,到安装开发工具、配置开发环境、获取访问令牌,以及具体的Java代码实现和注意事项。通过遵循这些步骤,开发者可以高效地获取商品详情、描述及图片等信息,为项目和业务增添价值。
121 10

热门文章

最新文章

AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等