java8新特性【2023】

news2024/9/29 18:41:31

Lambda表达式

新的一套语法规则
是一个匿名函数

@Test
    public void test1(){
        Runnable r1 = new Runnable(){
            @Override
            public void run() {
                System.out.println("线程A");
            }
        };
        r1.run();
        System.out.println("====================");
        Runnable r2 = () -> System.out.println("线程B");
        r2.run();
    }

在这里插入图片描述

 public void test2(){
        //比大小
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        int i = com1.compare(15, 12);
        System.out.println(i);
        System.out.println("=======================");
        //比大小
        //函数式接口只有一个方法，就无需知道具体是哪个方法
        Comparator<Integer> com2 = (o1,o2) ->Integer.compare(o1,o2);
        int ii = com1.compare(15, 19);
        System.out.println(ii);

    }

在这里插入图片描述

方法引用

//比大小
        //函数式接口只有一个方法，就无需知道具体是哪个方法
        System.out.println("=======================");
        Comparator<Integer> com3 = Integer::compare;
        int iii = com1.compare(15, 15);
        System.out.println(iii);

在这里插入图片描述

格式【Lambda表达式的使用】分为8种

本质：作为接口的一个实例

public class LambdaTest1 {
    //11111无参无返回值的
    @Test
    public void test1(){
        Runnable r1 = new Runnable(){
            @Override
            public void run() {
                System.out.println("线程A");
            }
        };
        r1.run();
        System.out.println("====================");
        Runnable r2 = () -> System.out.println("线程B");
        r2.run();
    }
    @Test
    public void test2() {
        //222222222222一个参数，但没有返回值
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("消费者");
        System.out.println("========================");
        //lambda的写法
        Consumer<String> conn = (String s) ->System.out.println(s);
        conn.accept("消费者11");
    }
    //33333333333数据类型可以省略，因为可以由编译器推断出来，称为"类型推断"
    @Test
    public void test3() {
        System.out.println("========================");
        //lambda的写法
        Consumer<String> conn1 = (s) ->System.out.println(s);
        conn1.accept("消费者22");
    }
    //444444444444444444若只需要一个参数时，参数的小括号可以省略
    @Test
    public void test4() {
        System.out.println("========================");
        //lambda的写法
        Consumer<String> conn1 = s ->System.out.println(s);
        conn1.accept("消费者33");
    }
    //555555555555555555555两个或以上的参数，多条执行行语句，并且可以有返回值
    @Test
    public void test5() {
        //lambda的写法
        //比大小
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        System.out.println("===========================");
        //比大小
        Comparator<Integer> com2 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }
        }; //比大小
        //66666666666
        System.out.println(com2.compare(15, 16));

        Comparator<Integer> com3 = (o1,o2) ->{
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        System.out.println(com3.compare(18, 12));
    }
    //7lambda只有一条语句，{}可以省略
}

在这里插入图片描述

函数式接口

只声明了一个抽样方法，则此接口就称为函数式接口
java四大核心函数式接口
Consumer<T>：不返
Supplier<T>：不给也返
Function<T,R>R apply(T t)
Predicate<T>:boolean test(T t)

方法引用与构造器引用

StreamAPI

对内存层面的多个数据，实现过滤，排序
可以对集合的数据进行操作，类似于sql执行的数据库查询
Stream操作三个步骤：创建----中间操作-------终止操作
创建：一个数据【如集合、数组】，获取一个流
中间操作：一个中间操作链，对数据源的数据进行处理
终止操作：一旦执行终止操作，就会执行中间操作链，并产生结果，之后不会被使用

创建Stream的方式

通过集合：
通过数组：

排序

自然排序：

 List<Integer> list = Arrays.asList(12, 43, 65, 34, 87, 0, -98, 7);
        list.stream().sorted().forEach(System.out::println);

定制排序：

List<Employee> employees = EmployeeData.getEmployees();
        employees.stream().sorted((e1, e2) -> {
            int ageValue = Integer.compare(e1.getAge(), e2.getAge());
            if (ageValue != 0) {
                return ageValue;
            } else {
                // 年龄相同，按工资从小到大排序
                return Double.compare(e1.getSalary(), e2.getSalary());
                // 年龄相同，按工资从大到小排序
                // return -Double.compare(e1.getSalary(), e2.getSalary());
            }
        }).forEach(System.out::println);

创建无限流

   Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);

  Stream.generate(Math::random).limit(10).forEach(System.out::println);

筛选与切片

筛选

  Stream<Employee> stream = list.stream();
        // 练习：查询员工表中薪资大于 7000 的员工信息
        stream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);

 // 1-筛选与切片
    @Test
    public void test5() {
        List<Employee> list = EmployeeData.getEmployees();
        // filter(Predicate p)-接收 Lambda，从流中排除某些元素。
        Stream<Employee> stream = list.stream();
        // 练习：查询员工表中薪资大于 7000 的员工信息
        stream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);
        // Employee{id=1002, name='马云', age=12, salary=9876.12}
        // Employee{id=1004, name='雷军', age=26, salary=7657.37}
        // Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}

        System.out.println();

        // limit(n)-截断流，使其元素不超过给定数量。
        // stream.limit(3).forEach(System.out::println);//closed已经关闭，需要重新生成
        list.stream().limit(3).forEach(System.out::println);
        // Employee{id=1001, name='马化腾', age=34, salary=6000.38}
        // Employee{id=1002, name='马云', age=12, salary=9876.12}
        // Employee{id=1003, name='刘强东', age=33, salary=3000.82}

        System.out.println();

        // skip(n)-跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则
        list.stream().skip(3).forEach(System.out::println);
        // Employee{id=1004, name='雷军', age=26, salary=7657.37}
        // Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
        // Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
        // Employee{id=1007, name='任正非', age=26, salary=4333.32}
        // Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}

        System.out.println();

        // distinct()-筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
        list.add(new Employee(1010, "刘强东", 40, 8000));
        list.add(new Employee(1010, "刘强东", 42, 8000));
        list.add(new Employee(1010, "刘强东", 40, 8000));
        list.add(new Employee(1010, "刘强东", 40, 8000));
        list.add(new Employee(1010, "刘强东", 40, 8000));

        // System.out.println(list);
        // [Employee{id=1001, name='马化腾', age=34, salary=6000.38}, Employee{id=1002, name='马云', age=12, salary=9876.12},
        // Employee{id=1003, name='刘强东', age=33, salary=3000.82}, Employee{id=1004, name='雷军', age=26, salary=7657.37},
        // Employee{id=1005, name='李彦宏', age=65, salary=5555.32}, Employee{id=1006, name='比尔盖茨', age=42,
        // salary=9500.43}, Employee{id=1007, name='任正非', age=26, salary=4333.32}, Employee{id=1008, name='扎克伯格',
        // age=35, salary=2500.32}, Employee{id=1010, name='刘强东', age=40, salary=8000.0}, Employee{id=1010, name='刘强东',
        // age=42, salary=8000.0}, Employee{id=1010, name='刘强东', age=40, salary=8000.0}, Employee{id=1010, name='刘强东',
        // age=40, salary=8000.0}, Employee{id=1010, name='刘强东', age=40, salary=8000.0}]

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

        list.stream().distinct().forEach(System.out::println);
        // Employee{id=1001, name='马化腾', age=34, salary=6000.38}
        // Employee{id=1002, name='马云', age=12, salary=9876.12}
        // Employee{id=1003, name='刘强东', age=33, salary=3000.82}
        // Employee{id=1004, name='雷军', age=26, salary=7657.37}
        // Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
        // Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
        // Employee{id=1007, name='任正非', age=26, salary=4333.32}
        // Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}
        // Employee{id=1010, name='刘强东', age=40, salary=8000.0}
        // Employee{id=1010, name='刘强东', age=42, salary=8000.0}
    }

去重

 list.stream().distinct().forEach(System.out::println);

映射

小写变大写

  List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
        list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);

Stream终止操作

输出结果forEach(System.out::println)；

Stream的终止操作：匹配与查询

匹配所有

 @Test
    public void test9(){
        List<Employee> employees = EmployeeData.getEmployees();
        boolean allMatch = employees.stream().allMatch(e->e.getAge()>18);
        System.out.println(allMatch);
    }

在这里插入图片描述
有一个匹配就可以

 List<Employee> employees1 = EmployeeData.getEmployees();
        boolean allMatch1 = employees1.stream().anyMatch(e->e.getAge()>18);
        System.out.println(allMatch1);

在这里插入图片描述

求个数

最大值

最小值

并行流

把一个内容分成多个数据模块，并用不同的线程分别处理每个数据块的流，相比较串行流，并行流可以很大层度上提高程序的执行效率

Optional类

最大化的减少空指针异常

新的时间日期API

其他特性

学习过程全部操作

public class LambdaTest2 {
    // 创建 Stream 方式一：通过集合
    @Test
    public void test1() {
        List<Employee> employees = EmployeeData.getEmployees();

        // default Stream<E> stream():返回一个顺序流
        Stream<Employee> stream = employees.stream();

        // default Stream<E> parallelStream():返回一个并行流
        Stream<Employee> parallelStream = employees.parallelStream();
    }

    // 创建 Stream 方式二：通过数组
    @Test
    public void test2() {
        int[] arr = new int[] {1, 2, 3, 4, 5, 6};
        // 调用 Arrays 类的 static <T> Stream<T> stream(T[] array): 返回一个流
        IntStream stream = Arrays.stream(arr);
        Employee e1 = new Employee(1001, "Tom");
        Employee e2 = new Employee(1002, "Jerry");
        Employee[] arr1 = new Employee[] {e1, e2};
        Stream<Employee> stream1 = Arrays.stream(arr1);
    }
    // 创建 Stream 方式三：通过 Stream 的 of()
    @Test
    public void test3() {
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
    }
    // 创建 Stream 方式四：创建无限流
    @Test
    public void test4() {
        // 迭代
        // public static<T> Stream<T> iterate(final T seed,final UnaryOperator<T> f)
        // 遍历前 10 个偶数
        Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);
        // 生成
        // public static<T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }

    // 1-筛选与切片
    @Test
    public void test5() {
        List<Employee> list = EmployeeData.getEmployees();
        // filter(Predicate p)-接收 Lambda，从流中排除某些元素。
        Stream<Employee> stream = list.stream();
        // 练习：查询员工表中薪资大于 7000 的员工信息
        stream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);
        // Employee{id=1002, name='马云', age=12, salary=9876.12}
        // Employee{id=1004, name='雷军', age=26, salary=7657.37}
        // Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}

        System.out.println("1");

        // limit(n)-截断流，使其元素不超过给定数量。
        // stream.limit(3).forEach(System.out::println);//closed已经关闭，需要重新生成
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("/2");

        // skip(n)-跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则
        list.stream().skip(3).forEach(System.out::println);
        System.out.println();

        // distinct()-筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
        list.add(new Employee(1010, "刘强东", 40, 8000));
        list.add(new Employee(1010, "刘强东", 42, 8000));
        list.add(new Employee(1010, "刘强东", 40, 8000));
        list.add(new Employee(1010, "刘强东", 40, 8000));
        list.add(new Employee(1010, "刘强东", 40, 8000));
        System.out.println("=================");

        list.stream().distinct().forEach(System.out::println);
    }

    // 映射
    @Test
    public void test6() {
        // map(Function f)-接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，并将其映射成一个新的元素。
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
        list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
        System.out.println("===--=-=-==0-");
        // 练习1：获取员工姓名长度大于 3 的员工的姓名。
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<String> namesStream = employees.stream().map(Employee::getName);
        namesStream.filter(name -> name.length() > 3).forEach(System.out::println);
        System.out.println();
        // 练习2：
        Stream<Stream<Character>> streamStream = list.stream().map(LambdaTest2::fromStringToStream);
        streamStream.forEach(s -> {
            s.forEach(System.out::println);
        });
        System.out.println();

        // 集合里面套集合的方式，遍历优先使用 flatMap 方式
        // flatMap(Function f)-接受一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
        Stream<Character> characterStream = list.stream().flatMap(LambdaTest2::fromStringToStream);
        characterStream.forEach(System.out::println);
        // a
        // a
        // b
        // b
        // c
        // c
        // d
        // d
    }

    // 将字符串中的多个字符构成的集合转换为对应的 Stream 的实例
    public static Stream<Character> fromStringToStream(String str) {// a
        ArrayList<Character> list = new ArrayList<>();
        for (Character c : str.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    }

    @Test
    public void test7() {
        ArrayList list1 = new ArrayList();
        list1.add(1);
        list1.add(2);
        list1.add(3);

        ArrayList list2 = new ArrayList();
        list2.add(4);
        list2.add(5);
        list2.add(6);
        list1.addAll(list2);
        System.out.println(list1);
    }

    // 3-排序
    @Test
    public void test8() {
        // sorted()-自然排序
        List<Integer> list = Arrays.asList(12, 43, 65, 34, 87, 0, -98, 7);
        list.stream().sorted().forEach(System.out::println);
        List<Employee> employees = EmployeeData.getEmployees();
        employees.stream().sorted((e1, e2) -> {
            int ageValue = Integer.compare(e1.getAge(), e2.getAge());
            if (ageValue != 0) {
                return ageValue;
            } else {
                // 年龄相同，按工资从小到大排序
                return Double.compare(e1.getSalary(), e2.getSalary());
                // 年龄相同，按工资从大到小排序
                // return -Double.compare(e1.getSalary(), e2.getSalary());
            }
        }).forEach(System.out::println);

    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/353186.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

linux 安装rabbitmq 文档

linux 安装rabbitmq 文档

1、下载rabbitMQ https://github.com/rabbitmq/rabbitmq-server/releases/tag/v3.9.15对应的erlang https://packagecloud.io/app/rabbitmq/erlang/search?distel%2F7https://packagecloud.io/rabbitmq/erlang/packages/el/7/erlang-23.3.4.11-1.el7.x86_64.rpm?distro_ver…
阅读更多...
Mysql | Error Code: 1153 - Got a packet bigger than ‘max_allowed_packet‘ bytes

Mysql | Error Code: 1153 - Got a packet bigger than ‘max_allowed_packet‘ bytes

描述 在执行sql语句插入的时候&#xff0c;报出了Error Code: 1153 - Got a packet bigger than ‘max_allowed_packet’ bytes 错误 解决方法 &#x1f6a9; 临时调整&#xff0c;重启后失效 1️⃣ 查询默认的max_allowed_packet值大小 执行语句&#xff1a; SHOW VARIABLE…
阅读更多...
[Android Studio] Android Studio Virtual Device虚拟机的功能试用

[Android Studio] Android Studio Virtual Device虚拟机的功能试用

&#x1f7e7;&#x1f7e8;&#x1f7e9;&#x1f7e6;&#x1f7ea; Android Debug&#x1f7e7;&#x1f7e8;&#x1f7e9;&#x1f7e6;&#x1f7ea; Topic 发布安卓学习过程中遇到问题解决过程&#xff0c;希望我的解决方案可以对小伙伴们有帮助。 &#x1f680;write…
阅读更多...
JS：构造函数和原型

JS：构造函数和原型

目录 1.构造函数和原型 1.1 概述 1.2 构造函数 1.2.1创建 1.2.2 静态成员和实例成员 1.3 构造函数原型 prototype 1.4 对象原型_proto_ 1.5 constructor 构造函数 1.6 构造函数、实例、原型对象的关系 1.7 原型链 2. 继承 2.1 call() 1.构造函数和原型 1.1 概述 在…
阅读更多...
OpenStack

OpenStack

名词解释RAM 身份验证管理SDN 软件定义网络虚拟化为什么openstack清一色的KVM&#xff1f;KVM属于redhat&#xff0c;开源可定制nentron实现SDNSDN实现了东西向流量管理&#xff08;VPC与VPC的流量管理&#xff09;SDNVXLan实现隧道网络&#xff08;对等连接&#xff09;SDN在公…
阅读更多...
【郭东白架构课 模块一：生存法则】04｜法则二：架构师为什么要学习马斯洛的需求理论？

【郭东白架构课 模块一：生存法则】04｜法则二：架构师为什么要学习马斯洛的需求理论？

你好&#xff0c;我是郭东白&#xff0c;今天我们来聊聊架构师的第二个生存法则&#xff1a;架构活动需要尊重和顺应人性。 自从学习计算机专业的那一天起&#xff0c;我们似乎就走入了一个简单直接的机器世界&#xff0c;一个完全靠逻辑和数字主宰的世界。于是我们总不自觉地认…
阅读更多...
如何将数据库结构导入到word

如何将数据库结构导入到word

在navicat执行查询语句 SELECT COLUMN_NAME 备注, COLUMN_COMMENT 名称, COLUMN_TYPE 数据类型, false as 是键 FROM INFORMATION_SCHEMA.COLUMNS where -- wx 为数据库名称&#xff0c;到时候只需要修改成你要导出表结构的数据库即可 table_schema yuncourt_ai AND -- articl…
阅读更多...
蓝库云｜制造业数字化转型为何转不动？资料处理很重要

蓝库云｜制造业数字化转型为何转不动？资料处理很重要

数字化转型已经成为每个产业势在必行的课题&#xff0c;没有人会怀疑数字化技术与科技能解放的生产力能量&#xff0c;但为什么看似美好的愿景&#xff0c;实行起来却如此缓慢&#xff1f;蓝库云认为这是因为没有盖好「资料治理」的地基。 面对不断变化的法令规范要求&#xf…
阅读更多...
＜＜Java开发环境配置＞＞7-Apache Tomcat安装教程环境变量配置IDEA配置

＜＜Java开发环境配置＞＞7-Apache Tomcat安装教程环境变量配置IDEA配置

一.Apache Tomcat简介: Apache是普通服务器&#xff0c;本身只支持html即普通网页。不仅可以通过插件支持php,还可以与Tomcat连通(单向Apache连接Tomcat,就是说通过Apache可以访问Tomcat资源。反之不然)。Apache只支持静态网页&#xff0c;但像php,cgi,jsp等动态网页就需要Tomc…
阅读更多...
无需端口映射，快解析外网访问U8C

无需端口映射，快解析外网访问U8C

U8C是用友针对成长型、创新型企业&#xff0c;提供企业级ERP整体解决方案&#xff0c;支持多组织业务协同、营销创新、智能财务、人力服务&#xff0c;构建产业链制造平台&#xff0c;实现企业互联网资源连接、共享、协同。 在系统实施过程中&#xff0c;多数企业想要自主掌握企…
阅读更多...
分支管理方案

分支管理方案

背景 在工作的过程中&#xff0c;git管理方式已经成为每一个项目开发的基础&#xff0c;每个项目的开发都离不开git管理方式。 但是在使用的过程中&#xff0c;由于对git分支管理方案的了解不深&#xff0c;导致会出现分支管理不明确的情况。 本文主要是做科普作用&#xff…
阅读更多...
c++类与对象

c++类与对象

1.类的定义 2.类的构造函数 1.函数名与类名相同 2.无返回值 3.对象实例化时编译器会自己调用构造函数 4.构造函数可以重载 5.没有显示定义时&#xff0c;编译器会自动调用一个无参的默认构造函数&#xff0c;一旦写显示则不生成 6.对于内置类型构造函数不做处理&#xff0c;对于…
阅读更多...
麒麟 arm架构安装nginx

麒麟 arm架构安装nginx

目录 1、下载nginx安装包并解压 在线安装&#xff1a; 离线安装&#xff1a; 上传nginx安装包&#xff08;下载地址&#xff1a;https://nginx.org/download/nginx-1.20.2.tar.gz&#xff09;到指定目录 2、安装系统相关依赖软件、组件包 1、上传或者下载对应的组件包 2、安…
阅读更多...
SQL 中的窗口函数

SQL 中的窗口函数

SQL 中的窗口函数&#xff08;Window Functions&#xff09;是一种特殊的函数&#xff0c;它可以在查询结果的某个区间内执行计算&#xff0c;而不仅仅是对单个行进行计算。 以下是一些常用的窗口函数&#xff1a; 1、ROW_NUMBER() ROW_NUMBER() 函数可以给查询结果的每一行…
阅读更多...
C语言常见关键字

C语言常见关键字

写在前面 这个博客是结合C语言深度解剖这本书和我以前学的知识综合而成的,我希望可以更见详细的谈一下C语言的关键字,内容有点多,有错误还请斧正. 常见关键字 下面我们说下C语言的关键字,所谓的关键字是指具有特定功能的单词,我们可以使用关键字来帮助我们完成不同的事物.C语…
阅读更多...
win系统电脑如何打开sketch？

win系统电脑如何打开sketch？

2 个方法快速使用 Windows 系统打开 Sketch 文件&#xff1a;使用 Adobe XD 打开 Sketch 文件或者使用浏览器中就能做设计的即时设计直接打开 Sketch 文件。众所周知&#xff0c; Sketch 只能在 Mac 电脑上使用&#xff0c;因此只有借助 XD 这种能在 Windows 系统启动的软件工具…
阅读更多...
LSTM原理解析

LSTM原理解析

一、背景 前文讲了RNN的基本原理&#xff0c;可以发现RNN是一个比较简单的神经网络结构&#xff0c;虽然为文本和时间序列的建模提供了一个很好的思路&#xff0c;但是也有一定的局限性。最直观的就是使用了Tanh函数造成梯度消失的问题。 根据Tanh的性质&#xff0c;很容易出…
阅读更多...
树莓派Bullseye版本更新

树莓派Bullseye版本更新

1、参考链接&#xff1a;树莓派11bullseye换源/Opencv安装_所罗门大帝的博客-CSDN博客 2、参考链接&#xff1a;https://blog.csdn.net/weixin_39589455/article/details/124514099 步骤1、使用镜像帮助&#xff1a;https://mirrors.tuna.tsinghua.edu.cn/help/raspbian/ 步骤…
阅读更多...
面试题 链表相交 -剑指offer简单

面试题 链表相交 -剑指offer简单

面试题 链表相交 题目链接 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 题目数据 保证 整个链式结构中不存在环。 注意&#…
阅读更多...
DIY生日蛋糕笔记

DIY生日蛋糕笔记

自制6寸生日蛋糕笔记 实验环境&#xff1a; 长帝CRTF32PD搪瓷烤箱32升&#xff0c; 九阳电动打蛋器&#xff0c; 裱花盘一套 蛋糕盒子 称重器 硅胶刀 两个大碗1号和2号。 材料&#xff1a; 参考&#xff1a; https://www.bilibili.com/video/BV1t34y1Z7mL/?spm_id_from333…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023