JDK8新特性

已于 2023-06-14 21:27:59 修改
阅读量97 收藏
点赞数 1
文章标签： java 开发语言
于 2023-06-05 18:01:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lhssy/article/details/131009341
版权

前言

众所周知，JDK8作为常用的开发LTS（Long Term Support）版本，深受各大企业的爱好，但是里面的一些新特性，常被使用却直戳心胸，so，了解新特性早已是刻不容缓。

Lambda表达式

lambda表达式的要素

  • 必须是接口
  • 接口内必须只有一个抽象方法或者该接口可以被@FunctionalInterface注解修饰

1.创建一个接口

package com.ssy.demo;

public interface MyInter {

    void action();

}

2.创建一个接口实现类

package com.ssy.demo;


public class MyInterImpl implements MyInter{
    @Override
    public void action() {
        System.out.println("武术散打······不败神话");
    }
}

3.测试demo

package com.ssy.demo;

public class JDK8 {

    public static void main(String[] args) {

        MyInterImpl myInter = new MyInterImpl();
        myInter.action();

    }

}

运行结果

res

Lambda的格式是

（类型 参数， 类型 参数，······）-> {
	······
}

现在以上述的为例展示Lambda的表达式demo

package com.ssy.demo;

public class JDK8 {

    public static void main(String[] args) {

        MyInter inter = ()->{
            System.out.println("Lambda表达式写出来的");
        };
        
        inter.action();

    }

}

运行结果

res

注意：

  • 如果接口的方法没有参数，那么Lambda表达式的小括号内没有数据
  • 如果接口的方法有且仅有一个参数，那么小括号可以省略也可以不省略
  • 如果只有方法体只有一条语句，可以不需要大括号
  • 如果是有返回值的方法且方法体的语句仅有一条而且还是返回值，要么不写大括号不写return不写分号，要么写大括号写return写分号

说白了Lambda就是匿名函数，仅此而已。

package com.ssy.demo;

public class JDK8 {

    public static void main(String[] args) {

        Demo demo = name -> name + "真好吃";
        String res = demo.eat("提拉米苏");
        System.out.println(res);
    }

}

interface Demo{

    String eat(String name);
}

运行结果

res

函数式接口

供给型接口Supplier

特点：无参有返回值

源码

res

测试Demo

res

消费型接口Consumer

特点：有参无返回值

源码

res

测试Demo

res

Function<T, R>接口

特点：有参有返回值

源码

res

测试Demo

res

断言Predicate接口

特点：有参返回值为boolean类型

源码

res

测试Demo

res

接口强化

JDK8之前接口里面只有公有静态常量和公有抽象方法，JDK新增了默认方法和公共静态方法

package com.ssy.demo;

public class JDK8 {

    public static void main(String[] args) {
        Ssy.myWorld();
        System.out.println("----------------------");
        Demo demo = new Demo();
        demo.action();
        System.out.println("----------------------");
        Ssy ssy = new Demo();
        ssy.action();
    }
}

interface Ssy{

    default void action(){
        System.out.println("动作事件");
    }

    static void myWorld(){
        System.out.println("我的世界······");
    }
}

class Demo implements Ssy{

    @Override
    public void action() {
        System.out.println("按钮左键点击动作");
    }
}

运行结果

res

默认方法与静态方法的区别
1.默认方法可以被继承，通过new对象调用
2.静态方法不能被继承，通过接口类名.方法名调用

方法引用

方法引用是用来直接访问类或者实例的已经存在的方法或者构造方法。方法引用提供了一种引用而不执行方法的方式,它需要由兼容的函数式接口构成的目标类型上下文。计算时，方法引用会创建函数式接口的一个实例。

注意方法引用是一个Lambda表达式，其中方法引用的操作符是双冒号"::"

package com.ssy.demo;

import java.util.function.Consumer;

public class JDK8 {

    public static void main(String[] args) {
        Consumer<String> demo = System.out::println;
        demo.accept("Hello Java");
    }
}

运行结果

res

对象名引用成员方法

对象名::方法名

package com.ssy.demo;

public class JDK8 {

    public static void main(String[] args) {
        Demo demo = System.out::println;
        demo.say("大家好，初来乍到，多多指教");
    }
}

interface Demo{

    void say(String text);

}

运行结果

res

类名引用静态方法

类名::静态方法

package com.ssy.demo;

public class JDK8 {

    public static void main(String[] args) {
       Demo<Boolean, String> demo = String::valueOf;
        System.out.println(demo.out(false).length());
    }
}

interface Demo<T,R>{

     R out(T val);

}

运行结果

res

类名引用实例方法

类名::成员方法名

package com.ssy.demo;

public class JDK8 {

    public static void main(String[] args) {
       Demo<String, Boolean> demo = String::isEmpty;
        System.out.println(demo.out("123"));
    }
}

interface Demo<T,R>{

     R out(T val);

}

运行结果

res

引用构造方法

类名::new

package com.ssy.demo;

public class JDK8 {

    public static void main(String[] args) {
        Demo<String,Bird> demo = Bird::new;
        Bird bird = demo.out("我是一只小小鸟");
        System.out.println(bird);
    }
}

interface Demo<T,R>{

     R out(T val);

}

class Bird{

    private String name;

    public Bird(String name){
        this.name = name;
    }

    @Override
    public String toString() {
        return "Bird{ name: " + name + "}";
    }
}

运行结果

res

Stream流

在使用集合相关的操作中，比如过滤、匹配、遍历、排序等操作时总是需要循环来遍历所有元素，从而来得到需要的结果，但我们更关注的是实现需求的逻辑，而不是如何循环。使用流操作更方便高效，流不是数据结构，只是在元数据集上定义了一组操作。

小demo1

package com.ssy.demo;

import java.util.ArrayList;
import java.util.List;

public class JDK8 {

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("250");
        list.add("110");
        list.add("100");
        list.add("120");
        list.add("99");

        list.stream().filter(s -> Integer.parseInt(s)>120).forEach(System.out::println);
    }
}

运行结果

res

小demo2

package com.ssy.demo;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class JDK8 {

    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();
        map.put("001",100);
        map.put("002",99);
        map.put("003",101);
        map.put("004",98);
        map.put("001",102);

        map.values().stream().forEach(System.out::println);
    }
}

运行结果

res

小demo3

package com.ssy.demo;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class JDK8 {

    public static void main(String[] args) {
        List<String> list = Stream.of("张三", "李四", "王五").collect(Collectors.toList());
        long count = list.stream().count();
        System.out.println(count);
    }
}

运行结果

res

小demo4

package com.ssy.demo;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class JDK8 {

    public static void main(String[] args) {
        List<String> list = Stream.of("张三", "李四", "王五","赵六","孙七","周八","刘九","孙十").collect(Collectors.toList());
        list.stream().limit(2).forEach(System.out::println);
    }
}

运行结果

res

小demo5

package com.ssy.demo;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class JDK8 {

    public static void main(String[] args) {
        List<String> list = Stream.of("张三", "李四", "王五","赵六","孙七","周八","刘九","孙十").collect(Collectors.toList());
        list.stream().skip(7).forEach(System.out::println);
    }
}

运行结果

res

小demo6

package com.ssy.demo;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class JDK8 {

    public static void main(String[] args) {
        List<String> list = Stream.of("1", "2", "3","4","5","6","7","8").collect(Collectors.toList());
        list.stream().map(s->Integer.parseInt(s)>5).forEach(System.out::println);
    }
}

运行结果

res

小demo7

package com.ssy.demo;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class JDK8 {

    public static void main(String[] args) {
        List<String> list = Stream.of("1111","2","33","444").collect(Collectors.toList());
        list.stream().sorted((a,b)->a.length()-b.length()).forEach(System.out::println);
    }
}

运行结果

res

小demo8

package com.ssy.demo;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class JDK8 {

    public static void main(String[] args) {
        List<String> list = Stream.of("111","2","2","111").collect(Collectors.toList());
        list.stream().distinct().forEach(System.out::println);
    }
}

运行结果

res

小demo9

package com.ssy.demo;

import java.util.ArrayList;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class JDK8 {

    public static void main(String[] args) {
        ArrayList<Integer> arr = Stream.of(1, 2, 3, 4, 5, 6).collect(Collectors.toCollection(ArrayList::new));
        arr.stream().forEach(System.out::println);
    }
}

运行结果

res

stream链式调用的时候注意终结点
res

时间和日期

JDK8之前用的是线程不安全的Calendar.getInstance对日期进行操作，JDK8推出了新的时间日期的API，且线程是安全的。

日期

package com.ssy.demo;

import java.time.LocalDate;

public class JDK8 {

    public static void main(String[] args) {
        LocalDate date = LocalDate.now();
        System.out.println("当前的日期是" + date);
        System.out.println("年：" + date.getYear());
        System.out.println("英文月：" + date.getMonth().toString().toLowerCase());
        System.out.println("月份值：" + date.getMonthValue());
        System.out.println("日：" + date.getDayOfMonth());
        LocalDate year = date.withYear(2000);
        System.out.println("修改之后的日期：" + year);
    }
}

运行结果

res

时间

package com.ssy.demo;

import java.time.LocalTime;

public class JDK8 {

    public static void main(String[] args) {
        LocalTime now = LocalTime.now();
        System.out.println(now);
        System.out.println(now.getHour());
        System.out.println(now.withHour(12));
    }
}

运行结果

res

日期时间

package com.ssy.demo;

import java.time.LocalDateTime;

public class JDK8 {

    public static void main(String[] args) {
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);
        System.out.println(now.getYear());
        System.out.println(now.withMonth(2));
    }
}

运行结果

res

格式化

package com.ssy.demo;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class JDK8 {

    public static void main(String[] args) {
        LocalDateTime now = LocalDateTime.now();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String s = now.format(formatter);
        System.out.println(s);
    }
}

运行结果

res

日期时间差

package com.ssy.demo;

import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.Period;

public class JDK8 {

    public static void main(String[] args) {
        LocalDate date = LocalDate.now();
        LocalDate dateEnd = LocalDate.of(2030, 10, 10);
        Period dpe = Period.between(date, dateEnd);
        System.out.println(dpe.getYears());

        LocalTime time = LocalTime.now();
        LocalTime timeEnd = LocalTime.of(22, 22, 22);
        Duration tdu = Duration.between(time, timeEnd);
        System.out.println(tdu.toHours());
    }
}

运行结果

res

时间校正器

package com.ssy.demo;

import java.time.*;
import java.time.temporal.TemporalAdjuster;
import java.time.temporal.TemporalAdjusters;

public class JDK8 {

    public static void main(String[] args) {
        LocalDateTime now = LocalDateTime.now();

        TemporalAdjuster t = temporal -> {
            LocalDateTime dateTime = (LocalDateTime) temporal;
            return dateTime.plusMonths(1).withDayOfMonth(1);
        };
        System.out.println(now.with(t));

        System.out.println(now.with(TemporalAdjusters.firstDayOfNextYear()));
    }
}

运行结果

res

重复注解和类型注解

重复注解

JDK5出现了注解，但是不能在一个类、方法、字段上出现重复的注解，JDK8很好的解决了这个问题。
前提：需要一个注解容器和一个注解内容，注解内容上的@Repeatable用来指定重复注解的容器，getAnnotationByType获取定义的所有的重复的注解。

package com.ssy.demo;

import java.lang.annotation.*;

public class JDK8 {

    public static void main(String[] args) {
        Demo[] demos = Test.class.getAnnotationsByType(Demo.class);
        for (Demo demo : demos) {
            System.out.println(demo.value());
        }
    }
}

@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnno{
    Demo[] value() default {};
}

@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(MyAnno.class)
@interface Demo{
    String value() default "";
}

@Demo("张三")
@Demo("李浩")
class Test{

}

运行结果

res

类型注解

JDK8在@Target中新出现了TYPE_USE（表示注解可以写在任何用到类型的地方）、TYPE_PARAMETER（表示该注解能写在类型参数的声明语句中，也就是泛型）两个枚举变量

res

lopaco
关注
jdk8的新特性
weixin_64035205的博客
09-20 136
1.内部类. 2.lambda表达式 3.stream流(补充)4.链式编程 5.泛型 6.Optional对象判空
Java 8的新特性—终极版
热门推荐
飞鸟Blog
03-15 14万+
前言： Java 8 已经发布很久了，很多报道表明Java 8 是一次重大的版本升级。在Java Code Geeks上已经有很多介绍Java 8新特性的文章，例如Playing with Java 8 – Lambdas and Concurrency、Java 8 Date Time API Tutorial : LocalDateTime和Abstract Class Versus
JDK 8 有哪些新特性?
最新发布
Alfred_tfk的博客
08-13 545
使用它可以写出更简洁、更灵活的代码。新 AP|提供了专门的时区类(如 zonedDateTime，offsetDateTime，zoneId 等)，简化了时区处理，并且这些类的方法更加直观和易用。而新的日期类都是不可变的，一旦创建就不能修改这样可以避免意外的修改，提升代码的安全性和可维护性。之所以提供静态方法，是为了将相关的方法内聚在接口中，而不必创建新的对象。Java8引入了新的日期和时间 API(位于 java.time 包中)，它们更加简洁和易于使用，解决了旧版日期时间 API 的许多问题。
JAVA8新特性
地平线的专栏
03-31 4442
一、接口的默认方法 Java 8允许我们给接口添加一个非抽象的方法实现，只需要使用 default关键字即可，这个特征又叫做扩展方法，示例如下： 复制代码 代码如下: interface Formula {     double calculate(int a);     default double sqrt(int a) {         return Math.sqrt
JDK8 之新特性
TU_BO的博客
08-10 294
一:速度快 二:代码少(引入了Lambda表达式) Lambda是一个匿名函数,lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。 lambda表达式的几种写法 (1)一个参数 三:引入了Stream API 四:便于并行 五:减少了空指针异常...
Java.JDK8新特性
springxing的博客
07-20 375
lambda表达式是针对接口的，有且仅有一个抽象方法，这种接口称为函数接口。lambda表达式使用时不关心接口名，抽象方法名，只关心抽象方法的参数列表和返回类型。这些函数接口都在java.util.function包下，常用接口有supplier接口，function接口，consumer接口，predicate接口。方法引用是一种更简洁的lambda表达式，如果一个lambda表达式的方法体只是在调用一个方法时，就可以使用方法引用来简化他。consumer表示消费的意思，这类接口的特点是有参无返回值。..
JDK8新特性（pdf版）
06-26
JDK8新特性 JDK8是Java开发平台的最新版本，自从1995年Java的诞生以来，Java已经发展了二十多年， Java仍是企业和开发人员的首选开发平台。JDK8新特性课程内容包括了解Java发展史、Lambda表达式、接口的增强、函数...
jdk8新特性
11-22
jdk8新特性，百度云盘。jdk8新特性，百度云盘。jdk8新特性，百度云盘。
jdk8新特性.md
12-03
jdk8新特性.md
JDK8新特性之判空遍历写法
08-25
JDK8 新特性之判空遍历写法 JDK 8 中引入了 Optional 类，用于避免 NullPointerException，它提供了一种更加简洁和优雅的方式来处理空值。Optional 类实际上是一个容器，可以保存类型 T 的值，或者仅仅保存 null。 ...
Java基础 - 第十一章 - JDK8新特性
SongYu的博客
08-29 1万+
新特性 一、Java8新特性 1.Lambda表达式 Lambda表达式的使用 1.举例： (o1,o2) -> Integer.compare(o1,o2); 2.格式： -> :lambda操作符 或 箭头操作符 ->左边：lambda形参列表 （其实就是接口中的抽象方法的形参列表） ->右边：lambda体 （其实就是重写的抽象方法的方法体） 3.Lambda表达式的使用：（分为6种情况介绍） 总结： ->左边：lambda形参
[转]看看 JDK 8 给我们带来什么
Hello World
01-15 502
世界正在缓慢而稳步的改变。这次改变给我们带来了一个新模样的JDK7，java社区也在一直期盼着在JDK8，也许是JDK9中出现一些其他的改进。JDK8的改进目标是填补JDK7实现中的一些空白——部分计划蓝图将被实现，在2013年里，从三个特殊方面提升和优化这门语言： 开发效率 性能 模块化 缪斯的情人翻译于 8天前 2人顶   顶 翻译的...
JDK8-新特性
佬叁
11-01 422
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 jdk8主要...
jdk8 新特性
dongxiexie的博客
07-12 111
接口default关键字 default 方法,已经有默认的实现体，可以在子类中不必实现。 public interface UserService { int updatePerson(); /** * @description default 方法,已经有默认的实现体，可以在子类中不必实现。 * @return int * @auth...
Lambda表达式与JDK8新特性详解
本资源主要讨论了JDK 8的新特性，特别是Lambda表达式、函数式编程思想以及Stream流的相关内容。首先，介绍了OpenJDK和Oracle JDK的关系，指出OpenJDK是Sun公司在2006年Java平台开源后的产物，由Java社区支持，而...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值