Java8新特性Stream的使用总结

最新推荐文章于 2023-02-27 09:07:21 发布
最新推荐文章于 2023-02-27 09:07:21 发布
阅读量2.4k 收藏 88
点赞数 17
分类专栏： Java SE 文章标签： stream lambda java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huangjhai/article/details/107852137
版权

文章目录

一、Stream简介

Stream是Java8中处理集合的关键抽象概念，Stream API提供了一种高效且易于使用的处理数据的方式。你可以使用它对集合数据进行指定操作，如可以执行非常复杂的查找、过滤和映射数据等操作。

注意：

  1. Stream自己不会存储元素
  2. Stream不会改变源对象，Stream操作会返回一个新的Stream
  3. Stream操作是延迟执行的，这意味着等到获取结果时,Stream才会执行

Stream操作的三个步骤：

  1. Stream创建，由一个数据源，如集合、数组来获取一个Stream
  2. 中间操作。一个中间操作链，对数据源的数据进行处理
  3. 终止操作。执行中间操作链并产生结果。

Stream的操作步骤示例图：
在这里插入图片描述

二、Stream的创建

1.使用集合来创建Stream
Java8中的Collection接口被扩展，提供了两个获取Stream的方法：

//返回一个顺序流
default Stream<R> stream() 
//返回一个并行流
default Stream<E> parallelStream()

2.使用数组创建Stream
Java8中的Arrays的静态方法stream()可以获取流

static <T> Stream<T> stream(T[] array)
static IntStream<T> stream(int[] array)
static LongStream<T> stream(long[] array)
static DoubleStream<T> stream(double[] array)

3.由值创建Stream
使用Stream的静态方法of来创建一个流，该方法可以接收任意数量的参数。

static<T> Stream<T> of(T... values)

4.由函数创建Stream
可以使用Stream的静态方法iterate()和generate()创建无限流

public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
public static<T> Stream<T> generate(Supplier<T> s)

Stream创建代码示例：

@Test
  public void test01(){
    //1.通过Collection系列集合提供的stream()或parallelStream()获取
    ArrayList<String> list = new ArrayList<>();
    Stream<String> stream1 = list.stream();
    //2.通过Arrays中的静态方法stream()获取
    String[] strings=new String[10];
    Stream<String> stream2 = Arrays.stream(strings);
    //3.通过Stream类中的静态方法of()获取
    Stream<String> stream3 = Stream.of(strings);
    //4.创建无限流
    //4.1迭代
    Stream<Integer> stream4 = Stream.iterate(0, x-> x + 2);
    //4.2生成
    Stream<Double> stream5 = Stream.generate(() -> Math.random());
  }

三、Stream的中间操作

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何处理，而是在种植操作时一次性全部处理，称为“惰性求值”。

1.筛选与切片

筛选与切片的相关方法介绍：
在这里插入图片描述
使用示例
创建一个Employee类用于后续使用：

public class Employee {
  private Integer id;
  private String name;
  private Integer age;
  private State state;

  public Employee(Integer id, String name, Integer age, State state) {
    this.id = id;
    this.name = name;
    this.age = age;
    this.state = state;
  }

  @Override
  public Employee(){

  }

  public Employee(Integer id) {
    this.id = id;
  }

  public Employee(Integer id, Integer age) {
    this.id = id;
    this.age = age;
  }

  public Employee(int id, String name, int age) {
    this.id = id;
    this.name = name;
    this.age = age;
  }



  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Employee employee = (Employee) o;
    return Objects.equals(id, employee.id) &&
            Objects.equals(name, employee.name) &&
            Objects.equals(age, employee.age) &&
            state == employee.state;
  }

  @Override
  public int hashCode() {
    return Objects.hash(id, name, age, state);
  }
//省略getter、setter、toString方法
}

State枚举类的定义

public enum State {
  BUSY,
  FREE,
  VACATION
}

filter方法——接收Lambda，从流中排除某些元素

public class TestStreamAPI02 {
  List<Employee> employees=Arrays.asList(new Employee(1,"张三",60),
          new Employee(2,"李四",50),
          new Employee(3,"王五",45),
          new Employee(26,"赵六",45),
          new Employee(26,"赵六",45),
          new Employee(26,"赵六",45));
  //filter——接收Lambda，从流中排除某些元素
  @Test
  public void test01(){
    //中间操作：不会执行任何操作
    Stream<Employee> stream = employees.stream().filter((employee -> {
      System.out.println("执行过滤操作");
      return employee.getAge() > 45;
    }));
    //终止操作：一次性执行全部内容，即“惰性求值”
    stream.forEach(System.out::println);
  }
}

控制台输出结果：
在这里插入图片描述
limit——截断流，使其元素不超过给定数量

  @Test
  public void test02(){
    employees.stream()
            .filter(e->e.getAge()>18)
            .limit(3)
            .forEach(System.out::println);
  }

控制台输出结果：
在这里插入图片描述
skip–跳过元素，返回一个扔掉了前n个元素的流，若流中的元素不足n个，则返回空流。与limit互补。

  @Test
  public void test03(){
    employees.stream()
            .skip(2)
            .forEach(System.out::println);
  }

控制台输出结果：
在这里插入图片描述
distinct–筛选，去取流中的hashcode()和equals相同的元素

  @Test
  public void test04(){
    employees.stream()
            .distinct()
            .forEach(System.out::println);
  }

Employee类中重写了hashcode()和equals（）方法根据id, name, age, state属性进行比较计算对象是否相等，以此控制台输出结果：
在这里插入图片描述

2.映射

映射相关方法如下：
在这里插入图片描述
使用示例
map方法——接收Lambda，将元素转化成其他形式或提取信息。接收一个函数作为参数， 该函数会被应用到每个元素上，并将其映射成一个新的元素。

public class TestStreamAPI03 {
  List<Employee> employees=Arrays.asList(new Employee(1,"张三",60),
          new Employee(2,"李四",50),
          new Employee(3,"王五",45),
          new Employee(26,"赵六",45),
          new Employee(26,"赵六",45),
          new Employee(26,"赵六",45));
  @Test
  public void test01(){
    List<String> list = Arrays.asList("a", "bb", "ccc", "dddd");
    //将list中元素转化成其他形式
    list.stream()
            .map(s->s.toUpperCase())
            .forEach(System.out::print);
    //原集合不受到影响
    list.forEach(System.out::print);
    //提取list中元素的信息
    employees.stream()
            .map(employee -> employee.getName())
            .forEach(System.out::print);
  }
  }

控制台输出结果：
在这里插入图片描述

flatMap方法–接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

public class TestStreamAPI03 {
  List<Employee> employees=Arrays.asList(new Employee(1,"张三",60),
          new Employee(2,"李四",50),
          new Employee(3,"王五",45),
          new Employee(26,"赵六",45),
          new Employee(26,"赵六",45),
          new Employee(26,"赵六",45));

  //提取字符串中的每个字符到list中，并放入stream流
  public static Stream<Character> filterCharacter(String str){
    ArrayList<Character> list = new ArrayList<>();
    for (Character ch:str.toCharArray()) {
      list.add(ch);
    }
    return list.stream();
  }
  //测试flatMap
  @Test
  public void test02(){
    List<String> list = Arrays.asList("a", "bb", "ccc", "dddd");
    Stream<Stream<Character>> streams = list.stream()
            .map(TestStreamAPI03::filterCharacter);//得到的流的形式类似{{a},{b,b},{c,c,c},{d,d,d,d}}
    //不使用flatMap函数
    System.out.println("不使用flatMap函数");
    streams.forEach(stream->stream.forEach(System.out::print));
    //使用flatMap函数
    System.out.println("\n使用flatMap函数");
    Stream<Character> streams2 = list.stream()
            .flatMap(TestStreamAPI03::filterCharacter);//得到流的形式类似{a,b,b,c,c,c,d,d,d,d}
    streams2.forEach(System.out::print);
  }
}

控制台输出结果：
在这里插入图片描述

3.排序

排序的相关方法：
在这里插入图片描述
使用示例：
sorted()–产生一个新流，自然排序(Comparable)

public class TestStreamAPI04 {
  List<Employee> employees=Arrays.asList(new Employee(1,"张三",60),
          new Employee(2,"李四",50),
          new Employee(3,"王五",45),
          new Employee(23,"赵六",45),
          new Employee(21,"田七",45),
          new Employee(24,"天启",45));
  @Test
  public void test01(){
    List<String> list = Arrays.asList("ddd", "ccc", "bbb", "aaa");
    //默认使用泛型的实现Comparable接口中的compareTo方法进行比较
    list.stream().sorted().forEach(System.out::println);
  }
}

sorted(Comparator com)–产生一个新流，定制排序(Comparator)

  @Test
  public void test02(){
    employees.stream().sorted((e1,e2)->{
      if (e1.getAge().equals(e2.getAge())){
        return e1.getId().compareTo(e2.getId());
      }else{
        return e1.getAge().compareTo(e2.getAge());
      }
    }).forEach(System.out::println);
  }

四、Stream的终止操作

终端操作会从stream的流水线生成结果，其结果可以不是流的值，可以是List，Integer，甚至是Void。

1.查找与匹配

查找与匹配的相关方法：
在这里插入图片描述
在这里插入图片描述
测试 allMatch，anyMatch，noneMatch方法的使用

public class TestStreamAPI05 {
  List<Employee> employees=Arrays.asList(new Employee(1,"张三",60),
          new Employee(2,"李四",50, State.BUSY),
          new Employee(3,"王五",45,State.BUSY),
          new Employee(23,"赵六",45,State.FREE),
          new Employee(21,"田七",40,State.VACATION),
          new Employee(24,"天启",35,State.FREE));
  //测试allMatch，anyMatch，noneMatch
  @Test
  public void test01(){
    boolean allMatch = employees.stream().allMatch(e -> e.getAge() >= 45);
    System.out.println(allMatch);
    boolean anyMatch = employees.stream().anyMatch((e -> e.getAge() > 65));
    System.out.println(anyMatch);
    boolean noneMatch = employees.stream().noneMatch((e -> e.getAge() > 65));
    System.out.println(noneMatch);
  }
}

控制台输出结果：
在这里插入图片描述

测试findFirst，findAny方法的使用

 //测试findFirst，findAny
  @Test
  public void test02(){
    Optional<Employee> first = employees.stream()
            .sorted((e1, e2) -> e1.getAge().compareTo(e2.getAge()))
            .findFirst();
    System.out.println(first.get());
    Optional<Employee> any = employees.stream().filter(e -> e.getState()==State.FREE).findAny();
    System.out.println(any.get());
  }

控制台输出结果：
在这里插入图片描述
测试count，max，min方法的使用

 //测试count，max，min
  @Test
  public void test03(){
    //测试count
    long count = employees.stream().count();
    System.out.println(count);
    //测试max
    Optional<Employee> max = employees.stream().max((e1, e2) -> e1.getAge().compareTo(e2.getAge()));
    System.out.println(max.get());
    //测试min
    Optional<Employee> min = employees.stream().min((e1, e2) -> e1.getAge().compareTo(e2.getAge()));
    System.out.println(min.get());
  }

控制台输出的结果：
在这里插入图片描述

2.规约

规约相关方法：
在这里插入图片描述
测试reduce(T identity,BinaryOperator)和reduce(BinaryOperator),其中identity为原始的结合值。

public class TestStreamAPI06 {
  List<Employee> employees=Arrays.asList(new Employee(1,"张三",60),
          new Employee(2,"李四",50, State.BUSY),
          new Employee(3,"王五",45,State.BUSY),
          new Employee(23,"赵六",45,State.FREE),
          new Employee(21,"田七",40,State.VACATION),
          new Employee(24,"天启",35,State.FREE));
  @Test
  public void test01(){
    //计算整数数组累加
    List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    Integer result = integers.stream().reduce(5, (x, y) -> x + y);
    System.out.println(result);
    //计算平均年龄
    Optional<Integer> ageTotal = employees.stream().map(Employee::getAge).reduce(Integer::sum);
    long empNum=employees.stream().count();
    System.out.println(ageTotal.get()/empNum);
  }
}

控制台输出结果：
在这里插入图片描述

3.收集

收集的方法定义
在这里插入图片描述
Collector接口中的方法的实现决定了如何对流执行收集操作（如收集到List、Set、Map）。Collectors实用类提供了很多静态方法，可以方便地创建常用的收集器实例，具体方法与实例如下图：
在这里插入图片描述
在这里插入图片描述
测试将流转换为其他形式，收集到新的集合上，包括Collectors.toList()、Collectors.toSet()、Collectors.toCollection（集合对象）

  List<Employee> employees=Arrays.asList(new Employee(1,"张三",60,State.VACATION),
          new Employee(2,"李四",50, State.BUSY),
          new Employee(3,"王五",45,State.BUSY),
          new Employee(23,"赵六",45,State.FREE),
          new Employee(23,"赵六",45,State.FREE),
          new Employee(21,"田七",40,State.VACATION),
          new Employee(24,"天启",35,State.FREE));
  @Test
  public void test01(){
    List<String> list = employees.stream().map(Employee::getName).collect(Collectors.toList());
    list.forEach(System.out::println);
    System.out.println("-----------------");
    Set<String> set = employees.stream().map(Employee::getName).collect(Collectors.toSet());
    set.forEach(System.out::println);
    System.out.println("-----------------");
    HashSet<String> hashSet = employees.stream().map(Employee::getName).collect(Collectors.toCollection(HashSet::new));
    hashSet.forEach(System.out::println);
  }
  }

数组统计相关方法，包括counting、averagingDouble、summingInt等方法。

  @Test
  public void test02(){
    //总数
    Long sum= employees.stream().collect(Collectors.counting());
    System.out.println(sum);
    //平均值
    Double averageAge = employees.stream().collect(Collectors.averagingDouble(Employee::getAge));
    System.out.println(averageAge);
    //某属性的综合
    Integer ageSum = employees.stream().collect(Collectors.summingInt(Employee::getAge));
    System.out.println(ageSum);
    //最大值
    Optional<Employee> maxAgeEmployee = employees.stream().collect(Collectors.maxBy((e1, e2) -> e1.getAge().compareTo(e2.getAge())));
    System.out.println(maxAgeEmployee.get());
    //最小值
    Optional<Employee> minAgeEmployee = employees.stream().collect(Collectors.minBy((e1, e2) -> e1.getAge().compareTo(e2.getAge())));
    System.out.println(minAgeEmployee.get());
    //所有数据
    IntSummaryStatistics totalData = employees.stream().collect(Collectors.summarizingInt(Employee::getAge));
    System.out.println(totalData);
  }

控制台输出结果：
在这里插入图片描述
测试分组groupingBy方法

  @Test
  public void test03(){
    Map<State, List<Employee>> stateListMap = employees.stream().collect(Collectors.groupingBy(Employee::getState));
    System.out.println(stateListMap);
  }

程序输出结果：

{FREE=[Employee{id=23, name='赵六', age=45, state=FREE}, Employee{id=23, name='赵六', age=45, state=FREE}, Employee{id=24, name='天启', age=35, state=FREE}], VACATION=[Employee{id=1, name='张三', age=60, state=VACATION}, Employee{id=21, name='田七', age=40, state=VACATION}], BUSY=[Employee{id=2, name='李四', age=50, state=BUSY}, Employee{id=3, name='王五', age=45, state=BUSY}]}

测试多级分组：

  @Test
  public void test04(){
    Map<State, Map<String, List<Employee>>> collect = employees.stream()
            .collect(Collectors.groupingBy(Employee::getState, Collectors.groupingBy((e) -> {
              if (((Employee) e).getAge() <= 30) {
                return "青年";
              } else if (((Employee) e).getAge() <= 50) {
                return "中年";
              } else {
                return "老年";
              }
            })));
    System.out.println(collect);
  }

控制台输出结果：

{VACATION={老年=[Employee{id=1, name='张三', age=60, state=VACATION}], 中年=[Employee{id=21, name='田七', age=40, state=VACATION}]}, FREE={中年=[Employee{id=23, name='赵六', age=45, state=FREE}, Employee{id=23, name='赵六', age=45, state=FREE}, Employee{id=24, name='天启', age=35, state=FREE}]}, BUSY={中年=[Employee{id=2, name='李四', age=50, state=BUSY}, Employee{id=3, name='王五', age=45, state=BUSY}]}}

测试分区方法partitioningBy，接收Predicate，满足属于true，不满足就属于false。

  //分区
  @Test
  public void test08(){
    Map<Boolean, List<Employee>> collect = employees.stream().collect(Collectors.partitioningBy(employee -> employee.getAge() > 40));
    System.out.println(collect);

  }

程序输出结果：

{false=[Employee{id=21, name='田七', age=40, state=VACATION}, Employee{id=24, name='天启', age=35, state=FREE}], true=[Employee{id=1, name='张三', age=60, state=VACATION}, Employee{id=2, name='李四', age=50, state=BUSY}, Employee{id=3, name='王五', age=45, state=BUSY}, Employee{id=23, name='赵六', age=45, state=FREE}, Employee{id=23, name='赵六', age=45, state=FREE}]}

笔记总结自：https://www.bilibili.com/video/BV14W411u7Ly?from=search&seid=6050719224094931659

Code0cean
关注
  • 17
    点赞
  • 踩
  • 88
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Java8新特性之Stream的使用
qq_44779506的博客
04-03 351
流(Stream)的基本介绍 Stream的操作步骤 创建Stream 一个数据源（如：集合、数组），获取一个流 中间操作 一个中间操作链，对数据源的数据进行处理 终止操作（终端操作） 一个终止操作，执行中间操作链，并产生结果 创建Stream public class Demo01 { List<Person> people = Arrays.asList( ...
Java8新特性，Stream方法总结
q8365的博客
09-05 184
Java8新特性，Stream方法总结 Java 8之所以费这么大功夫引入函数式编程，原因有二： 1.代码简洁函数式编程写出的代码简洁且意图明确，使用stream接口让你从此告别for循环。 2.多核友好，Java函数式编程使得编写并行程序从未如此简单，你需要的全部就是调用一下parallel()方法。 对于Java 7来说stream完全是个陌生东西，stream并不是某种数据结构，它只是数据源...
java8新特性-Stream
odelia的博客
05-23 402
—–通过学习尚硅谷视频所得—– 咱们在sql中,可以对集合进行增删改插入和统计,但是在java程序中,对于一些集合, 都是通过循环的方式来处理里面的数据的.所以,对于大数量的集合,能不能充分利用多核的优势,并行去处理. 这里就来介绍一种这样的处理数据的风格—Stream 这种特性的引入,让我们更加便利一些函数式编程方法的使用.可以充分利用系统并行能力,不需要自己手工去做很多底层的工作. 定...
Java8 新特性:（二）Stream
360°顺滑
02-06 537
一、前言二、Stream概述三、Stream的创建三、Stream的使用3.1 遍历/匹配（foreach/find/match）3.2 筛选（filter）3.3 聚合（max/min/count)3.4 映射(map/flatMap)3.5 归约(reduce)3.6 收集(collect)3.6.1 归集(toList/toSet/toMap)3.6.2 统计(count/averaging)3.6.3 分组(partitioningBy/groupingBy)3.6.4 接合(joining)3..
Java8新特性-Stream流
silentcow
12-07 640
Java8新特性-Stream流 1、Stream 和 集合的区别 Stream 关注的是对数据的运算，与CPU打交道 集合关注的数据的存储，与内存打交道 2、Stream 的特性 1.Stream 不会自己存储元素 2.Stream 不会改变源对象。相反，其会返回一个持有结果的新Stream 3.Stream 操作是延迟执行的，这意味着他们会等到需要结果的时候才执行 3、Stream 执行流程 Stream 的实例化 一系列的中间操作（过滤、映射。。。） 终止操作 说明： 一个中间操作链，
java8 stream使用总结
最新发布
08-16
Java 8是Java发展历程中的一个重要里程碑，它引入了许多新特性，其中最为显著的就是Stream API。Stream API彻底改变了我们处理集合数据的方式，使得代码更加简洁、高效且易于理解。以下是对"Java 8 Stream使用总结...
java8新特性之stream的collect实战教程
08-18
Java8新特性之Stream的Collect实战教程 Java8中引入了Stream API，它是一个功能强大且灵活的数据处理工具。Stream API提供了一个高效的方式来处理数据，特别是在处理大量数据时。Stream API的核心是collect方法，它...
Java8特性Stream流的使用（学完就会，项目源码，附带个人总结）
09-09
Java8是Java语言的一个重要版本，引入了许多新特性，其中最为引人注目的就是Stream API。Stream API极大地改进了集合操作的方式，使得处理大量数据变得更加高效、简洁和易读。以下将详细介绍Stream流的使用，以及它...
尚硅谷Java8新特性下载
01-22
Stream API是Java 8新增的一个重要特性，它提供了一种新的数据处理方式。Stream API可以让你以声明式的方式来操作数据，类似于SQL查询语言。它支持并行操作，并且可以自动管理内存。以下是一个简单的例子，展示如何...
streamjs用流的方式来对数组对象进行系列操作
08-10
streamjs 用流的方式来对数组，对象进行系列操作
【Java】Java8 之Stream用法总结（持续更新）
热门推荐
慕白Lee的博客
04-23 1万+
Java8 之Stream用法总结
Stream概述以及创建Stream对象
tainxiawuti的博客
08-26 1646
用来操作容器中的数据，例如过滤，映射，规约，排序，查找记录等等 Stream是和CPU打交道 集合关注的是数据的存储，是和内存打交道 总结：集合说的是数据，Stream说的是计算 注意： ①Stream 自己不会存储元素(数据)，数据仍然是在集合当中。类似于迭代器，迭代器是用来遍历集合的，迭代器本身也不存数据，数据还是在集合当中。Stream关注的是对数据的运算 ②Stream 不会改变源对象。相...
java8新特性 stream中间操作和终端操作示例说明java8新特性（查找、 排序、 过滤 、计算、 去重 、分组 等操作）
可爱猪猪
10-17 955
java8 的forEach、filter、map、distinct、sorted、peek、limit、skip、count、anyMatch、allMatch、noneMatch、toArray操作、min、max、findFirst、findAny、reduce、collect操作 示例说明 package com.zpy.demo.java8; import java.ut...
TestDataStream的用法
Sui_Phoebe的博客
04-06 421
package com.ylkj0401; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException;
Java8新特性
m1234ilu的博客
09-20 229
文章目录 前言 一、Lambda表达式 二、函数式接口 2.读入数据 总结 前言 提示：介绍Java8的新特性，包括Lambda表达式、函数式接口、方法引用、Optional、Stream流、日期类、其他 参考：https://www.runoob.com/java/java8-new-features.html 1、Lambda表达式 Lambda 表达式− Lambda 允许把函数作为一个方法的参数（函数作为参数传递到方法中）。 在JDK8之前，一个方法能接受的参数都..
Java8 Stream流编程操作
weixin_40659514的博客
07-29 452
java8 stream操作
Java基础必备
m0_59347746的博客
11-23 459
覆盖了equals()和hashCode()方法以确保两个相等映射返回相同的哈希码。如果两个映射大小相等、包含同样的键且每个键在这两个映射中对应的值都相同，则这两个映射相等。映射的哈希码是映射元素哈希码的总和，其中每个元素是Map.Entry接口的一个实现。因此，不论映射内部顺序如何，两个相等映射会报告相同的哈希码。
Java8 Stream流操作总结
weixin_54828627的博客
02-27 1409
Stream 流操作可以分为 3 种类型：创建 StreamStream 中间处理终止 Steam中间处理只是一种标记，只有终止操作才会触发实际计算。 中间操作又可以分为无状态的(Stateless)和有状态的(Stateful)，无状态中间操作是指元素的处理不受前面元素的影响，而有状态的中间操作必须等到所有元素处理之后才知道最终结果，比如排序是有状态操作，在读取所有元素之前并不能确定排序结果； 结束操作又可以分为短路操作和非短路操作，短路操作是指不用处理全部元素就可以返回结果，比如 找到第
Java8新特性探索：Lambda与Stream API
"Java8语法总结，包括Lambda表达式、Stream API、行为参数化、默认方法、Optional类、并行数据处理以及异步编程。学习Java8的新特性可以帮助提升编程效率，减少错误，并行处理能力增强，使得多核处理器的优势得以...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值