java8新特性【2023】

最新推荐文章于 2023-04-18 14:39:31 发布
最新推荐文章于 2023-04-18 14:39:31 发布
阅读量736 收藏
点赞数
分类专栏： javase 文章标签： java jvm android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42044885/article/details/129067549
版权
本文介绍了Java中的Lambda表达式，包括如何创建匿名函数、使用方法引用以及函数式接口。同时，详细讲解了StreamAPI的应用，如创建流、排序、筛选、映射等操作，展示了如何在实际编程中提升效率和代码简洁性。
摘要由CSDN通过智能技术生成

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);

    }
}
Comus_j
关注
专栏目录
java中double..compare_Java Double类compare()方法与示例
weixin_28848933的博客
02-13 6119
Double类compare()法compare()方法在java.lang包中可用。compare()方法用于检查给定两个双精度值的相等或不相等，换句话说，可以说此方法用于比较两个双精度值。compare()方法是一个静态方法，也可以使用类名进行访问，如果尝试使用类对象访问该方法，那么也不会出错。比较双精度值时，compare()方法不会引发异常。语法：publicstaticintcom...
关于 Double.compare()
hello world
11-07 2803
使用<和>对浮点数进行比较时，不够严谨，有这两个问题：0.0、-0.0的比较问题(0.0 > -0.0)，以及NaN的问题(NaN永远比!NaN大)，建议使用Double.compare()或Float.compare()进行比较。 Double.compare()源码 public static int compare(double d1, double d2) { if (d1 < d2) return -1;
Java Double compare()方法具有什么功能呢？
qq_25073223的博客
09-13 883
Java Double compare()方法的功能简介说明
java double方法_Java Double类compare（）方法与示例
cumudi0723的博客
07-13 1853
java double方法 双类compare()方法 (Double class compare() method) compare() method is available in java.lang package. compare()方法在java.lang包中可用。 compare() method is used to check equality or inequality of t...
java double.compare_Java Double compare()方法
weixin_39980596的博客
02-13 664
Java Double compare()方法java.lang.Double.compare()方法比较两个指定的double值。返回整数值符号是相同的，这将通过调用被返回整数：new Double(d1).compareTo(new Double(d2))1 语法public static int compare(double d1, double d2)2 参数d1：这是第一个要比较的do...
java 8 新特性
04-03
### Java 8 新特性详解 #### 一、概述 Java 8 是自 Java 5 以来最重要的一个版本，它引入了一系列的新特性和改进，极大地提高了开发效率和代码可读性。这些新特性主要包括：Lambda 表达式、Stream API、日期时间...
2023java最新阿里巴巴面试题,2023java最新阿里巴巴面试题
06-02
以下是一些针对阿里巴巴2023年Java面试题的相关知识点： 1. **Java语言特点**： - **简单易学**：Java的设计目标是易于学习，其语法简洁，避免了C++等语言的复杂性。 - **丰富的类库**：Java拥有庞大的标准类库，...
阿里巴巴 Java 编码指南，Alibaba Java Coding Guidelines​，兼容 Idea 2023.3+
最新发布
04-09
《阿里巴巴 Java 编码指南》是业界广泛采用的编码规范，旨在提高代码质量和开发效率，尤其对于使用 IntelliJ IDEA 的开发者来说，此指南的兼容性更新至 2023.3+ 版本，确保了最新的开发环境支持。这份指南在 2024 年...
最新Java面试笔试题库2023
07-21
17. **Java新特性**：从Java 8到Java 17的新特性和改进，如Lambda表达式、Stream API、Optional类、模块系统等。 这个题库将帮助求职者对以上知识点有更全面的认识，通过实践题目加深理解，提高在面试中的表现。...
2023最新整理版-java基础面试提
06-19
这份最新的2023年整理版涵盖了广泛的Java基础知识，包括但不限于基础概念与常识、基本语法、基本数据类型、面向对象特性、Java内置类、异常处理、泛型、反射、注解、服务提供接口（SPI）以及序列化与反序列化等多个...
Float.compare()和Double.compare()的使用
lydms的博客
01-19 9776
文章目录1、简介2、案例 1、简介 public static int compare(float f1, float f2) ; 底层的源码为： public static int compare(float f1, float f2) { if (f1 < f2) return -1; if (f1 > f2) return 1; ...
Java8新特性【函数式接口、Lambda表达、Stream流】
白豆五的博客
04-18 1387
Java8新特性之函数式接口、Lambda表达、Stream流。
6.java8新特性
qq_43699776的博客
12-01 192
java8新特性 Java8对内存结构进行了优化，同时对HashMap的底层结构进行了优化，从原来的数字加链表的结构改变为数组加红黑树的结构提升了效率 lambda表达式 stream串行流和并行流 Java8中新的时间API Instant LocalTime LocalDateTime 一：lambda表达式 lambda表达式是一个匿名函数，我们可以把它理解为是一...
java double.compare_Java Comparator comparingDouble()用法及代码示例
weixin_36370242的博客
02-23 1764
Java中Comparator接口的compareDouble(java.util.function.ToDoubleFunction)方法接受一个函数作为参数，该参数从类型T中提取一个双精度排序键，并返回一个与该排序键进行比较的Comparator。指定的函数也可以序列化。用法:static Comparator comparingDouble(ToDoubleFunction keyExt...
Java比较器
ZJH
10-18 200
比较器的作用 在Java中，要想比较对象一般只能用==或！= 如果想要比较< <= > >=则需要使用Comparable或Comparator两个接口的其中一个 Comparable接口 String、包装类都实现了Comparable接口，并且重写了其中的compareTo(obj)方法 例如： "aa".compareTo("bb")返回的结果是-1，意为"aa"-"bb"=-1<0即"aa"<"bb" "cc".compareTo("bb")返回的
比较double类型数值的方法
qq_32352367的博客
06-05 5263
1. compare方法 如果要比较d1与d2两个double类型的数值，可以调用java.lang.Double中的Compare方法 new Double(d1).compareTo(new Double(d1)) 依据返回值判断大小:   若等于0，则说明d1在数值上等于d2，   若大于0，则说明d1在数值上大于d2，   若小于0，则说明d1在数值上小于d2， 2. 自己编写equal函数，设定允许的误差范围   设定一个精度esp，当两个double类型数字的差的绝对值小于esp，则认为
十八、JAVA8新特性
qq_42926722的博客
12-31 655
文章目录1、JAVA概述2、JAVA8新特性的好处3、并行流与串行流4、Lambda表达式4.1 Lambda表达式使用举例4.2 Lambda表达式语法的使用5、函数式（Function）接口5.1 函数式接口的介绍5.2 JAVA内置的函数式接口介绍及使用举例6、方法引用与构造器引用6.1 方法引用的情况6.2 构造器引用与数组引用的使用7、强大的Stream API7.1 Stream API的概述7.2 Stream的实例化7.3 Stream的中间操作：筛选与切片7.4 Stream的中间操作：映
Java 8 新特性之一——Lambda使用
qq_41891244的博客
11-16 738
目录 一、Lambda 1.Lambda的简单介绍 2.java 8 的函数式接口 一、Lambda 1.Lambda的简单介绍 Lambda表达式可以简单的理解为一种简洁的可传递匿名函数：它没有名次，但它有参数列表、函数主体、返回类型，可能还能抛出异常列表。 Lambda表达式的基本语法：(parameters) -> expression 或者(parameters) ->{statements;} 注意：本文着重写Lambda表达式在函数式接口的使用，至于Lam...
【2019尚硅谷宋红康java基础2】 比较器 Comparator和 System 和 Math BigDecimal
qq120631157的博客
08-30 495
比较器 Comparator和 System 和 Math BigDecimal
Java 8 新特性教程：默认接口方法、Lambda 表达式和函数式编程
本教程将带领读者一步一步地认识 Java 8 的新特性，通过简单明了的代码示例，读者将会学习到如何使用默认接口方法、Lambda 表达式、方法引用和重复注解等新的语言特性。 默认接口方法 Java 8 允许我们使用 default...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值