并行流 :
stream().parallel()
/*fork时会对源数据进行分割,数据源的特性直接影响了fork的性能。 ArrayList、数组或IntStream.range,可分解性最佳,因为他们都支持随机读取,因此可以被任意分割。 HashSet、TreeSet,可分解性一般,其虽然可被分解,但因为其内部数据结构,很难被平均分解。 LinkedList、Streams.iterate、BufferedReader.lines,可分解性极差,因为他们长度未知,无法确定在哪里进行 分割
————————————————
版权声明:本文为CSDN博主「我是七月呀」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/weixin_44655599/article/details/111636732*/
// 并行流 ArrayList、数组或IntStream.range
/**
* fork时会对源数据进行分割,数据源的特性直接影响了fork的性能
* ArrayList、数组或IntStream.range,可分解性最佳,因为他们都支持随机读取,因此可以被任意分割
* HashSet、TreeSet,可分解性一般,其虽然可被分解,但因为其内部数据结构,很难被平均分解
* LinkedList、Streams.iterate、BufferedReader.lines,可分解性极差,因为他们长度未知,无法确定在哪里进行 分割
*
* 装箱拆箱 尽量使用基本数据类型,避免装箱拆箱。
* CPU核数 fork的产生数量是与可用CPU核数相关,可用的核数越多,获取的性能提升就会越大。
*
* 单元处理开销 花在流中每个元素的时间越长,并行操作带来的性能提升就会越明显。
*
*
*/
stream().parallel().collect(Collections.toList());
1)基本类型
性能消耗: Stream串行>for循环>Stream并行
2)对象
性能消耗:Stream串行>for循环>Stream并行
3)复杂对象
性能消耗:for循环>Stream串行>Stream并行
forEach 循环
// forEach
// forEach是单线程方法,拒绝给
List<String> list = new ArrayList<>();
list.forEach(n -> System.out.println(n));
// 使用Java 8的方法引用更方便,方法引用由::双冒号操作符标示,
list.forEach(System.out::println);
filter 去重
List<String> names = Arrays.asList("小三", "小四", "小五", "原配", "老公公");
// 将集合中开头是“小”的整合成一个list返回;
names.stream().filter(n -> n.startsWith("小")).collect(Collectors.toList());
Bean- filter 去重
Map<String, ResourceBo> map = new ConcurrentHashMap<>();
// 去重
List<ResourceBo> resourceBoList = claimApplicationBo.getResourceList().stream().filter(n -> map.put(n.getResourceTypeCode(),n) == null).collect(Collectors.toList());
filter + Predicate 去重
/**
* String 方法 startsWith 开头 contains 包含 endsWith 结尾
*/
// 开头是包含“小”的
Predicate<String> xiao = (n) -> n.startsWith("小");
// 开头是“小”的,返回
names.stream().filter(xiao).collect(Collectors.toList());
names.stream().filter(xiao).forEach(n -> System.out.println(n));
/**
* Predicate 的方法 : and()并且 or()或者 negate()不是
*
*/
// 开头是“小” and 和 结尾是 “三”
names.stream().filter(xiao.and(n.startsWith("三"))).collect(Collectors.toList());
names.stream().filter(xiao.and(n -> n.endsWith("三"))).forEach(n -> System.out.println(n));
Collectors 转集合
/**
* Collectors.joining(", ")
* Collectors.toList()
* Collectors.toSet() ,生成set集合
*/
// 将字符串换成大写并用逗号链接起来
List<String> list = Arrays.asList("Aa", "Bb", "Cc", "Dd", "Ee", "Ff","Gg");
String Collectors = list.stream().map(x -> x.toUpperCase()).collect(Collectors.joining(": "));
System.out.println(Collectors);
flatMap 连接多个Stream
将多个Stream连接成一个Stream
我认为,他就是把list都串联在一起了
List<Integer> listInt = new ArrayList<>();
listInt.add(1);
listInt.add(2);
List<Integer> listInt3 = new ArrayList<>();
listInt3.add(4);
listInt3.add(5);
List<Integer> result = Stream.of(listInt,listInt3,listInt3).flatMap(
a -> a.stream()).collect(Collectors.toList()
);
for(int ins : result){
System.out.println(ins);
}
// 输出:124545
distinct 去重
name n = new name();
n.setId(1);
name a = new name();
a.setId(2);
name b = new name();
b.setId(1);
List<name> list=new ArrayList<name>();
list.add(n);
list.add(a);
list.add(b);
List<Integer> likeList = list.stream().map(x -> x.getId()).distinct().collect(Collectors.toList());
List<Integer> likeLists = list.stream().map(name :: getId).distinct().collect(Collectors.toList());
for (Integer integer : likeList){
System.out.print(integer);
}
System.out.println("");
for (Integer l : likeLists){
System.out.print(l);
}
count 计数
name n = new name();
n.setId(1);
name a = new name();
a.setId(50);
name b = new name();
b.setId(19);
List<name> list=new ArrayList<name>();
list.add(n);
list.add(a);
list.add(b);
List<Integer> likeList = list.stream().map(x -> x.getId()).distinct().collect(Collectors.toList());
int countOfAdult= (int) list.stream()
.filter(p -> p.getId() > 18)
//.map()
//.collect(Collectors.toList())
.count();
System.out.println(countOfAdult);
allMatch、anyMatch、noneMatch
// allMatch:Stream中全部元素符合传入的predicate返回 true
// anyMatch:Stream中只要有一个元素符合传入的predicate返回 true
// noneMatch:Stream中没有一个元素符合传入的predicate返回 true
List<String> list = new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");
list.add("four");
list.add("five");
Boolean bl = list.stream()
.anyMatch(x->x.length()==3);
System.out.println(bl);
// 输出:true
peek 调试方法
/* 可以使用peek方法,peek方法可只包含一个空的方法体,只要能设置断点即可,
但有些IDE不允许空,可以如下文示例,简单写一个打印逻辑。
注意,调试完后要删掉。*/
sorted 排序
/**
* lambda
* sorted排序
*/
@Test
public void test19() {
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(11);
list.add(111);
list.add(9);
List<Integer> collect = list.stream().sorted().collect(Collectors.toList());
collect.forEach(System.out::println);
System.out.println("********");
List<Integer> reverseOrder = list.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
reverseOrder.forEach(System.out::println);
}
List<User> user = new ArrayList<>();
user.add(new User(1L, 18, "小明"));
user.add(new User(2L, 20, "小王"));
user.add(new User(3L, 28, "小刚"));
//先按照age排序,age相同时按照id排序
List<User> collect3 = user.stream().sorted(Comparator.comparing(User::getAge)
.thenComparing(User::getId))
.collect(Collectors.toList());
collect3.forEach(e -> {
System.out.println(JSON.toJSONString(e));
});
min,max,summaryStatistics 最小值,最大值,合
0.0