Java8新特性

已于 2023-09-18 12:42:46 修改
阅读量47 收藏
点赞数
文章标签： java jdk
于 2023-09-04 15:23:52 首次发布
Darling达
本文链接：https://blog.csdn.net/SDAU_Ada/article/details/132669980
版权

Java8新特性

小不忍，则乱大谋。识 时 务 者 为 俊 杰。

完整版笔记及源码

1、Lambda表达式

1.1、说明

  1. Lambda表达式的使用举例：
    (o1, o2) -> Integer.compare(o1,o2);

  2. Lambda表达式的格式举例:
    lambda形参列表 -> lambda体

  3. Lambda表达式的格式
    -> : lambda操作符或箭头操作符
    -> 的左边: lambda形参列表，对应着要重写的接口中的抽象方法的形参列表。
    -> 的右边: lambda体，对应着接口的实现类要重写的方法的方法体。

  4. Lambda表达式的本质：

> 一方面，lambda表达式作为接口的实现类的对象。 —> “万事万物皆对象”
> 另一方面，lambda表达式是一个匿名函数。

  1. 函数式接口：

5.1 什么是函数式接口？为什么需要函数式接口？

如果接口中只声明有一个抽象方法，则此接口就称为函数式接口。

因为只有给函数式接口提供实现类的对象时，我们才可以使用lambda表达式。

jdk8中声明的函数式接口都在java.util.function包下。

5.2 api中函数式接口所在的包

5.3 4个基本的函数式接口

​ 接口 对应的抽象方法
消费型接口：Consumer void accept(T t)
供给型接口：Supplier T get()
函数型接口：Function<T,R> R apply(T t)
判断型接口：Predicate boolean test(T t)

  1. Lambda表达式的语法规则总结
    -> 的左边：lambda形参列表，参数的类型都可以省略。如果形参只有一个，则一对()也可以省略。

-> 的右边：lambda体，对应着重写的方法的方法体。如果方法体中只有一行执行语句，则一对{}可以省略。如果有return关键字，则必须一并省略。

1.2、样例

Lambda 表达式：在Java 8 语言中引入的一种新的语法元素和操作符。这个操作符为 “->” ， 该操作符被称为 Lambda 操作符或箭头操作符。它将 Lambda 分为两个部分：

  • 左侧：指定了 Lambda 表达式需要的参数列表
  • 右侧：指定了 Lambda 体，是抽象方法的实现逻辑，也即 Lambda 表达式要执行的功能。

**语法格式一：**无参，无返回值

@Test
public void test1() {
    //未使用Lambda表达式
    Runnable r1 = new Runnable() {
        @Override
        public void run() {
            System.out.println("我爱北京天安门");
        }
    };
    r1.run();

    System.out.println("***********************");

    //使用Lambda表达式
    Runnable r2 = () -> {
        System.out.println("我爱北京故宫");
    };
    r2.run();
}

**语法格式二：**Lambda 需要一个参数，但是没有返回值。

@Test
public void test2() {
    //未使用Lambda表达式
    Consumer<String> con = new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    };
    con.accept("谎言和誓言的区别是什么？");

    System.out.println("*******************");

    //使用Lambda表达式
    Consumer<String> con1 = (String s) -> {
        System.out.println(s);
    };
    con1.accept("一个是听得人当真了，一个是说的人当真了");

}

**语法格式三：**数据类型可以省略，因为可由编译器推断得出，称为“类型推断”

@Test
public void test3() {
    Consumer<String> con1 = (String s) -> {
        System.out.println(s);
    };
    con1.accept("如果大学可以重来，你最想重来的事是啥？");

    System.out.println("*******************");

    Consumer<String> con2 = s -> {
        System.out.println(s);
    };
    con2.accept("谈一次轰轰烈烈的爱情");
}


@Test
public void test3_1() {
    int[] arr = {1, 2, 3, 4}; // 类型推断

    HashMap<String, Integer> map = new HashMap<>(); // 类型推断

    var entrySet = map.entrySet(); // 类型推断，在jdk10及以后可以用。
}

**语法格式四：**Lambda 若只需要一个参数时，参数的小括号可以省略

@Test
public void test4() {
    //语法格式四使用前
    Consumer<String> con1 = (s) -> {
        System.out.println(s);
    };
    con1.accept("世界那么大，我想去看看");

    System.out.println("*******************");
    //语法格式四使用后
    Consumer<String> con2 = s -> {
        System.out.println(s);
    };
    con2.accept("世界那么大，我想去看看");
}

**语法格式五：**Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值

@Test
public void test5() {
    //语法格式五使用前
    Comparator<Integer> com1 = new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        }
    };

    System.out.println(com1.compare(12, 21));
    System.out.println("*****************************");
    //语法格式五使用后
    Comparator<Integer> com2 = (o1, o2) -> {
        System.out.println(o1);
        System.out.println(o2);
        return o1.compareTo(o2);
    };

    System.out.println(com2.compare(12, 6));
}

**语法格式六：**当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略

@Test
public void test6() {
    //语法格式六使用前
    Comparator<Integer> com1 = (o1, o2) -> {
        return o1.compareTo(o2);
    };
    System.out.println(com1.compare(12, 6));

    System.out.println("*****************************");
    //语法格式六使用后
    Comparator<Integer> com2 = (o1, o2) -> o1.compareTo(o2);
    System.out.println(com2.compare(12, 21));
}


@Test
public void test7() {
    //语法格式六使用前
    Consumer<String> con1 = s -> {
        System.out.println(s);
    };
    con1.accept("一个是听得人当真了，一个是说的人当真了");
    
    System.out.println("*****************************");
    //语法格式六使用后
    Consumer<String> con2 = s -> System.out.println(s);
    con2.accept("一个是听得人当真了，一个是说的人当真了");

}

2、方法引用

2.1、说明

2.1.1、方法引用
  1. 举例：

Integer :: compare;

  1. 方法引用的理解

方法引用，可以看做是基于lambda表达式的进一步刻画。

当需要提供一个函数式接口的实例时，我们可以使用lambda表达式提供此实例。

当满足一定的条件的情况下，我们还可以使用方法引用或构造器引用替换lambda表达式。

  1. 方法引用的本质：

方法引用作为了函数式接口的实例。 —> “万事万物皆对象”

  1. 格式：

类(或对象) :: 方法名

  1. 具体使用情况说明：

情况1：对象 :: 实例方法

要求：函数式接口中的抽象方法a与其内部实现时调用的对象的某个方法b的形参列表和返回值类型都相同(或一致)。
此时，可以考虑使用方法b实现对方法a的替换、覆盖。此替换或覆盖即为方法引用。

注意：此方法b是非静态的方法，需要对象调用。

情况2：类 :: 静态方法

要求：函数式接口中的抽象方法a与其内部实现时调用的类的某个静态方法b的形参列表和返回值类型都相同(或一致)。
此时，可以考虑使用方法b实现对方法a的替换、覆盖。此替换或覆盖即为方法引用。

注意：此方法b是静态的方法，需要类调用。

情况3： 类 :: 实例方法

要求：函数式接口中的抽象方法a与其内部实现时调用的对象的某个方法b的返回值类型相同。
同时，抽象方法a中有n个参数，方法b中有n-1个参数，且抽象方法a的第1个参数作为方法b的调用者，且抽象方法a
的后n-1个参数与方法b的n-1个参数的类型相同(或一致)。则可以考虑使用方法b实现对方法a的替换、覆盖。此替换或覆盖即为方法引用。

注意：此方法b是非静态的方法，需要对象调用。但是形式上，写出对象a所属的类 （笔误，改为：写成对象所属的类）

2.1.2、构造器引用
  1. 构造器引用

1.1 格式：
类名 :: new

1.2 说明:

调用了类名对应的类中的某一个确定的构造器

具体调用的是类中的哪一个构造器呢？取决于函数式接口的抽象方法的形参列表

  1. 数组引用

格式：数组名[] :: new

2.2、使用前提

**要求1：**Lambda体只有一句语句，并且是通过调用一个对象的\类现有的方法来完成的

例如：System.out对象，调用println()方法来完成Lambda体

​ Math类，调用random()静态方法来完成Lambda体

要求2：

针对情况1：函数式接口中的抽象方法a在被重写时使用了某一个对象的方法b。如果方法a的形参列表、返回值类型与方法b的形参列表、返回值类型都相同，则我们可以使用方法b实现对方法a的重写、替换。

针对情况2：函数式接口中的抽象方法a在被重写时使用了某一个类的静态方法b。如果方法a的形参列表、返回值类型与方法b的形参列表、返回值类型都相同，则我们可以使用方法b实现对方法a的重写、替换。

针对情况3：函数式接口中的抽象方法a在被重写时使用了某一个对象的方法b。如果方法a的返回值类型与方法b的返回值类型相同，同时方法a的形参列表中有n个参数，方法b的形参列表有n-1个参数，且方法a的第1个参数作为方法b的调用者，且方法a的后n-1参数与方法b的n-1参数匹配（类型相同或满足多态场景也可以）

例如：t->System.out.println(t)

​ () -> Math.random() 都是无参

2.3、样例

**情况一：**对象 :: 实例方法

//Consumer中的void accept(T t)
//PrintStream中的void println(T t)
@Test
public void test1() {
    //1.
    Consumer<String> con1 = new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    };

    con1.accept("hello!");

    //2. lambda表达式
    Consumer<String> con2 = s -> System.out.println(s);
    con2.accept("hello!");

    //3. 方法引用
    Consumer<String> con3 = System.out::println;
    con3.accept("hello!");
}

//Supplier中的T get()
//Employee中的String getName()
@Test
public void test2() {
    Employee emp = new Employee(1001, "马化腾", 34, 6000.38);
    //1.
    Supplier<String> sup1 = new Supplier<String>() {
        @Override
        public String get() {
            return emp.getName();
        }
    };

    System.out.println(sup1.get());

    //2. lambda表达式
    Supplier<String> sup2 = () -> emp.getName();
    System.out.println(sup2.get());

    //3. 方法引用
    Supplier<String> sup3 = emp::getName;
    System.out.println(sup3.get());
}

**情况二：**类 :: 静态方法

//Comparator中的int compare(T t1,T t2)
//Integer中的int compare(T t1,T t2)
@Test
public void test3() {
    //1.
    Comparator<Integer> com1 = new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return Integer.compare(o1, o2);
        }
    };
    System.out.println(com1.compare(12, 21));

    //2. lambda表达式
    Comparator<Integer> com2 = (o1, o2) -> Integer.compare(o1, o2);
    System.out.println(com2.compare(21, 12));

    //3. 方法引用
    Comparator<Integer> com3 = Integer::compare;
    System.out.println(com3.compare(15, 15));
}

//Function中的R apply(T t)
//Math中的Long round(Double d)
@Test
public void test4() {
    //1.
    Function<Double, Long> fun1 = new Function<Double, Long>() {
        @Override
        public Long apply(Double aDouble) {
            return Math.round(aDouble);
        }
    };
    System.out.println(fun1.apply(12.5));

    //2. lambda表达式
    Function<Double, Long> fun2 = aDouble -> Math.round(aDouble);
    System.out.println(fun2.apply(15.5));

    //3. 方法引用
    Function<Double, Long> fun3 = Math::round;
    System.out.println(fun3.apply(18.8));
}

**情况三：**类 :: 实例方法 (有难度)

// Comparator中的int compare(T t1,T t2)
// String中的int t1.compareTo(t2)
@Test
public void test5() {
    //1.
    Comparator<String> com1 = new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            return o1.compareTo(o2);
        }
    };
    System.out.println(com1.compare("abc", "abd"));

    //2. lambda表达式
    Comparator<String> com2 = (o1, o2) -> o1.compareTo(o2);
    System.out.println(com2.compare("abd", "abc"));

    //3. 方法引用
    Comparator<String> com3 = String::compareTo;
    System.out.println(com3.compare("dasfsd", "dfsfdfasfd"));
}

//BiPredicate中的boolean test(T t1, T t2);
//String中的boolean t1.equals(t2)
@Test
public void test6() {
    //1.
    BiPredicate<String, String> biPre1 = new BiPredicate<String, String>() {
        @Override
        public boolean test(String s1, String s2) {
            return s1.equals(s2);
        }
    };
    System.out.println(biPre1.test("aaa", "bbb"));

    //2. lambda表达式
    BiPredicate<String, String> biPre2 = (s1, s2) -> s1.equals(s2);
    System.out.println(biPre2.test("aaa", "aaa"));

    //3. 方法引用
    BiPredicate<String, String> biPre3 = String::equals;
    System.out.println(biPre3.test("abc", "acd"));
}

// Function中的R apply(T t)
// Employee中的String getName();
@Test
public void test7() {
    Employee emp = new Employee(1001, "马化腾", 34, 6000.38);
    //1.
    Function<Employee, String> fun1 = new Function<Employee, String>() {
        @Override
        public String apply(Employee employee) {
            return employee.getName();
        }
    };
    System.out.println(fun1.apply(emp));

    //2. lambda表达式
    Function<Employee, String> fun2 = employee -> employee.getName();
    System.out.println(fun2.apply(emp));

    //3. 方法引用
    Function<Employee, String> fun3 = Employee::getName;
    System.out.println(fun3.apply(emp));
}

3、Stream API

3.1、说明

  1. Stream API vs 集合框架

Stream API 关注的是多个数据的计算（排序、查找、过滤、映射、遍历等），面向CPU的。集合关注的数据的存储，面向内存的。

Stream API 之于集合，类似于SQL之于数据表的查询。

  1. 使用说明

①Stream 自己不会存储元素。
②Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。即一旦执行终止操作，就执行中间操作链，并产生结果。
④ Stream一旦执行了终止操作，就不能再调用其它中间操作或终止操作了。

  1. Stream 执行流程

步骤1：Stream的实例化
步骤2：一系列的中间操作
步骤3：执行终止操作

3.1.1、什么是Stream API

Stream 是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。

Stream 和 Collection 集合的区别：**Collection 是一种静态的内存数据结构，讲的是数据，而 Stream 是有关计算的，讲的是计算。**前者是主要面向内存，存储在内存中，后者主要是面向 CPU，通过 CPU 实现计算。

注意：

①、Stream 自己不会存储元素。

②、Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。

③、Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。即一旦执行终止操作，就执行中间操作链，并产生结果。

④、 Stream一旦执行了终止操作，就不能再调用其它中间操作或终止操作了。

3.2、样例

3.2.1、创建Stream实例

方式一：通过集合

Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：

  • default Stream stream() : 返回一个顺序流
  • default Stream parallelStream() : 返回一个并行流
@Test
public void test01(){
    List<Integer> list = Arrays.asList(1,2,3,4,5);

    //JDK1.8中，Collection系列集合增加了方法
    Stream<Integer> stream = list.stream();
}

方式二：通过数组

Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：

  • static Stream stream(T[] array): 返回一个流
  • public static IntStream stream(int[] array)
  • public static LongStream stream(long[] array)
  • public static DoubleStream stream(double[] array)
@Test
public void test02(){
    String[] arr = {"hello","world"};
    Stream<String> stream = Arrays.stream(arr); 
}

@Test
public void test03(){
    int[] arr = {1,2,3,4,5};
    IntStream stream = Arrays.stream(arr);
}

方式三：通过Stream的of()

可以调用Stream类静态方法 of(), 通过显示值创建一个流。它可以接收任意数量的参数。

  • public static Stream of(T… values) : 返回一个流
@Test
public void test04(){
    Stream<Integer> stream = Stream.of(1,2,3,4,5);
    stream.forEach(System.out::println);
}

方式四：创建无限流

可以使用静态方法 Stream.iterate() 和 Stream.generate(), 创建无限流。

  • 迭代
    public static Stream iterate(final T seed, final UnaryOperator f)

  • 生成
    public static Stream generate(Supplier s)

@Test
public void test05() {
    // 迭代
    // public static<T> Stream<T> iterate(final T seed, final
    // UnaryOperator<T> f)
    Stream<Integer> stream = Stream.iterate(0, x -> x + 2);
    stream.limit(10).forEach(System.out::println);

    // 生成
    // public static<T> Stream<T> generate(Supplier<T> s)
    Stream<Double> stream1 = Stream.generate(Math::random);
    stream1.limit(10).forEach(System.out::println);
}

待更新…

Darling、达
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java8 新特性
06-17
java8的新特性，包含lambda表达式，stream流以及Optional和日期
java8新特性
11-08
本视频为java8新特性，百度云链接和密码，永久有效，失效联系我
Java的异常处理体系
落日的博客
06-28 866
ControllerAdvice 注解用于定义全局控制器建议，在 Spring MVC 中，控制器建议由控制器中的 @ExceptionHandler 方法、@InitBinder 方法和 @ModelAttribute 方法组成。①、CheckedException （检查异常 必须在代码中显式处理 使用try catch捕获 或者 在方法上使用 throws 抛出 除了RuntimeException及其子类以外，其他的Exception类及其子类都属于受检查异常 ）
Java 中的访问修饰符及其适用范围
liangzai215的专栏
06-25 475
public就像是开放的公园，对所有人开放。private好比你的私人日记，只有你能看。protected则是家庭相册，家人和继承者可以看到。而默认访问级别，则像是一扇未上锁的后门，只对同在一个包的“家人”开放。合理使用这些访问修饰符，可以帮助你构建更加安全、模块化和易于维护的代码。就像管理家中的物品一样，通过设置合适的访问权限，让每个部分各司其职，既保护了隐私，又促进了内部的合作与协调。
idea配置外置gradle
蔡定努
06-28 242
路径： /Users/caidingnu/save/gradle-8.5/init.d/ init.gradle。下载gradle包，解压。idea 配置文件修改。
Android10 SystemUI系列 需求定制（二）隐藏状态栏通知图标，锁屏通知，可定制包名，渠道等
fighting_2017的博客
06-25 116
SystemUI 所包含的界面和模块比较多，这一节主要分享一下状态栏通知图标和通知栏的定制需求：隐藏状态栏通知图标，锁屏通知，可定制包名，渠道等来熟悉一下Systemui。
性能评测系列：云架构扩展演进横向对比
luckcxy的专栏
06-26 391
性能评测系列：云架构扩展演进横向对比
计算机等级考试-Java考试大纲
weixin_54454406的博客
06-27 104
二级Java语言程序设计考试大纲。
multiprocessing.Queue 多个进程生产和多个进程消费怎么处理
qh0526wy的博客
06-24 265
在主进程中，我们创建了多个消费者和生产者进程，并将它们启动。生产者进程将数据放入队列，消费者进程从队列中取出数据并处理。生产者进程完成后，我们向队列发送。进行多个生产者和多个消费者的场景时，队列可以很好地协调这些进程。这个模式允许多个生产者并发地向队列中放入数据，同时多个消费者并发地从队列中取出并处理数据，直到所有生产者完成生产，消费者接收到结束信号。函数，分别用于从队列中获取数据和向队列中放入数据。来确保队列可以在多个进程之间共享。方法等待队列中的所有任务完成时很有用。在这个示例中，我们创建了一个队列。
分布式kettle调度管理平台简介
sharehoo的博客
06-28 504
分布式kettle调度管理系统，采用微服务前后端分离方式开发，前端采用vue2，页面美观，系统可扩展性强，兼容主流kettle版本，无入侵源码，实时支持升级版本。
RocketMQ快速入门：事务消息原理及实现（十）
最新发布
55555的博客
06-28 545
最后一句话总结一下，rocketmq的事务消息，是通过half消息（即二阶段提交）+回查机制来实现的。
面试-java多线程与并发
TOMORROW6COME的博客
06-23 298
进程是资源分配的最小单位，线程是CPU调度的最小单位。进程让操作系统的并发性成为可能，线程让进程的内部并发成为可能。Thread.start()创建子线程，再在子线程中调用Thread中实现好的run方法去执行相应的业务逻辑。源码中start使用start0()方法调用JVM_StartThread()方法。这里其实就是Thread.start()方法会创建出子线程！进程是抢占处理机的调度单位，线程属于某个进程，共享其资源。Runnable是个接口(只有个抽象的run方法)。start方法会创建新的线程。
一些使用 `DataSet` 的示例方法
jackfb2012的专栏
06-24 498
在现有代码的基础上，您可以添加一些使用 `DataSet` 的方法，作为 `LocalDataAccess` 类的 helper 方法。- 这个方法演示了如何使用 `DataSet` 和 `DataAdapter` 更新数据库的数据。该方法使用 `SQLiteCommandBuilder` 自动生成 `INSERT`、`UPDATE` 和 `DELETE` 命令，并将 `DataSet` 中的更改提交到数据库。每个表的数据保存在 `DataSet` 的不同 `DataTable` 中。
Mybatis
qq_62366797的博客
06-24 362
开启二级缓存之后，每个SQLSession进行查询动作时会先去二级缓存中看是否有，如果有就直接命中，如果没有则去看一级缓存中有没有，如果还没有就只能去数据库中查。首先Mybatis是提供了两级缓存的机制去提高数据的检索效率，避免每一次都去数据库中查数据。默认情况下是开启一级缓存(SqlSession级别的缓存，也称为本地缓存)，在一级缓存下，每个SQLSession都会把从数据库查询到的数据保存在自己的一级缓存中，当该SQLSession下次进行相同的查询时就可以直接走缓存而不用去数据库中查。
根据类上的注解信息生成创建表的SQL语句
沐雨橙风ιε的博客
06-28 102
定义一个实体类，在字段上使用knife4j的接口文档注解@ApiModelProperty注解指定字段名。
Java中如何处理ArrayIndexOutOfBoundsException异常？
weixin_44626980的博客
06-24 475
大家好，我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！在Java编程中，ArrayIndexOutOfBoundsException异常是一个经常出现的问题，特别是在处理数组时。本文将详细探讨ArrayIndexOutOfBoundsException异常的产生原因、如何预防以及如何通过正确的异常处理机制来处理这个异常。
第一百二十三节 Java面向对象的设计 - Java接口继承
2301_78772942的博客
06-24 1121
Java面向对象的设计 - Java接口继承
SpringCloud微服务框架的原理及应用详解（八）
凛鼕将至的博客
06-25 1171
​ Spring Cloud是一个基于Spring Boot实现的服务治理工具包，在微服务架构中用于管理和协调服务。它提供了一系列框架和组件，如服务发现、配置管理、熔断器、智能路由等，用于简化分布式系统的开发。Spring Cloud通过提供一系列开箱即用的组件和工具，帮助开发者快速构建和部署微服务架构的系统。 本文将跟随《SpringCloud微服务框架的原理及应用详解（七）》的进度，继续介绍Spring Cloud框架。希望通过本系列文章的学习，您将能够更好地理解Spring Cl
java 8 新特性
07-27
Java 8引入了许多令人兴奋的新特性，以下是其中一些： 1. Lambda表达式：Lambda表达式允许以更简洁的方式编写匿名函数，并且可以更方便地使用函数式编程风格。 2. 函数式接口：Java 8引入了函数式接口的概念，这是只包含一个抽象方法的接口。函数式接口可以与Lambda表达式一起使用，从而实现函数式编程。 3. Stream API：Stream API提供了一种新的处理集合数据的方式，使得我们可以更轻松地进行过滤、映射、排序等操作。 4. 默认方法：默认方法允许在接口中添加具有默认实现的方法。这样一来，当接口的实现类没有实现该方法时，就会使用默认方法。 5. 方法引用：方法引用提供了一种更简洁的方式来调用已经存在的方法。 6. Optional类：Optional类是一个容器对象，可以包含或不包含非空值。它可以避免空指针异常，并且可以简化对null值的处理。 7. 新的日期和时间API：Java 8引入了全新的日期和时间API，提供了更好的日期和时间处理方式，并且解决了旧API中的一些问题。 这些是Java 8引入的一些主要新特性，它们使得Java编程更加现代化和灵活。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值