JDK8新特性-下部

2024-02-19 22:40
文章标签 特性 jdk8 下部

本文主要是介绍JDK8新特性-下部，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

文章目录

    • 一、Stream结果收集
      • 1.1 结果收集到集合中
      • 1.2 结果集收集到数组中
      • 1.3 对流中数据做聚合运算
      • 1.4 对流中数据做分组操作
      • 1.5 对流中的数据做分区操作
      • 1.6 对流中的数据做拼接
    • 二、并行的Stream流
      • 2.1 串行的Stream流
      • 2.2 并行流
        • 2.2.1获取并行流
        • 2.2.2 并行流操作
      • 2.3 串行流与并行流对比
      • 2.4 线程安全问题

🌕博客x主页：己不由心王道长🌕!
🌎文章说明：JDK8新特性🌎
✅系列专栏：Java基础
🌴本篇内容：对JDK8的新特性进行学习和讲解🌴
☕️每日一语：这个世界本来就不完美，如果我们再不接受不完美的自己，那我们要怎么活。☕️
🚩 交流社区：己不由心王道长(优质编程社区)

一、Stream结果收集

1.1 结果收集到集合中

/*** @Author Administrator* @Date 2023/6/30 15:23* @description Stream结果集收集测试* @Version 1.0*/public class test01 {@Testpublic void test01(){//收集到list集合中List<String> list = Stream.of("王也", "诸葛青", "冯宝宝", "张楚岚").collect(Collectors.toList());System.out.println(list);//收集到set集合中Set<String> collect = Stream.of("王也", "王也", "诸葛青", "冯宝宝", "张楚岚").collect(Collectors.toSet());System.out.println(collect);}
}
[王也, 诸葛青, 冯宝宝, 张楚岚]
[诸葛青, 冯宝宝, 张楚岚, 王也]

这里有一个关于单元测试的常见错误，踩坑一下：
如果在test目录和main目录有同级且方法名相同的方法，执行单元测试的时候执行的是main目录下的方法，但是main目录下的方法并非@Test测试方法，所以会报以下错误：
在这里插入图片描述
解决办法就是改变main目录同名类或者放入不同的层次中。

1.2 结果集收集到数组中

Stream中提供了toArray方法来将结果放到一个数组中，返回值类型是Object[],如果我们要指定返回的类型，那么可以使用另一个重载的toArray(IntFunction f)方法：

/*** @Author Administrator* @Date 2023/6/30 15:54* @description* @Version 1.0*/
public class test02 {@Testpublic void test01(){Object[] objects = Stream.of("王也", "诸葛青", "冯宝宝", "张楚岚").toArray();System.out.println(Arrays.toString(objects));}
}

结果：

[王也, 诸葛青, 冯宝宝, 张楚岚]

1.3 对流中数据做聚合运算

当我们使用Stream流处理数据后，可以像数据库的聚合函数一样对某个字段进行操作，比如获得最大值，最小值，求和，平均值，统计数量。

/*** @Author Administrator* @Date 2023/6/30 15:54* @description* @Version 1.0*/
public class test03 {@Testpublic void test01() {/*** 找出最大年龄*/Optional<Person> MaxAge = Stream.of(new Person("王也", 18),new Person("张楚岚", 13),new Person("冯宝宝", 108),new Person("诸葛青", 15)).collect(Collectors.maxBy((x, y) -> x.getAge() - y.getAge()));System.out.println(MaxAge);/*** 找出最小年龄*/Optional<Person> MinAge = Stream.of(new Person("王也", 18),new Person("张楚岚", 13),new Person("冯宝宝", 108),new Person("诸葛青", 15)).collect(Collectors.minBy((x, y) -> x.getAge() - y.getAge()));System.out.println(MinAge);/***  计算年龄综合*/Integer sumAge = Stream.of(new Person("王也", 18),new Person("张楚岚", 13),new Person("冯宝宝", 108),new Person("诸葛青", 15)).collect(Collectors.summingInt(Person::getAge));System.out.println(sumAge);/*** 计算年龄平均值*/Double ava = Stream.of(new Person("王也", 18),new Person("张楚岚", 13),new Person("冯宝宝", 108),new Person("诸葛青", 15)).collect(Collectors.averagingInt(Person::getAge));System.out.println(ava);}

1.4 对流中数据做分组操作

当我们使用Stream流处理数据后，可以根据某个属性将数据分组：

/*** @Author Administrator* @Date 2023/6/30 15:54* @description* @Version 1.0*/
public class test04 {@Testpublic void test01() {/*** 单级分组*/Map<Integer, List<Person>> collect = Stream.of(new Person("王也", 18),new Person("张楚岚", 13),new Person("冯宝宝", 108),new Person("诸葛青", 15)).collect(Collectors.groupingBy(Person::getAge));collect.forEach((k,v)-> System.out.println(k+"\t"+v));/*** 多级分组，先根据名字分组，随后根据年龄分组*/Map<Integer, Map<String, List<Person>>> collect1 = Stream.of(new Person("王也", 18),new Person("张楚岚", 13),new Person("冯宝宝", 108),new Person("王也", 22),new Person("诸葛青", 13),new Person("诸葛青", 14),new Person("诸葛青", 19)).collect(Collectors.groupingBy(Person::getAge,Collectors.groupingBy(p -> p.getAge() > 18 ? "成年" : "未成年")));collect1.forEach((k,v)->{System.out.println(k);v.forEach((k1,v1)->{System.out.println("\t"+k1+"\t"+v1);});});}
}

结果：

18	[Person{name='王也', age=18, high=null}]
108	[Person{name='冯宝宝', age=108, high=null}]
13	[Person{name='张楚岚', age=13, high=null}]
15	[Person{name='诸葛青', age=15, high=null}]
18未成年	[Person{name='王也', age=18, high=null}]
19成年	[Person{name='诸葛青', age=19, high=null}]
22成年	[Person{name='王也', age=22, high=null}]
108成年	[Person{name='冯宝宝', age=108, high=null}]
13未成年	[Person{name='张楚岚', age=13, high=null}, Person{name='诸葛青', age=13, high=null}]
14未成年	[Person{name='诸葛青', age=14, high=null}]

1.5 对流中的数据做分区操作

Collectors.partitioningBy会根据值是否为true,把集合中的数据分割为两个列表，一个true列表，一个false列表:
在这里插入图片描述

/*** @Author Administrator* @Date 2023/6/30 15:54* @description* @Version 1.0*/
public class test05 {@Testpublic void test01(){Map<Boolean, List<Person>> collect = Stream.of(new Person("王也", 18),new Person("张楚岚", 13),new Person("冯宝宝", 108),new Person("王也", 22),new Person("诸葛青", 13),new Person("诸葛青", 14),new Person("诸葛青", 19)).collect(Collectors.partitioningBy(p -> p.getAge() > 18));collect.forEach((k,v)->{System.out.println(k);System.out.println(v);});}
}

结果：

false
[Person{name='王也', age=18, high=null}, Person{name='张楚岚', age=13, high=null}, Person{name='诸葛青', age=13, high=null}, Person{name='诸葛青', age=14, high=null}]
true
[Person{name='冯宝宝', age=108, high=null}, Person{name='王也', age=22, high=null}, Person{name='诸葛青', age=19, high=null}]

1.6 对流中的数据做拼接

Collectors.joining会根据指定的连接符，将所有的元素连接成一个字符串：

/*** @Author Administrator* @Date 2023/6/30 15:54* @description* @Version 1.0*/
public class test06 {@Testpublic void test01(){String collect = Stream.of(new Person("王也", 18),new Person("张楚岚", 13),new Person("冯宝宝", 108),new Person("王也", 22),new Person("诸葛青", 13),new Person("诸葛青", 14),new Person("诸葛青", 19)).map(Person::getName).collect(Collectors.joining());System.out.println(collect);String collect1 = Stream.of(new Person("王也", 18),new Person("张楚岚", 13),new Person("冯宝宝", 108),new Person("王也", 22),new Person("诸葛青", 13),new Person("诸葛青", 14),new Person("诸葛青", 19)).map(Person::getName).collect(Collectors.joining("_"));System.out.println(collect1);String collect2 = Stream.of(new Person("王也", 18),new Person("张楚岚", 13),new Person("冯宝宝", 108),new Person("王也", 22),new Person("诸葛青", 13),new Person("诸葛青", 14),new Person("诸葛青", 19)).map(Person::getName).collect(Collectors.joining("_","aaa","zzz"));System.out.println(collect2);}

结果：

王也张楚岚冯宝宝王也诸葛青诸葛青诸葛青
王也_张楚岚_冯宝宝_王也_诸葛青_诸葛青_诸葛青
aaa王也_张楚岚_冯宝宝_王也_诸葛青_诸葛青_诸葛青zzz

二、并行的Stream流

2.1 串行的Stream流

我们前面使用的Stream流都是串行，也就是在一个线程上面执行。

/*** @Author Administrator* @Date 2023/6/30 15:23* @description Stream结果集收集测试* @Version 1.0*/public class test07 {@Testpublic void test01(){long count = Stream.of(1, 2, 3, 8, 9, 7, 5, 6, 2, 8, 4, 10).filter(s -> {System.out.println(Thread.currentThread() + "" + s);return s > 3;}).count();System.out.println(count);}
}

输出：

Thread[main,5,main]1
Thread[main,5,main]2
Thread[main,5,main]3
Thread[main,5,main]8
Thread[main,5,main]9
Thread[main,5,main]7
Thread[main,5,main]5
Thread[main,5,main]6
Thread[main,5,main]2
Thread[main,5,main]8
Thread[main,5,main]4
Thread[main,5,main]10

2.2 并行流

parallelStream其实就是一个并行执行的流，它通过默认的ForkJoinPool，可以提高多线程任务的速
度。

2.2.1获取并行流

我们可以通过两种方式来获取并行流。

  1. 通过List接口中的parallelStream方法来获取
  2. 通过已有的串行流转换为并行流(parallel)
    实现：
   /*** 测试获取两种并行流的方法*/@Testpublic void test02(){//方式一、通过List集合获取List<String> list = new ArrayList<>();//获取并行流Stream<String> stream = list.parallelStream();//方式二、通过已有的串行流转换为并行流Stream<Integer> parallel = Stream.of(1, 2, 3, 4).parallel();}
2.2.2 并行流操作
/*** 并行流操作*/@Testpublic void test03(){long count = Stream.of(1, 5, 6, 8, 9, 7, 10).parallel().filter(s -> {System.out.println(Thread.currentThread() + "" + s);return s > 3;}).count();}

效果：

Thread[main,5,main]9
Thread[main,5,main]8
Thread[main,5,main]10
Thread[main,5,main]7
Thread[ForkJoinPool.commonPool-worker-1,5,main]5
Thread[ForkJoinPool.commonPool-worker-1,5,main]6
Thread[ForkJoinPool.commonPool-worker-2,5,main]1

2.3 串行流与并行流对比

我们通过for循环，串行Stream流，并行Stream流来对10亿个数字求和。看看消耗时间对比：

package com.daozhang;import org.junit.After;
import org.junit.Before;
import org.junit.Test;import java.util.stream.LongStream;
import java.util.stream.Stream;/*** @Author Administrator* @Date 2023/6/30 19:05* @description* @Version 1.0*/
public class test08 {private static long times = 1000000000;private long startTimes;private long endTimes;@Beforepublic void before(){startTimes = System.currentTimeMillis();}@Afterpublic void after(){endTimes =System.currentTimeMillis();System.out.println(endTimes-startTimes);}/*** 普通for循环*/@Testpublic void forTest(){long res = 0;for(int i=0;i<times;i++){res+=i;}}//消耗时间:380/*** 串行流*/@Testpublic void test02(){System.out.println("串行流");LongStream.rangeClosed(0,times).reduce(0,Long::sum);}//消耗时间：429/*** 并行流*/@Testpublic void test03(){System.out.println("并行流");LongStream.rangeClosed(0,times).parallel().reduce(0,Long::sum);}//消耗时间:198
}

通过案例我们可以看到parallelStream的效率是最高的。
Stream并行处理的过程会分而治之，也就是将一个大的任务切分成了多个小任务，这表示每个任务都是
一个线程操作。

2.4 线程安全问题

在多线程的处理下，肯定会出现数据安全问题。如下：

package com.daozhang;import org.junit.Test;import java.util.ArrayList;
import java.util.List;/*** @Author Administrator* @Date 2023/6/30 19:18* @description* @Version 1.0*/
public class test09 {@Testpublic void test01(){List<Integer> list = new ArrayList<>();for(int i=0;i<1000;i++){list.add(i);}System.out.println(list.size());List<Integer> listnew = new ArrayList<>();list.parallelStream().forEach(listnew::add);System.out.println(listnew.size());}
}

报错异常：


java.lang.ArrayIndexOutOfBoundsException: 366at java.util.ArrayList.add(ArrayList.java:459)at java.util.stream.ForEachOps$ForEachOp$OfRef.accept(ForEachOps.java:184)at java.util.ArrayList$ArrayListSpliterator.forEachRemaining(ArrayList.java:1374)at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:481)at java.util.stream.ForEachOps$ForEachTask.compute(ForEachOps.java:291)at java.util.concurrent.CountedCompleter.exec(CountedCompleter.java:731)at java.util.concurrent.ForkJoinTask.doExec(ForkJoinTask.java:289)at java.util.concurrent.ForkJoinPool.helpComplete(ForkJoinPool.java:1870)at java.util.concurrent.ForkJoinPool.externalHelpComplete(ForkJoinPool.java:2467)at java.util.concurrent.ForkJoinTask.externalAwaitDone(ForkJoinTask.java:324)at java.util.concurrent.ForkJoinTask.doInvoke(ForkJoinTask.java:405)at java.util.concurrent.ForkJoinTask.invoke(ForkJoinTask.java:734)at java.util.stream.ForEachOps$ForEachOp.evaluateParallel(ForEachOps.java:160)at java.util.stream.ForEachOps$ForEachOp$OfRef.evaluateParallel(ForEachOps.java:174)at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:233)at java.util.stream.ReferencePipeline.forEach(ReferencePipeline.java:418)at java.util.stream.ReferencePipeline$Head.forEach(ReferencePipeline.java:583)at com.daozhang.test09.test01(test09.java:24)at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)at java.lang.reflect.Method.invoke(Method.java:498)at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)at org.junit.runners.ParentRunner.run(ParentRunner.java:363)at org.junit.runner.JUnitCore.run(JUnitCore.java:137)at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:69)at com.intellij.rt.junit.IdeaTestRunner$Repeater$1.execute(IdeaTestRunner.java:38)at com.intellij.rt.execution.junit.TestsRepeater.repeat(TestsRepeater.java:11)at com.intellij.rt.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:35)at com.intellij.rt.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:235)at com.intellij.rt.junit.JUnitStarter.main(JUnitStarter.java:54)

针对这个问题，我们的解决方案有哪些呢？

  1. 加同步锁
  2. 使用线程安全的容器
  3. 通过Stream中的toArray/collect操作
package com.daozhang;import org.junit.Test;import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Vector;
import java.util.stream.Collectors;
import java.util.stream.IntStream;/*** @Author Administrator* @Date 2023/6/30 19:25* @description 解决并行流安全问题* @Version 1.0*/
public class test10 {/*** 加线程同步锁*/@Testpublic void test01(){List<Integer> list = new ArrayList<>();Object obj = new Object();IntStream.rangeClosed(0,1000).parallel().forEach(s->{synchronized (obj){list.add(s);}});System.out.println(list.size());}/*** 使用线程安全的容器*/@Testpublic void test02(){Vector v = new Vector();Object obj = new Object();IntStream.rangeClosed(0,1000).forEach(s->{synchronized (obj){v.add(s);}});System.out.println(v.size());}/*** 将线程不安全的容器转换为线程安全的容器*/@Testpublic void test03(){List<Integer> list = new ArrayList<>();//转换List<Integer> list1 = Collections.synchronizedList(list);IntStream.rangeClosed(0,1000).parallel().forEach(s->{list1.add(s);});System.out.println(list1.size());}
}

这篇关于JDK8新特性-下部的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/726227。

相关文章

ActiveMQ—消息特性（延迟和定时消息投递）

ActiveMQ—消息特性（延迟和定时消息投递）

ActiveMQ消息特性：延迟和定时消息投递（Delay and Schedule Message Delivery） 转自：http://blog.csdn.net/kimmking/article/details/8443872 有时候我们不希望消息马上被broker投递出去，而是想要消息60秒以后发给消费者，或者我们想让消息没隔一定时间投递一次，一共投递指定的次数。。。 类似
阅读更多...
PostgreSQL核心功能特性与使用领域及场景分析

PostgreSQL核心功能特性与使用领域及场景分析

PostgreSQL有什么优点？ 开源和免费 PostgreSQL是一个开源的数据库管理系统，可以免费使用和修改。这降低了企业的成本，并为开发者提供了一个活跃的社区和丰富的资源。 高度兼容 PostgreSQL支持多种操作系统（如Linux、Windows、macOS等）和编程语言（如C、C++、Java、Python、Ruby等），并提供了多种接口（如JDBC、ODBC、ADO.NET等
阅读更多...
JDK8中关于最小堆的实现（PriorityBlockingQueue）

JDK8中关于最小堆的实现（PriorityBlockingQueue）

java.util.concurrent.PriorityBlockingQueue#siftUpComparable 代码很简单，记录一下。 /*** Inserts item x at position k, maintaining heap invariant by* promoting x up the tree until it is greater than or eq
阅读更多...
详解Tomcat 7的七大新特性和新增功能(1)

详解Tomcat 7的七大新特性和新增功能(1)

http://developer.51cto.com/art/201009/228537.htm http://tomcat.apache.org/tomcat-7.0-doc/index.html  Apache发布首个Tomcat 7版本已经发布了有一段时间了，Tomcat 7引入了许多新功能，并对现有功能进行了增强。很多文章列出了Tomcat 7的新功能，但大多数并没有详细解释它们
阅读更多...
如何掌握面向对象编程的四大特性、Lambda 表达式及 I/O 流：全面指南

如何掌握面向对象编程的四大特性、Lambda 表达式及 I/O 流：全面指南

这里写目录标题 OOP语言的四大特性lambda输入/输出流（I/O流） OOP语言的四大特性 面向对象编程（OOP）是一种编程范式，它通过使用“对象”来组织代码。OOP 的四大特性是封装、继承、多态和抽象。这些特性帮助程序员更好地管理复杂的代码，使程序更易于理解和维护。 类-》实体的抽象类型 实体（属性，行为） -》 ADT（abstract data type） 属性-》成
阅读更多...
《C++标准库》读书笔记/第一天（C++新特性（1））

《C++标准库》读书笔记/第一天（C++新特性（1））

C++11新特性（1） 以auto完成类型自动推导 auto i=42; //以auto声明的变量，其类型会根据其初值被自动推倒出来，因此一定需要一个初始化操作； static auto a=0.19;//可以用额外限定符修饰 vector<string> v;  auto pos=v.begin();//如果类型很长或类型表达式复杂 auto很有用； auto l=[] (int
阅读更多...
12C 新特性，MOVE DATAFILE 在线移动 包括system， 附带改名 NID ，cdb_data_files视图坏了

12C 新特性，MOVE DATAFILE 在线移动 包括system， 附带改名 NID ，cdb_data_files视图坏了

ALTER DATABASE MOVE DATAFILE  可以改名 可以move file，全部一个命令。 resue 可以重用，keep好像不生效！！！ system照移动不误-------- SQL> select file_name, status, online_status from dba_data_files where tablespace_name='SYSTEM'
阅读更多...
Cmake之3.0版本重要特性及用法实例(十三)

Cmake之3.0版本重要特性及用法实例(十三)

简介： CSDN博客专家、《Android系统多媒体进阶实战》一书作者 新书发布：《Android系统多媒体进阶实战》🚀 优质专栏： Audio工程师进阶系列【原创干货持续更新中……】🚀 优质专栏： 多媒体系统工程师系列【原创干货持续更新中……】🚀 优质视频课程：AAOS车载系统+AOSP14系统攻城狮入门视频实战课 🚀 人生格言： 人生从来没有捷径，只有行动才是治疗恐惧
阅读更多...
Java8特性：分组、提取字段、去重、过滤、差集、交集

Java8特性：分组、提取字段、去重、过滤、差集、交集

总结下自己使用过的特性 将对象集合根据某个字段分组 //根据id分组Map<String, List<Bean>> newMap = successCf.stream().collect(Collectors.groupingBy(b -> b.getId().trim())); 获取对象集合里面的某个字段的集合 List<Bean> list = new ArrayList<>
阅读更多...
【JVM】JVM栈帧中的动态链接 与 Java的面向对象特性--多态

【JVM】JVM栈帧中的动态链接 与 Java的面向对象特性--多态

栈帧 每一次方法调用都会有一个对应的栈帧被压入栈（虚拟机栈）中，每一个方法调用结束后，都会有一个栈帧被弹出。 每个栈帧中包括：局部变量表、操作数栈、动态链接、方法返回地址。 JavaGuide：Java内存区域详解（重点） 动态链接 动态链接：指向运行时常量池中该栈帧所属方法的引用。 多态 多态允许不同类的对象对同一消息做出响应，但表现出不同的行为（即方法的多样性）。 多态
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2