玩转 Java8 Stream

真格量化——GFTD策略 #!/usr/bin/env python # coding:utf-8 from PoboAPI import * import datetime import numpy as np import math #开始时间,用于初始化一些参数 def OnStart(context) : print "I\'m starting..." #设置全局变量 g.signalcount = 0 g.signal_list = [] g.buysignal = 0 . 阅读详情

 

转载自https://www.jianshu.com/p/e681dc3895d9

 

前言

  • 一、Stream 特性
  • 二、Stream 创建
  • 2.1 用集合创建流
  • 2.2 用数组创建流
  • 2.3 Stream静态方法
  • 三、Stream 使用案例
  • 3.1 遍历 forEach
  • 3.2 过滤 filter
  • 3.3 查找 findFirst,findAny
  • 3.4 匹配 match
  • 3.5 映射 map
  • 3.6 截取流 limit
  • 3.7 排序 sorted
  • 3.8 去重 distinct
  • 3.9 统计 summaryStatistics
  • 3.10 归约 reduce
  • 3.11 归集 toList,toSet,toMap
  • 3.12 分组 partitioningBy,groupingBy
  • 3.13 合并 joining
  • 四、演示代码获取

前言

Java 8 (又称为 jdk 1.8) 是 Java 语言开发的一个主要版本。 Oracle 公司于 2014 年 3 月 18 日发布 Java 8 ,它支持函数式编程,新的 JavaScript 引擎,新的日期 API,新的Stream API 等。
新添加的Stream API(java.util.stream) 把真正的函数式编程风格引入到Java中。它可以让你以一种声明的方式处理数据,从而写出高效率、干净、简洁的代码。
这种风格将要处理的元素集合看作一种流, 流在管道中传输, 并且可以在管道的节点上进行处理, 比如筛选, 排序,聚合等。

一、Stream 特性

元素是特定类型的对象,形成一个队列。 Java中的Stream不会存储元素,而是按需计算按照特定的规则对数据进行计算,一般会输出结果。
Stream不会改变数据源,一般情况下会产生一个新的集合或者新值。
Stream流的来源,可以是集合,数组,I/O channel, 产生器generator 等等。
Stream具有延迟执行特性,只有调用终端操作时,中间操作才会执行。中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道, 如同流式风格(fluent style)。
以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代, 这叫做外部迭代。 Stream提供了内部迭代的方式, 通过访问者模式(Visitor)实现。

Stream流的操作可以大概分为2种:

1.中间操作:每次操作都返回流对象本身。
2.终端操作:一个流只可以进行一次终端操作,即产生一个新的集合或者新值。终端操作结束后流无法再次使用。

二、Stream 创建

在 Java 8 中, Stream可以由集合或数组创建而来,生成的流有2种类型:
stream() :串行流,由主线程按顺序对流执行操作。parallelStream():并行流,内部以多线程并行执行的方式对流进行操作,但前提是流中的数据处理没有顺序要求。例如计算集合中的数量之和。如果流种数据量很大,并行流可以加快处理速度。串行流可以通过parallel()方法把顺序流转换成并行流。

2.1 用集合创建流

因为集合继承或实现了java.util.Collection接口,而Collection接口定义了stream()和parallelStream()方法,所以可通过集合的stream() 和parallelStream()方法创建流。

// 创建集合

List<String> list = Arrays.asList("张三", "李四", "王五");// 创建一个串行流

Stream<String> stream = list.stream();// 创建一个并行流

Stream<String> parallelStream = list.parallelStream();123456

2.2 用数组创建流

使用java.util.Arrays.stream(T[] array)方法用数组创建流。

// 创建数组

String[] persons = {"张三", "李四", "王五"};// 创建一个串行流

Stream<String> stream = Arrays.stream(persons);// 创建一个并行流

Stream<String> parallelStream = Arrays.stream(persons).parallel();123456

2.3 Stream静态方法

使用Stream的静态方法生成Stream,例如of()、iterate()、generate()等。

Stream<String> stream2 = Stream.of("张三", "李四", "王五");

// 输出5个奇数 1 3 5 7 9

Stream<Integer> stream3 = Stream.iterate(1, x -> x + 2).limit(5);

stream3.forEach(System.out::println);

// 生成2个UUID

Stream<UUID> stream4 = Stream.generate(UUID::randomUUID).limit(2);

stream4.forEach(System.out::println);123456789

三、Stream 使用案例

以下所有案例会基于学生数据,学生类,以及测试数据如下:

package com.nobody;

/**

 * @Description 学生类

 * @Author Mr.nobody

 * @Date 2021/1/17

 * @Version 1.0

 */public class Student {

    // 主键

    private String id;

    // 姓名

    private String name;

    // 年龄

    private int age;

    // 性别

    private String sex;

    // 成绩

    private double score;

 

    public Student(String id, String name, int age, String sex, double score) {

        this.id = id;

        this.name = name;

        this.age = age;

        this.sex = sex;

        this.score = score;

    }

    // 省略get和set方法,toString方法,如若测试需自行添加12345678910111213141516171819202122232425262728

List<Student> students = new ArrayList<>(16);

students.add(new Student("1", "张三", 18, "male", 88));

students.add(new Student("2", "李四", 17, "male", 60));

students.add(new Student("3", "王五", 18, "male", 100));

students.add(new Student("4", "赵六", 20, "male", 10));

students.add(new Student("5", "董七", 14, "female", 95));

students.add(new Student("6", "幺八", 21, "male", 55));

students.add(new Student("7", "老九", 20, "female", 66));

students.add(new Student("8", "小明", 18, "male", 100));

students.add(new Student("9", "小红", 22, "female", 95));

students.add(new Student("10", "小张", 25, "male", 90));1234567891011

3.1 遍历 forEach

students.stream().forEach(System.out::println);

// 输出结果

Student{id='1', name='张三', age=18, sex=male, score=88.0}

Student{id='2', name='李四', age=17, sex=male, score=60.0}

Student{id='3', name='王五', age=18, sex=male, score=100.0}

Student{id='4', name='赵六', age=20, sex=male, score=10.0}

Student{id='5', name='董七', age=14, sex=female, score=95.0}

Student{id='6', name='幺八', age=21, sex=male, score=55.0}

Student{id='7', name='老九', age=20, sex=female, score=66.0}

Student{id='8', name='小明', age=18, sex=male, score=100.0}

Student{id='9', name='小红', age=22, sex=female, score=95.0}

Student{id='10', name='小张', age=25, sex=male, score=90.0}12345678910111213

3.2 过滤 filter

// 过滤出成绩100分的学生List<Student> students1 =

        students.stream().filter(student -> student.getScore() == 100).collect(Collectors.toList());

students1.forEach(System.out::println);

// 输出结果

Student{id='3', name='王五', age=18, sex=male, score=100.0}

Student{id='8', name='小明', age=18, sex=male, score=100.0}12345678

3.3 查找 findFirst,findAny

一般filter和find搭配使用,即从过滤符合条件的数据中,获得一个数据。

// 串行流,匹配第一个

Optional<Student> studentOptional =

        students.stream().filter(student -> student.getAge() >= 20).findFirst();if (studentOptional.isPresent()) {

    Student student = studentOptional.get();

    System.out.println(student);}// 上面输出语句可简写如下// studentOptional.ifPresent(System.out::println);

// 并行流,匹配任意一个,findAny一般用于并行流

Optional<Student> studentOptiona2 =

        students.parallelStream().filter(student -> student.getAge() >= 20).findAny();

studentOptiona2.ifPresent(System.out::println);

// 输出结果

Student{id='4', name='赵六', age=20, sex=male, score=10.0}

Student{id='7', name='老九', age=20, sex=female, score=66.0}123456789101112131415161718

3.4 匹配 match

// 是否存在100分的学生

boolean anyMatch = students.stream().anyMatch(student -> student.getScore() == 100);// 是否全部学生都100分

boolean allMatch = students.stream().allMatch(student -> student.getScore() == 100);// 是否全部学生都没有100分

boolean noneMatch = students.stream().noneMatch(student -> student.getScore() == 100);

System.out.println(anyMatch);

System.out.println(allMatch);

System.out.println(noneMatch);

// 输出结果truefalsefalse1234567891011121314

3.5 映射 map

映射,顾名思义,将一个对象映射成另外一个对象。即一个Stream流中的所有元素按照一定的映射规则,映射到另一个流中。映射有map和flatMap两种类型:
map:接收一个函数作为参数,此函数作用到Stream中每一个元素,形成一个新的元素,所有新的元素组成一个新的流。
flatMap:接收一个函数作为参数,它将流中的每个元素都转换成另一个流,然后把所有流再连接形成一个最终流。

// 获取每个学生的姓名

List<String> studentNames =

        students.stream().map(Student::getName).collect(Collectors.toList());

System.out.println(studentNames);// 每个学生的成绩加10分

List<Double> studentScores = students.stream().map(student -> student.getScore() + 10)

        .collect(Collectors.toList());

System.out.println(studentScores);

// 输出结果[张三, 李四, 王五, 赵六, 董七, 幺八, 老九, 小明, 小红, 小张][98.0, 70.0, 110.0, 20.0, 105.0, 65.0, 76.0, 110.0, 105.0, 100.0]123456789101112

List<String> list = Arrays.asList("a-b-c-d", "g-h-i");

List<String> list1 = list.stream().flatMap(s -> Arrays.stream(s.split("-"))).collect(Collectors.toList());

System.out.println(list1);

// 输出结果[a, b, c, d, g, h, i]123456

3.6 截取流 limit

// limit方法用于获取指定数量的流。例如下面演示取出学习成绩大于70的5个人List<Student> students2 = students.stream().filter(student -> student.getScore() > 70)

        .limit(5).collect(Collectors.toList());

students2.forEach(System.out::println);// 跳过第一个再取2个List<Student> students8 = students.stream().skip(1).limit(2).collect(Collectors.toList());// 获取5个int随机数,按从小到大排序

Random random = new Random();

random.ints().limit(5).sorted().forEach(System.out::println);

// 输出结果

Student{id='1', name='张三', age=18, sex=male, score=88.0}

Student{id='3', name='王五', age=18, sex=male, score=100.0}

Student{id='5', name='董七', age=14, sex=female, score=95.0}

Student{id='8', name='小明', age=18, sex=male, score=100.0}

Student{id='9', name='小红', age=22, sex=female, score=95.0}-14902027141453405473683321553883993981099579920123456789101112131415161718192021

3.7 排序 sorted

sorted 方法用于对流中的元素进行排序,有两种排序:
sorted():自然排序,流中元素需要实现Comparable接口。
sorted(Comparator<? super T> comparator):需要自定义排序器。

// 按成绩升序List<Student> students3 = students.stream().sorted(Comparator.comparing(Student::getScore))

        .collect(Collectors.toList());

System.out.println("按成绩升序");

students3.forEach(System.out::println);// 按成绩降序List<Student> students4 =

        students.stream().sorted(Comparator.comparing(Student::getScore).reversed())

                .collect(Collectors.toList());

System.out.println("按成绩降序");

students4.forEach(System.out::println);// 按成绩升序,再按年龄升序List<Student> students5 = students.stream()

        .sorted(Comparator.comparing(Student::getScore).thenComparing(Student::getAge))

        .collect(Collectors.toList());

System.out.println("按成绩升序,再按年龄升序");

students5.forEach(System.out::println);// 按成绩升序,再按年龄降序List<Student> students6 = students.stream().sorted((s1, s2) -> {

    if (s1.getScore() != s2.getScore()) {

        return (int) (s1.getScore() - s2.getScore());

    } else {

        return (s2.getAge() - s1.getAge());

    }}).collect(Collectors.toList());

System.out.println("按成绩升序,再按年龄降序");

students6.forEach(System.out::println);123456789101112131415161718192021222324252627

3.8 去重 distinct

List<String> list2 = Arrays.asList("a", "b", "a", "c", "f", "e", "f");

List<String> list3 = list2.stream().distinct().collect(Collectors.toList());

Set<String> stringSet = list2.stream().collect(Collectors.toSet()); // list转set也可以达到去重效果

System.out.println(list3);

System.out.println(stringSet);

// 输出结果[a, b, c, f, e][a, b, c, e, f]123456789

3.9 统计 summaryStatistics

一些收集器能产生统计结果,例如Collectors提供了一系列用于数据统计的静态方法,它们主要用于int、double、long等基本类型上。

// 总和统计summaryStatistics

DoubleSummaryStatistics doubleSummaryStatistics =

        students.stream().mapToDouble(Student::getScore).summaryStatistics();

System.out.println("平均值:" + doubleSummaryStatistics.getAverage());

System.out.println("总个数:" + doubleSummaryStatistics.getCount());

System.out.println("最大值:" + doubleSummaryStatistics.getMax());

System.out.println("最小值:" + doubleSummaryStatistics.getMin());

System.out.println("总和值:" + doubleSummaryStatistics.getSum());

// 输出结果

平均值:75.9

总个数:10

最大值:100.0

最小值:10.0

总和值:759.0123456789101112131415

// 统计个数

long count = students.stream().count();// 平均值Double averageScore =

        students.stream().collect(Collectors.averagingDouble(Student::getScore));// 最大值和最小值Optional<Double> maxScore = students.stream().map(Student::getScore).max(Double::compare);Optional<Double> minScore = students.stream().map(Student::getScore).min(Double::compare);// 求和

double sumScore = students.stream().mapToDouble(Student::getScore).sum();// 一次性统计所有DoubleSummaryStatistics doubleSummaryStatistics1 =

        students.stream().collect(Collectors.summarizingDouble(Student::getScore));System.out.println("单个维度计算:");System.out.println("统计个数:" + count);System.out.println("平均值:" + averageScore);

maxScore.ifPresent(aDouble -> System.out.println("最大值:" + aDouble));

minScore.ifPresent(aDouble -> System.out.println("最小值:" + aDouble));System.out.println("求和:" + sumScore);System.out.println("一次性统计所有:" + doubleSummaryStatistics1);

// 输出结果

单个维度计算:

统计个数:10

平均值:75.9

最大值:100.0

最小值:10.0

求和:759.012345678910111213141516171819202122232425262728

3.10 归约 reduce

归约,把一个流归约(缩减)成一个值,能实现对集合求和、求乘积和求最值等操作。

List<Integer> integerList = Arrays.asList(6, 7, 1, 10, 11, 7, 13, 20);// 求和Optional<Integer> sum1 = integerList.stream().reduce(Integer::sum);// 求和,基于10的基础上Integer sum2 = integerList.stream().reduce(10, Integer::sum);// 求最大值Optional<Integer> max1 = integerList.stream().reduce((x, y) -> x > y ? x : y);// 求最大值,基于与50比较的基础上Integer max2 = integerList.stream().reduce(50, Integer::max);Optional<Integer> min = integerList.stream().reduce(Integer::min);// 求乘积Optional<Integer> product = integerList.stream().reduce((x, y) -> x * y);System.out.println("原始集合:" + integerList);System.out.println("集合求和:" + sum1.get() + "," + sum2);System.out.println("集合求最大值:" + max1.get() + "," + max2);System.out.println("集合求最小值:" + min.get());System.out.println("集合求积:" + product.get());

// 输出结果

原始集合:[6, 7, 1, 10, 11, 7, 13, 20]

集合求和:75,85

集合求最大值:20,50

集合求最小值:1

集合求积:8408400123456789101112131415161718192021222324

3.11 归集 toList,toSet,toMap

Java中的Stream不会存储元素,而是按需计算按照特定的规则对数据进行计算,一般会输出结果。所以流中的数据完成处理后,需要将流中的数据重新归集到新的集合里。比较常用的是toList、toSet和toMap,以及复杂的toCollection、toConcurrentMap等。

// 获取学生名字,形成新的list集合

List<String> studentNames1 =

        students.stream().map(Student::getName).collect(Collectors.toList());// 获取年龄大于等于15的年龄set集合

Set<Integer> ageSet = students.stream().filter(student -> student.getAge() >= 15)

        .map(Student::getAge).collect(Collectors.toSet());// 创建学生ID和学生实体的map

Map<String, Student> studentMap =

        students.stream().collect(Collectors.toMap(Student::getId, student -> student));

System.out.println(studentNames1);

System.out.println(ageSet);

studentMap.forEach((key, value) -> System.out.println(key + ":" + value));

// 输出结果[张三, 李四, 王五, 赵六, 董七, 幺八, 老九, 小明, 小红, 小张][17, 18, 20, 21, 22, 25]1:Student{id='1', name='张三', age=18, sex=male, score=88.0}2:Student{id='2', name='李四', age=17, sex=male, score=60.0}3:Student{id='3', name='王五', age=18, sex=male, score=100.0}4:Student{id='4', name='赵六', age=20, sex=male, score=10.0}5:Student{id='5', name='董七', age=14, sex=female, score=95.0}6:Student{id='6', name='幺八', age=21, sex=male, score=55.0}7:Student{id='7', name='老九', age=20, sex=female, score=66.0}8:Student{id='8', name='小明', age=18, sex=male, score=100.0}9:Student{id='9', name='小红', age=22, sex=female, score=95.0}10:Student{id='10', name='小张', age=25, sex=male, score=90.0}1234567891011121314151617181920212223242526

3.12 分组 partitioningBy,groupingBy

partitioningBy(分区):stream中的元素按条件被分为两个Map。
groupingBy(分组):stream中的元素按条件被分为多个Map。

// 按条件学生成绩是否大于等于60,划分为2个组

Map<Boolean, List<Student>> studentScorePart = students.stream()

        .collect(Collectors.partitioningBy(student -> student.getScore() >= 60));// 按性别分组

Map<String, List<Student>> studentSexMap =

        students.stream().collect(Collectors.groupingBy(Student::getSex));// 按年龄分组

Map<Integer, List<Student>> studentAgeMap =

        students.stream().collect(Collectors.groupingBy(Student::getAge));// 先按性别分组,再按年龄分组

Map<String, Map<Integer, List<Student>>> collect = students.stream().collect(

        Collectors.groupingBy(Student::getSex, Collectors.groupingBy(Student::getAge)));

System.out.println("按条件学生成绩是否大于等于60,划分为2个组:");

studentScorePart.forEach((aBoolean, students7) -> {

    System.out.println("成绩大于等于60?:" + aBoolean);

    students7.forEach(System.out::println);});

System.out.println("按性别分组:");

studentSexMap.forEach((sex, students7) -> {

    System.out.println("性别?:" + sex);

    students7.forEach(System.out::println);});

System.out.println("按年龄分组:");

studentAgeMap.forEach((age, students7) -> {

    System.out.println("年龄:" + age);

    students7.forEach(System.out::println);});

System.out.println("先按性别分组,再按年龄分组:");

collect.forEach((sex, integerListMap) -> {

    System.out.println("性别:" + sex);

    integerListMap.forEach((age, students7) -> {

        System.out.println("年龄:" + age);

        students7.forEach(System.out::println);

    });});

//输出结果

按条件学生成绩是否大于等于60,划分为2个组:

成绩大于等于60?:false

Student{id='4', name='赵六', age=20, sex=male, score=10.0}

Student{id='6', name='幺八', age=21, sex=male, score=55.0}

成绩大于等于60?:true

Student{id='1', name='张三', age=18, sex=male, score=88.0}

Student{id='2', name='李四', age=17, sex=male, score=60.0}

Student{id='3', name='王五', age=18, sex=male, score=100.0}

Student{id='5', name='董七', age=14, sex=female, score=95.0}

Student{id='7', name='老九', age=20, sex=female, score=66.0}

Student{id='8', name='小明', age=18, sex=male, score=100.0}

Student{id='9', name='小红', age=22, sex=female, score=95.0}

Student{id='10', name='小张', age=25, sex=male, score=90.0}

按性别分组:

性别?:female

Student{id='5', name='董七', age=14, sex=female, score=95.0}

Student{id='7', name='老九', age=20, sex=female, score=66.0}

Student{id='9', name='小红', age=22, sex=female, score=95.0}

性别?:male

Student{id='1', name='张三', age=18, sex=male, score=88.0}

Student{id='2', name='李四', age=17, sex=male, score=60.0}

Student{id='3', name='王五', age=18, sex=male, score=100.0}

Student{id='4', name='赵六', age=20, sex=male, score=10.0}

Student{id='6', name='幺八', age=21, sex=male, score=55.0}

Student{id='8', name='小明', age=18, sex=male, score=100.0}

Student{id='10', name='小张', age=25, sex=male, score=90.0}

按年龄分组:

年龄:17

Student{id='2', name='李四', age=17, sex=male, score=60.0}

年龄:18

Student{id='1', name='张三', age=18, sex=male, score=88.0}

Student{id='3', name='王五', age=18, sex=male, score=100.0}

Student{id='8', name='小明', age=18, sex=male, score=100.0}

年龄:20

Student{id='4', name='赵六', age=20, sex=male, score=10.0}

Student{id='7', name='老九', age=20, sex=female, score=66.0}

年龄:21

Student{id='6', name='幺八', age=21, sex=male, score=55.0}

年龄:22

Student{id='9', name='小红', age=22, sex=female, score=95.0}

年龄:25

Student{id='10', name='小张', age=25, sex=male, score=90.0}

年龄:14

Student{id='5', name='董七', age=14, sex=female, score=95.0}

先按性别分组,再按年龄分组:

性别:female

年龄:20

Student{id='7', name='老九', age=20, sex=female, score=66.0}

年龄:22

Student{id='9', name='小红', age=22, sex=female, score=95.0}

年龄:14

Student{id='5', name='董七', age=14, sex=female, score=95.0}

性别:male

年龄:17

Student{id='2', name='李四', age=17, sex=male, score=60.0}

年龄:18

Student{id='1', name='张三', age=18, sex=male, score=88.0}

Student{id='3', name='王五', age=18, sex=male, score=100.0}

Student{id='8', name='小明', age=18, sex=male, score=100.0}

年龄:20

Student{id='4', name='赵六', age=20, sex=male, score=10.0}

年龄:21

Student{id='6', name='幺八', age=21, sex=male, score=55.0}

年龄:25

Student{id='10', name='小张', age=25, sex=male, score=90.0}123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102

3.13 合并 joining

将stream中的元素用指定的连接符(没有的话,则直接连接)连接成一个字符串。

String joinName = students.stream().map(Student::getName).collect(Collectors.joining(", "));

System.out.println(joinName);

// 输出结果

张三, 李四, 王五, 赵六, 董七, 幺八, 老九, 小明, 小红, 小张12345

 

鸿蒙系统开发工程师:核心技术解析与深度面试指南 摘要: 鸿蒙系统开发工程师需具备底层驱动开发、系统移植优化及分布式架构能力。核心职责包括硬件适配(Bootloader、内核移植、HDF驱动开发)、性能调优(启动加速、功耗管理)及稳定性保障。技术要求涵盖C/C++编程、Linux内核机制、鸿蒙架构(HDF、分布式服务)及ArkTS/ArkUI基础。面试重点考察系统移植流程(如ARM板适配)、驱动开发(I2C/Display)、性能优化手段及内存/同步机制的应用。 阅读详情

相关推荐

02.Palantir Foundry平台功能和应用全景图

本文深入解析 Palantir Foundry 平台核心功能与应用全景。

697

java8 stream 过滤、排序、求和、分组、去重等方法使用和说明

定义一个实体 import lombok.Data; @Data public class TestVO { /** * 主键 */ private long id; /** * 姓名 */ private String name; /** * 年龄 */ private String age; }

qq_44293888的博客 1万+

机器学习系列(1)_逻辑回归初步

1、总述 逻辑回归是应用非常广泛的一个分类机器学习算法,它将数据拟合到一个logit函数(或者叫做logistic函数)中,从而能够完成对事件发生的概率进行预测。 2、由来     要说逻辑回归,我们得追溯到线性回归,想必大家对线性回归都有一定的了解,即对于多维空间中存在的样本点,我们用特征的线性组合去拟合空间中点的分布和轨迹。如下图所示:     线性回归能对连续值结果进行预测,

寒小阳 13万+

Java如何借助Stream流进行求和呢?

stream对list进行求和的示例分享

qq_25073223的博客 3万+

【OpenCV】手眼标定实战:从原理到calibrateHandEye的完整实现

本文详细解析了机器人视觉中的手眼标定原理与实战,重点介绍了如何使用OpenCV的calibrateHandEye函数实现从数据采集到结果验证的完整流程。文章深入剖析了AX=XB核心方程,区分了眼在手上与眼在手外两种配置,并提供了详细的代码示例与避坑指南,帮助开发者精准建立相机与机械臂末端的坐标转换关系,是机器人精准抓取的关键技术。

weixin_29046611的博客 512

[ vulhub漏洞复现篇 ] ActiveMQ反序列化漏洞复现(CVE-2015-5254)

Apache ActiveMQ是美国阿帕奇(Apache)软件基金会所研发的一套开源的消息中间件,它支持Java消息服务、集群、Spring Framework等。由于ActiveMQ是一个纯Java程序,因此只需要操作系统支持Java虚拟机,ActiveMQ便可执行。Apache ActiveMQ 5.13.0之前5.x版本中存在安全漏洞,该漏洞源于程序没有限制可在代理中序列化的类。......

qq_51577576的博客 4445

Stream流基础

Stream流基础

码上红尘仙的博客 467

ICC2(一)import design —— tluplus

itf转tluplus相关命令 TLUPlus是存储RC系数的二进制表格式。 TLUPlus模型通过包括宽度,空间,密度和温度对电阻系数的影响,可以估算RC计算net delay。 1.2 产生TLUplus的方法 Itf文件转TLUplus的命令: grdgenxo -itf2TLUPlus -i xx.itf-o xx.tlu+ itf: interconnect technology format file 含每层的厚度,面积等参数 itf同样可以转nxtgrd格式文...

m0_61544122的博客 5486

java8 List的Stream流操作 (特别篇 二) toMap

java8 List的Stream流操作 (特别篇 二) toMap 1、简单组装 (但是 key(userId) 重复会报错) 2、组装成map key值取前面的(重复情况下) 3、组装成map key值取后面的(重复情况下) 4、组装成map key值取累加或者拼接(重复情况下) 5、组装成map 先通过性别分组再统计性别年龄总和 6、组装成 Map> 根据userId 组装list对象,对应userId的对象的某个属性成组(userName) 7、以userId为key 以User对象为值 Map

DJyzh的博客 3733

自动化上位机开发C#100例:如何用面向对象的方式封装雷赛运动控制卡EtherCAT总线卡(C#代码)

自动化上位机开发C#100例:雷赛运动控制卡EtherCAT总线卡C#封装类。

十多年IT经验,专注机器视觉,智能制造半导体行业 5037

MATLAB离线附加功能包下载与安装教程

本文介绍如何下载与安装MATLAB离线附加功能包,便于大家更加高效的使用MATLAB。

加斯顿工程师的博客 1万+

java8的stream中的toMap

我们将对这个List使用java8的strea中的toMap转换成Map对象。 toMap有个三个重载的方法,toConcurrentMap同理: 两个参数 public static <T, K, U> Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper, Functio..

qq_41434612的博客 1万+

深度学习驱动的股票波动率预测:LSTM和Transformer模型的实战解析

股票市场的波动率一直是金融领域关注的焦点之一。波动率预测对于风险管理、期权定价和资产配置至关重要。深度学习模型,如长短时记忆网络(LSTM)和Transformer,已经在时间序列数据分析领域取得了显著的成就。本博客将向您展示如何使用这两种深度学习模型来进行股票波动率预测,提供清晰的思路和相应的Python代码,以帮助您理解和应用这一重要任务。

斌擎科技 974

玩转Java8Stream(一、从零认识Stream)

前言相信Java8的Stream 大家都已听说过了,但是可能大家不会用或者用的不熟,笔者将在《玩转Java8Stream》系列文章中带大家从零开始使用,循序渐进,带你走向Stream的巅...

这个时代,作为程序员可能要学习小程序 469

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

玩转Java8 Stream流

Java8中Stream流总结 因为在工作后,发现项目代码里经常会出现Stream流以及和lambda表达式联合使用。但之前对于这块的学习有点一知半解,所以花了几天空闲时间将这些知识总结一下。 一、概述 **(参考百度)**Stream 是 Java8 中处理集合的关键抽象概念,它可以指定你希望对集合进行的操作,可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作,就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之,Str

weixin_41938314的博客 9595

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

20 个实例玩转 Java 8 Stream

20 个实例玩转 Java 8 Stream

YIYIYI 808

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

玩转 Java8 Stream 流,常用方法,详细用法大合集

Stream 是 Java8 中处理集合的关键抽象概念,它可以指定你希望对集合进行的操作,可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作,就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之,Stream API 提供了一种高效且易于使用的处理数据的方式。特点:不是数据结构,不会保存数据。不会修改原来的数据源,它会将操作后的数据保存到另外一个对象中。(保留意见:毕竟peek方法可以修改流中元素)

m0_74931226的博客 770

玩转Java8中的 Stream 之从零认识 Stream

点击上方“码猿技术专栏”,选择“设为星标”作者:liteskywww.jianshu.com/p/11c925cdba50相信Java8的Stream 大家都已听说过了,但是可能大家不会...

码猿技术专栏 487

20个实例玩转Java8 Stream

Java 8 是一个非常成功的版本,这个版本新增的Stream,配合同版本出现的 Lambda ,给我们操作集合(Collection)提供了极大的便利。Stream将要处理的元素集合看作一种流,在流的过程中,借助Stream API对流中的元素进行操作,比如:筛选、排序、聚合等。Stream可以由数组或集合创建,对流的操作分为两种:1、中间操作,每次返回一个新的流,可以有多个。2、终端操作,每个流只能进行一次终端操作,终端操作结束后流无法再次使用。终端操作会产生一个新的集合或值。

壹升茉莉清的博客 530

玩转 Java8 Stream,让你代码更高效紧凑简洁

聆听 沉淀 传播 … 关注微信公众号【Java之言】,助你放弃编程之路! 文章目录前言一、Stream 特性二、Stream 创建2.1 用集合创建流2.2 用数组创建流2.3 Stream静态方法三、Stream 使用案例3.1 遍历 forEach3.2 过滤 filter3.3 查找 findFirst,findAny3.4 匹配 match3.5 映射 map3.6 截取流 limit3.7 排序 sorted3.8 去重 distinct3.9 统计 前言 Java 8 (又称为 jdk.

陈皮的JavaLib 1万+

玩转Java8的 Stream 之从零认识Stream

相信Java8的Stream 大家都已听说过了,但是可能大家不会用或者用的不熟,笔者将在《玩转Java8Stream》系列文章中带大家从零开始使用,循序渐进,带你走向Stream的巅峰。 操作符 什么是操作符呢?操作符就是对数据进行的一种处理工作,一道加工程序;就好像工厂的工人对流水线上的产品进行一道加工程序一样。 Stream的操作符大体上分为两种:中间操作符和终止操作符 中间操作符 对于数据流来说,中间操作符在执行制定处理程序后,数据流依然可以传递给下一级的操作符。 中间操作符包含8种(排除了par.

麦叔 457
上一篇: 阿里云SSL证书免费申请
下一篇: java实现带logo的二维码
宁漂打工仔
博客等级 码龄9年 1万+粉丝 153原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值