JDK8简介-CSDN博客

本文链接：https://blog.csdn.net/qq_32089727/article/details/129555449

Java8引入了默认方法、静态方法和函数式接口，增强了接口的功能。Lambda表达式简化了代码，提供了匿名函数的能力。StreamAPI为集合操作提供了强大的工具，包括过滤、映射和聚合操作。新的日期时间API解决了旧版日期处理的痛点，提供了线程安全和易于使用的类。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Java 8由Oracle从2014年3月18日发布，此版本是自Java 5（发布于2004年）之后的一个重量级版本，也是java发展史上的一个里程碑式的版本。这个版本在JVM、编译器、库、Java语法特性等方面都做了很大改进，同时在语言的表达力、简洁性等个方面也有了很大的提高。目前几乎所有的JAVA框架也都已升级到支持JDK8

接口新特性

基于JDK8中接口新规范的定义，不仅可以扩展接口新功能（新的标准），还能保持接口向前兼容的特性

JDK8中对接口规范进行了新的定义，允许在接口中定义默认方法（使用default关键字修饰），静态方法，同时还推出了函数式接口（使用@FunctionInterface注解描述）设计。

default方法

JDK8中为了对接口业务进行扩展，但又不影响实现类，提供了默认方法。此类型的方法实用default关键字修饰，可以有方法体的实现。

一个接口中可以有多个默认方法，在实现类中可以有选择的对方法进行重写

interface IA{
    default void doMethod01() {
        System.out.println("doMethod01");
    }
    default void doMethod02() {
        System.out.println("doMethod02");
    }
}

static方法

interface IB{
    static void doMethod() {
        System.out.println("doMethod()");
    }
}

函数式接口

Java8引入了一个是函数式接口（Functional Interfaces），此接口使用@FunctionalInterface注解修饰，并且此接口内部只能包含一个抽象方法。

函数式接口推出的目的主要是为了配合后续Lambda表达式的应用。

@FunctionalInterface
public interface Comparator<T> {
   int compare(T o1, T o2);  // public abstract
}

消费型接口：接口中的方法只负责接收参数，不负责返回具体值(方法返回值类型是void)。

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}

函数式接口：接口方法不仅仅可以接收参数的输入，还可以给出一个具体的返回值

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}

判定式接口：基于你传入的参数，经过处理给出一个boolean类型的结果

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

供给式接口：方法不需要接收参数，只需要返回结果

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

Lambda 表达式

Java中的Lambda表达式是JDK8中的一种新特性，它允许我们将一段代码（这段代码可以理解为一个接口的实现）当成参数传递给某个方法，然后进行业务处理，这种方式更像是一种函数式编程风格，可以让代码结构更简洁，开发效率更高。

使用Lambda需要简化的是函数式接口(接口中只有一个抽象方法)

在lambda 表达式应用过程中，一般只有两个元素，其中“->” 将参数列表与函数主体分离，旨在对给定参数进行处理。函数的主体可能是一条或多条语句

(参数类型 变量) -> 代码块

无参无返回值一句方法体

() ->  System.out.print(“测试”);

一参无返回值一句方法体

arg ->  System.out.print(arg);

多参无返回值多句方法体

 (arg1, arg2, arg3) -> {  
    System.out.print(arg1);
    System.out.print(arg2);   
    System.out.print(arg3);
 }

多参有返回值一句方法体

(arg1, arg2, arg3) ->  arg1+arg2+arg3;

多参有返回值多句方法体

 (arg1, arg2, arg3) -> {  
    System.out.print(arg1);
    System.out.print(arg2);   
    System.out.print(arg3);
    return arg1+arg2+arg3;
 }

方法引用

方法引用是用来直接引用类方法、实例方法或者构造方法的一种新的方式。这里要特别强调一点的是“方法引用”提供的是一种对方法的引用而不是执行方法的方式，简单点理解的话就是可以将方法作为参数进行传递，我们还可以将方法引用理解为lambda的一种深层表达,是一种更简洁易懂的Lambda表达式，操作符是双冒号"::"，也可以将方法引用看成是一个更加紧凑，易读的Lambda表达式。

构造方法引：ClassName::new，应用默认构造函数。

        //Lambda方式
        Test<Object> s2=()->new Object();      
        
        //构造方法引用"类名::new"
        Test<Object> obj=Object::new;

类静态方法引用：ClassName::static_method

        //Lambda方式
        Test<Object> s2=(t)->Integer.parseInt(t);  
        
        //类方法引用应用方式"类名::方法名"
        Test<Object> obj=Integer::parseInt;

类实例方法引用：ClassName::method，方法不能带参数。

        //Lambda方式
        Test<File,String> s2=file->file.getAbsolutePath();
        
        //.类实例方法引用"类名::实例方法名"
        Test<File,String> obj=File::getAbsolutePath;

对象实例方法引用：对象实例::method，方法不能带参数。

 //Lambda方式
        Test<Object> s2=t->System.out.println(t);
        
        //类方法引用应用方式"类名::方法名"
        Test<Object> obj=System.out::println;

Stream

Stream 作为 Java 8 的一大亮点，它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念。Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作，或者大批量数据操作。

在当今这个数据爆炸的时代，数据来源多样化、数据海量化，很多时候不得不脱离 RDBMS，以底层返回的数据为基础进行更上层的数据统计。而原有 Java 的集合 API 中，仅仅有极少量的辅助型方法，更多的时候是程序员需要用 Iterator 来遍历集合，然后完成相关的聚合应用逻辑。这是一种远不够高效而且相对比较笨拙的方法。在JDK8中使用 Stream 对象，不仅丰富了在业务层面对数据处理的方式，还可以让代码更加简洁、易读和高效。

我们在使用Stream对象时，一般会按照如下为三个步骤进行操作：

第一步：创建Stream流对象。

第二步：Stream流中间操作。

第三步：Stream流终止操作。

List<Integer> list = Arrays.asList(3, 2, 12, 5, 6, 11, 13);
long count = list.stream()
                 .filter(i -> i % 2 == 0)
                 .count();
System.out.println(count);

Stream对象创建

借助Collection接口中的stream()或parallelStream（）方法

借助Arrays类中的stream(...)方法。

借助Stream类中的of(...)方法。

借助Stream类中的iterator和generator方法（无限操作）。

Stream中间操作

filter()：对数据进行过滤

limit()：限定操作

skip()：跳过操作

distinct()：去重操作

sorted()：排序操作，底层基于内部比较器Comparable或外部Comparator比较器进行比对。

map()：映射操作

Stream终止操作

match()

find()

count()

max()

min()

forEach()

Reduce()：计算集合中所有元素的和，其中第一个参数0为初始值，然后与后面每个值累加

Collector()

日期对象

在Java8之前，日期和时间的管理一直是令Java开发者很痛苦的一个的问题。java.util.Date、java.util.Calendar，SimpleDateFormat都一直没有很好解决这个问题。故此，Java8引入了一套全新的日期时间处理API，新的API基于ISO标准日历系统，解决了以前日期和时间类的很多弊端问题

jdk8之前的日期与字符串之间的转换通常会借助SimpleDateFormat对象，但是此对象线程不安全，通常要借助ThreadLocal对象，保证SimpleDateFormat对象每个线程一份。

Java8中的时间处理API定义在java.time包中，这些API具备不可变且线程安全特性,具备准确和灵活特性。所以现在基本可以使用这组API替换所有原有历史版本中时间API的应用。

Instant 时间戳对象：默认是0时区，比北京少8个时区。

//获取瞬时对象(当前时间年月日时分秒),Instant是绝对时间，没有时区的概念
Instant instant1 ==Instant.now();//Clock.systemUTC().instant();
//通过这种方式获取的时间戳与北京时间相差8个时区，需要修正为北京时间
instant1=instant1.plusMillis(TimeUnit.HOURS.toMillis(8));;
//输出系统可用时区
System.out.println(ZoneId.getAvailableZoneIds());
//输出系统默认时区
System.out.println(ZoneId.systemDefault());
//输出系统默认时区时间
System.out.println(Instant.now().atZone(ZoneId.systemDefault()));

//获取时间间隔。
Instant start = Instant.now();
Instant end = Instant.now();
Duration timeElapsed = Duration.between(start, end);
System.out.println("Milliseconds: " + timeElapsed.toMillis());

LocalDate 日期对象：不包含具体时间。

//当前年月日
LocalDate ld1=LocalDate.now();
//自定义年月日
LocalDate ld2 = LocalDate.of(2019, Month.JANUARY, 8);
//解析自定义年月日
LocalDate ld3=LocalDate.parse("2019-12-12");

LocalTime 时间对象：不包含日期。

//当前时分秒
LocalTime lt1=LocalTime.now();
//当前时区的时分秒
LocalTime lt2=LocalTime.now(ZoneId.systemDefault());
//两个时间差
long t=ChronoUnit.HOURS.between(lt1, lt2);

LocalDateTime ：包含了日期和时间对象，没有时区信息。

//年月日时分秒
LocalDateTime ldt02 = 
    LocalDateTime.of(2019, Month.DECEMBER, 31, 23, 59, 59);
//获取当前时间在这个星期哪一天        
DayOfWeek dayOfWeek = ldt02.getDayOfWeek();

ZoneDateTime ：包含时区的完整日期时间对象，偏移量以UTC时间为基准。

//当前时区的年月日时分秒
ZonedDateTime zdt01=ZonedDateTime.now();
//获取当前时区
ZoneId zd01=TimeZone.getDefault().toZoneId();