JDK8的特性

最新推荐文章于 2023-09-26 01:01:57 发布
最新推荐文章于 2023-09-26 01:01:57 发布
阅读量207 收藏 1
点赞数
文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/thillsoft/article/details/131252644
版权

JDK8的特性

 1. Lambda表达式
 2. 函数式接口
 3. 方法引用。
 4. Stream流
 5. 日期时间类

1.Lambda表达式

1.1 lambda的由来

/**
 * @Description:
 * @Author: Zhou
 * @CreateTime: 2023/6/13 16:07
 */
public class Test01 {
    public static void main(String[] args) {
        //开启一个线程 该构造函数需要传递一个Runnable类型的接口参数
        Thread thread = new Thread(new My());
        //开启线程
        thread.start();

        //匿名内部类
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("通过匿名内部类实现线程任务");
            }
        });
        //开启线程
        thread1.start();
    }
}
class My implements Runnable{

    @Override
    public void run() {
        System.out.println("使用实现类来完成线程任务");
    }
}

分析:

  1. Thread类需要一个Runnable接口作为参数，其中的抽象方法run方法是用来指定线程任务内容的核心方法，并且Runnable接口中有且只有一个抽象方法

  2. 为了指定run方法体，不得不需要Runnable的实现类

  3. 为了省去定义一个Runnable 的实现类，不得不使用匿名内部类

  4. 必须覆盖重写抽象的run方法，所有的方法名称，方法参数，方法返回值不得不都重写一遍，而且不能出错，

  5. 而实际上，我们只在乎方法体中的代码.

我们可以使用lambda表达式来完成上面的功能。

1.2 lambda表达式初体验

//lambda表达式
Runnable runnable = ()->{
    System.out.println("lambda表达式完成线程任务");
};
//将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
Thread thread2 = new Thread(runnable);
//开启线程
thread2.start();

1.3 lambda表达式的语法

lambda省去了面向对象的条条框框，lambda的标注格式有3个部分组成：

  • Lambda表达式的基础语法

  • Lambda是一个匿名函数 一般关注的是以下两个重点

  • 参数列表 方法体

  • 组成Lambda表达式的三要素：参数，箭头，代码块

  • (参数列表)->{}

  • ()：用来描述参数列表 如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可

  • ->: Lambda运算符 连接符 连接的是参数以及方法体

  • {}：用来描述方法体 有时可以省略

1.4 练习

  • Lambda表达式的使用前提 ①、有一个接口 ②、接口中有且仅有一个抽象方法

（1）抽象方法无参无返回值

/**
 * @Description:
 * @Author: Zhou
 * @CreateTime: 2023/6/13 17:04
 */
public class Test02 {
    public static void main(String[] args) {
        //主函数调用fun方法。第一种：创建UserService接口的实现类，并且创建该类的实现对象
        //创建UserServiceImpl的实现对象
        UserServiceImpl userService = new UserServiceImpl();
        userService.show();

        //第二种：匿名内部类的方式
        UserService userService1 = new UserService() {
            @Override
            public void show() {
                System.out.println("这是匿名内部类的show方法的实现");
            }
        };
        fun(userService1);

        //第三种：lambda表达式--该接口必须为函数式接口
        UserService userService2=()->{
            System.out.println("这是lambda表达式的show方法");
        };
        fun(userService2);
    }
    public static void fun(UserService userService){
        userService.show();
    }
}


@FunctionalInterface
interface UserService{
    /**
     * 函数式接口(FunctionalInterface)-->里面有且只有一个抽象方法。
     * 只有这种接口才能使用lambda表达式。
     */
    public void  show();
}
class UserServiceImpl implements UserService{
    @Override
    public void show() {
        System.out.println("这是USerService的实现类的show方法");
    }
}

（2）抽象方法有参有返回值

Collections 类是 Java 提供的一个操作 Set、List 和 Map 等集合的工具类。Collections 类提供了许多操作集合的静态方法，借助这些静态方法可以实现集合元素的排序、查找替换和复制等操作.

Collections 提供了如下方法用于对 List 集合元素进行排序。

  • void reverse(List list)：对指定 List 集合元素进行逆向排序。

  • void shuffle(List list)：对 List 集合元素进行随机排序（shuffle 方法模拟了“洗牌”动作）。

  • void sort(List list)：根据元素的自然顺序对指定 List 集合的元素按升序进行排序。

  • void sort(List list, Comparator c)：根据指定 Comparator 产生的顺序对 List 集合元素进行排序。

  • void swap(List list, int i, int j)：将指定 List 集合中的 i 处元素和 j 处元素进行交换。

  • void rotate(List list, int distance)：当 distance 为正数时，将 list 集合的后 distance 个元素“整体”移到前面；当 distance 为负数时，将 list 集合的前 distance 个元素“整体”移到后面。该方法不会改变集合的长度。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * @Description:
 * @Author: Zhou
 * @CreateTime: 2023/6/13 18:31
 */
public class Test03 {
    public static void main(String[] args) {
        List<Person> personList = new ArrayList<>();
        personList.add(new Person("张三",55));
        personList.add(new Person("李四",5));
        personList.add(new Person("王五",65));
        personList.add(new Person("赵六",15));
        personList.add(new Person("刘强",45));
        //对集合中的元素按照年龄排序，由小到大
        System.out.println(personList);
        //Collections:集合工具类，--匿名内部类
//        Comparator<Person> comparator = new Comparator<Person>() {
//            @Override//如果是0表示相同 大于0表示o1大于o2
//            public int compare(Person o1, Person o2) {
//                return o1.getAge()-o2.getAge();
//            }
//        };
//        Collections.sort(personList,comparator);
//        System.out.println(personList);
        //lambda表达式就是对函数式接口中的抽象方法的简写
        Collections.sort(personList,(o1, o2) -> {
            return o1.getAge()- o2.getAge();
        });
        System.out.println(personList);
    }
}
class Person{
    private String name;
    private Integer age;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Person() {
    }

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

（3）抽象方法有参无返回值

/**
 * @Description:
 * @Author: Zhou
 * @CreateTime: 2023/6/13 20:34
 */
public class Test04 {
    public static void main(String[] args) {
        //匿名内部类
        EmpService empService=new EmpService() {
            @Override
            public void eat(String food) {
                System.out.println("烧烤");
            }
        };
        fun(empService);
        //lambda表达式
        EmpService empService1=(f)->{
            System.out.println("爆炒鸡");
        };
        fun(empService1);
    }
    public static void fun(EmpService empService){
        empService.eat("龙虾");
    }
}
interface EmpService{
    public void eat(String food);
}

1.5 Lambda表达式的省略写法

在lambda表达式的标准写法基础上，可以使用省略写法规则为： ①、小括号内的参数类型可以省略。但是有多个参数的情况下，不能只省略一个 ②、如果小括号内有且仅有一个参数，那么小括号可以省略 ③、如果代码块的语句有且仅有一条，可以同时省略大括号、return关键字以及分号。

/**
 * @Description:
 * @Author: Zhou
 * @CreateTime: 2023/6/13 20:47
 */
public class Test05 {
    public static void main(String[] args) {
        Us u=a -> System.out.println("你好明天："+a);
        fun(u);
//        Us2 us2=a -> {return a*2;};
        //默认lambda表达式就会把最后一条语句作为返回结果。
//        Us2 us2=a -> a*2;
//        fun02(us2);
        fun02(a -> a*2);
    }
    public static void fun(Us us){
        us.show(15);
    }
    public static void fun02(Us2 us2){
        System.out.println(us2.print(25));
    }
}
interface Us{
    public void show(int a);
}
interface Us2{
    public int print(int a);
}

1.6 Lambda表达式使用的前提

 Lambda表达式的语法是非常简洁的，但是Lambda表达式不是随便使用的，使用时有几个条件要特别注意

  1. 方法的参数或局部变量类型必须为接口才能使用Lambda

  2. 接口中有且仅有一个抽象方法(@FunctionalInterface)

后面我们使用lambda表达式主要核心使用再Stream流中。

2.内置函数式接口

要想使用lambda表达式它的前提就是必须是函数式接口。

2.1 内置函数式接口的由来

/**
 * @Description:
 * @Author: Zhou
 * @CreateTime: 2023/6/14 14:04
 */
public class Test {
    public static void main(String[] args) {
        Operation o=arr -> {
            int sum=0;
            for (int s : arr) {
                sum+=s;
            }
            return sum;
        };
        fun(o);
    }
    public static void fun(Operation operation){
        int[] arr={1,2,3,4};
        int sum= operation.getSum(arr);
        System.out.println("数组的和："+sum);
    }
}
@FunctionalInterface
interface Operation
最低0.47元/天 解锁文章
点星辰
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
jdk8新特性
11-22
jdk8新特性，百度云盘。jdk8新特性，百度云盘。jdk8新特性，百度云盘。
JDK8新特性
扛麻袋的少年的博客
01-02 7237
1.Lambda表达式 JDK8以前，我们编写匿名内部类，看着很繁琐。 JDK8带来了Lambda表达式，编写代码更加简单，可以减少冗余代码。 参考：Lambda表达式 Lambda表达式原理分析 Lambda表达式----常用的内置函数式接口 ...
28.java中Java8.0的新特性（附讲解和练习）
Royalic的博客
08-04 1333
Java 8新特性简介 速度更快 代码更少(增加了新的语法： Lambda 表达式) 强大的 Stream API 便于并行 最大化减少空指针异常： Optional Nashorn引擎，允许在JVM上运行JS应用 Lambda表达式 Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。 函数式(Functional)接口 函数式(Funct
JDK8新特性介绍
偏偏爱吃梨的博客
10-23 1561
JDK8新特性介绍 JDK8新特性： ​ 1，Lambda表达式 ​ 2，新的日期API ​ 3，引入Optional ​ 4，使用Base64 ​ 5，接口的默认方法和静态方法 ​ 6，新增方法引用格式 ​ 7，新增Stream类 ​ 8，注解相关的改变 ​ 9，支持并行（parallel）数组 ​ 10，对并发类（Concurrency）的扩展。 1，Lambda表达式 Lambda 表...
JDK 8的下载、安装、配置【保姆级教程】
热门推荐
weixin_62222732的博客
06-05 4万+
(JDK) 是 Sun 公司（已被 Oracle 收购）针对 Java 开发员的软件开发工具包。自从 Java 推出以来，JDK 已经成为使用最广泛的 Java SDK（Software development kit）。
JDK8新特性（pdf版）
06-26
JDK8新特性 JDK8是Java开发平台的最新版本，自从1995年Java的诞生以来，Java已经发展了二十多年， Java仍是企业和开发人员的首选开发平台。JDK8新特性课程内容包括了解Java发展史、Lambda表达式、接口的增强、函数...
JDK8特性(Lambda表达式+StreamAPI简单示例代码)
04-02
JDK8特性(Lambda表达式+StreamAPI的简单使用示例代码)
jdk8新特性demo
01-15
JDK8是Java历史上的一个重要版本，引入了许多创新特性，极大地提升了Java的开发效率和代码可读性。本篇文章将详细探讨JDK8的三大关键新特性：Lambda表达式、方法引用来及Stream API。 一、Lambda表达式 Lambda...
jdk8新特性.md
04-15
jdk8相关特性使用的说明文档
一文详解JDK8常用10个更新特性
最新发布
规则中找出不规则，挫折中找出突破点
09-26 446
今日一语：当你发现编程的规律就是世界的规律时，你就是一名真正的程序员。
JDK8新特性详解
路在何方
04-12 534
目录 一. 1.lambda表达式 2.函数式接口 方法引用 构造器引用 数组引用 Stream API的引入 java8(jdk8)是java语言开发的一个主要版本，2014年3月发布，是JDK5以来最具革命性的版本 新特性简介： （1）速度更快 （2）代码更少 （3）Stream API (4)便于并行 （5）最大化减少空指针异常：Optional ...
JDK8新特性：
m0_49102053的博客
05-01 1352
java基础--jDK8新特性
Java-JDK8下载|安装|环境变量配置|详细图文教程【Windows10】
XiuyIiii的博客
07-23 1万+
Java开发程序员必备的开发环境——Java-JDK8
JDK8的新特性
huyulong0612的博客
07-21 5374
java8 的新特性
JDK8安装与环境配置
m0_69298879的博客
07-31 8171
在网上看了下JDK的安装与环境配置，发现很多视频以及博客的讲的都很复杂，对初学者很不友好。很多小白看到这些配置步骤都一脸懵，即使一步一步看着操作还是配置失败。这主要是因为很多博主配置了不需要的配置环境，让人觉得很复杂。其实只要配置一步就可以了，是的没错，只需要配置一个地方就可以了，那么下面让我们来看看如何配置。.........
JDK8新特性之Lambda表达式
cch970812的博客
06-13 505
我们知道使用Lambda表达式的前提是需要有函数式接口，而Lambda表达式使用时不关心接口名，抽象方法名。只关心抽象方法的参数列表和返回值类型。因此为了让我们使用Lambda表达式更加的方便，在JDK中提供了大量常用的函数式接口. 大多数无需自己再定义函数式接口，而可以直接使用jdk内置的函数式接口。Lambda表达式的语法是非常简洁的，但是Lambda表达式不是随便使用的，使用时有几个条件要特别注意。必须覆盖重写抽象的run方法，所有的方法名称，方法参数，方法返回值不得不都重写一遍，而且不能出错，
JDK8知识点梳理
初心不忘、始终方得
08-19 640
梳理jdk8新增API
Java基础（JDK8篇）
老苏的一日三浪
02-21 157
JDK8相关内容
java使用jdk8特性级联查询树代码
06-03
以下是一个简单的使用 JDK 8 特性进行级联查询树的例子： ```java public class TreeNode { private Long id; private Long parentId; private String name; private List<TreeNode> children = new ArrayList<>(); // 构造函数、getter 和 setter 方法省略 // 添加子节点 public void addChild(TreeNode node) { children.add(node); } // 获取子节点 public List<TreeNode> getChildren() { return children; } // 级联查询树 public static List<TreeNode> buildTree(List<TreeNode> nodes) { Map<Long, TreeNode> nodeMap = nodes.stream().collect(Collectors.toMap(TreeNode::getId, Function.identity())); List<TreeNode> rootNodes = new ArrayList<>(); for (TreeNode node : nodes) { Long parentId = node.getParentId(); if (parentId == null) { rootNodes.add(node); } else { TreeNode parent = nodeMap.get(parentId); parent.addChild(node); } } return rootNodes; } } ``` 使用上述代码，我们可以将一个节点列表转换为树形结构。例如，如果我们有以下节点列表： ```java List<TreeNode> nodes = Arrays.asList( new TreeNode(1L, null, "A"), new TreeNode(2L, 1L, "B"), new TreeNode(3L, 1L, "C"), new TreeNode(4L, 2L, "D"), new TreeNode(5L, 2L, "E"), new TreeNode(6L, 3L, "F") ); ``` 我们可以使用 `TreeNode.buildTree(nodes)` 方法将其转换为树形结构： ```java List<TreeNode> rootNodes = TreeNode.buildTree(nodes); System.out.println(rootNodes); ``` 输出结果为： ``` [TreeNode(id=1, parentId=null, name=A, children=[TreeNode(id=2, parentId=1, name=B, children=[TreeNode(id=4, parentId=2, name=D, children=[]), TreeNode(id=5, parentId=2, name=E, children=[])]) TreeNode(id=3, parentId=1, name=C, children=[TreeNode(id=6, parentId=3, name=F, children=[])])])] ``` 这个例子中，我们使用了 Java 8 的 Lambda 表达式和 Stream API 来简化代码。其中，`Collectors.toMap()` 方法将节点列表转换为一个以节点 ID 为键、节点对象为值的 Map，方便后续查找父节点。然后，我们遍历节点列表，将每个节点添加到其父节点的 `children` 列表中，最终返回所有根节点。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值