Java8新特性

最新推荐文章于 2024-05-19 18:00:53 发布
最新推荐文章于 2024-05-19 18:00:53 发布
阅读量196 收藏
点赞数
文章标签： java spring 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49569564/article/details/123171303
版权

一、java8新特性内容概述

  1. Lambda表达式；
  2. 方法引用、构造器引用；
  3. stream流：并行流、串行流；
  4. 接口的增强：静态方法、动态方法；
  5. Optional类；
  6. 新的时间的日期API
  7. 其他：重复注解、类型注解、通用目标类型判断；

速度更快
代码更少：增加了新的语法，lambda表达式
stream流
便于并行
最大化减少空指针异常：Optinal
Nashorn引擎，允许在jvm上运行js应用

二、Lambda表达式

写法：6种

public class Lambda {

    @Test
    public void test3(){
        // 语法格式一：无参无返回值
        Runnable er2 = ()-> System.out.println("345345346456");
        er2.run();

        // 语法格式二：有参无返回值
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer.accept("5345345");

        // 语法格式二：有参无返回值
        Consumer<String> consumer2 = (String s) -> {
            System.out.println(s);
        };
        consumer2.accept("343543");

        // 引用写法
        Consumer<String> consumer3 = System.out::println;
        consumer3.accept("343543");

        // 语法格式三:类型推断，可以省略类型
        Consumer<String> consumer4 = (s) -> {
            System.out.println(s);
        };

        consumer4.accept("3435434343");

        // 语法格式四：参数只有一个，（）可以省略
        Consumer<String> consumer5 = s -> {
            System.out.println(s);
        };

        consumer5.accept("343455434343");

    }


    @Test
    public void test2(){
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1, o2);
            }
        };
        int compare = comparator.compare(12, 32);
        System.out.println(compare);

        // lambda表达式写法
        // 语法格式五：有参有返回值
        Comparator<Integer> comparator1 = (o1,o2) -> {
            return Integer.compare(o1, o2);
        };
        int compare1 = comparator1.compare(43, 22);
        System.out.println(compare1);

        // 方法引用
        Comparator<Integer> comparator2 = Integer::compareTo;
        int compare2= comparator2.compare(43, 22);
        System.out.println(compare2);

        // 语法格式六：lambda只有一条语句，{}和return都可以省略
        Comparator<Integer> comparator3 = (o1,o2) -> Integer.compare(o1, o2);
        int comparator33 = comparator3.compare(43, 22);
        System.out.println(comparator33);
        

    }

}

三、函数式接口

如果一个接口中只声明了一个抽象的方法，就叫函数式接口；
Lambda表达式的本质就是作为函数式接口的实例；
接口加@FunctionalInterface 注解定义可以验证，是不是函数式接口
在这里插入图片描述
在这里插入图片描述

四、方法引用与构造器引用

/**
 * 使用场景：
 *  1、对象::非静态方法（实例方法）
 *  2、类::静态方法
 *  3、类::非静态方法
 *
 *  使用要求：接口中的抽象方法的形参列表和返回值类型 和
 *  方法引用的方法形参列表和返回值类型 相同
 */
public class MethodRefTest {

    @Test
    void test1(){
        Consumer<String> consumer = str -> System.out.println(str);
        consumer.accept("被急加速");

        // 方法引用写法一 对象::非静态方法
        Consumer<String> consumer2 = System.out::println;
        // 或者
        PrintStream ps = System.out;
        Consumer<String> consumer3 = ps::println;

    }

    @Test
    void test2(){
        // 方法引用写法二 类::静态方法
        Comparator<Integer> comparator = Integer::compare;

    }

    @Test
    void test3(){
        Comparator<Integer> comparator = (s1,s2)-> s1.compareTo(s2);

        // 方法引用写法三 类::非静态方法（实例方法）
        Comparator<Integer> comparator3 = Integer::compareTo;
    }

}

五、构造器引用和数组引用

在这里插入图片描述

在这里插入图片描述

六、Stream API 666

是数据渠道。用于操作数据源所生成的元素序列。

public class StreamTest {

    // 通过集合创建Stream流

    @Test
    void test1(){
        UserData data = new UserData();
        List<User> userList = data.getUserList();
        // 默认是串行流
        Stream<User> stream = userList.stream();

        // 并行流
        Stream<User> userStream = userList.parallelStream();
    }


    // 通过数组创建Stream流
    @Test
    void test2(){

        IntStream stream = Arrays.stream(new int[]{1, 2, 3});

        UserData data = new UserData();
        User[] userArr = data.getUserArr();
        Stream<User> userStream = Arrays.stream(userArr);
    }

    // 通过Stream的of方法
    @Test
    void test3(){

        Stream<Integer> integerStream = Stream.of(1, 2, 3);
    }
}

Stream流的方法操作

 // stream的筛选与切片
    @Test
    public void test4(){
        UserData data = new UserData();
        List<User> userList = data.getUserList();
        
        // 查询手机号码是110d的用户，输出
        userList.stream().filter(e -> e.getPhone().equals("110")).forEach(System.out::println);
        System.out.println("===============");
        // limit(n) 截断流，使其元素不超过n
        userList.stream().limit(2).forEach(System.out::println);
        System.out.println("===============");
        // skip(n) 跳过元素前2个元素
        userList.stream().skip(2).forEach(System.out::println);
        System.out.println("===============");
        // distinct 去重,通过流所生成元素的hashcode()和equals()去重
        // 注意：distinct（）用于基本数据类型和String可以去重，但对于对象，不能做到去重；
        // 可以在对象中重写hashcode()和equals()方法去重，或者
        //根据name属性去重
        userList.stream().filter(distinctByKey(User::getId)).forEach(System.out::println);
        // 或者，利用TreeSet
        userList.stream().collect(Collectors.collectingAndThen(
                Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(User::getName))), ArrayList::new))
                .forEach(System.out::println);

    }

    public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor){
        Map<Object,Boolean> seen = new ConcurrentHashMap<>();
        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }

map 与 flatmap 映射

// stream的映射 map  flatmap
    @Test
    public void test5(){
        UserData data = new UserData();
        List<User> userList = data.getUserList();
        // 拿到用户姓名长度大于3的用户姓名
        userList.stream().filter(user -> user.getName().length() > 3)
                .map(User::getName).forEach(System.out::println);

        // 转换成大小写
        List<String> strings = Arrays.asList("aa", "bb", "cc");
        strings.stream().map(String::toUpperCase).forEach(System.out::println);

        // Stream嵌套stream 比较map和flatmap的区别
        // map需要foreach两次
        Stream<Stream<Character>> streamStream = strings.stream().map(StreamTest::fromstreamToStream);
        streamStream.forEach(s -> {
            s.forEach(System.out::println);
        });
        // flatmap只需要一次foreach ,对于集合套集合的情况，优先flatmap
        Stream<Character> characterStream = strings.stream().flatMap(StreamTest::fromstreamToStream);
        characterStream.forEach(System.out::println);

    }

    public static Stream<Character> fromstreamToStream(String str){
          ArrayList<Character> list = new ArrayList<>();
          for(Character a : str.toCharArray()){
              list.add(a);
          }
           return list.stream();
    }

// 排序
    @Test
    public void test6() {

        // sorted 自然排序 数字默认从小到大排序 如果排序对象会报错，因为对象没有实现Compable排序接口
        List<Integer> integers = Arrays.asList(666, 44, -98, 1, 33, 44, 66, 77);
        integers.stream().sorted().forEach(System.out::println);
        System.out.println("============================");
        List<String> integers2 = Arrays.asList("斩杀", "ed", "44", "我的世界", "43534");
        integers2.stream().sorted().forEach(System.out::println);
        // sorted(Compator c) 定制排序
        UserData userData = new UserData();
        List<User> userList = userData.getUserList();
        // 默认从小到大
        userList.stream().sorted(Comparator.comparingInt(User::getPhone)).forEach(System.out::println);
        // 按照电话从小到大，按照从大到小
        userList.stream().sorted((e1, e2) -> {
           int v = Integer.compare(e1.getPhone(),e2.getPhone());
           if (v == 0){
               return v;
           }else {
               // 在前面加 - 负号
               return -Integer.compare(e1.getId(),e2.getId());
           }
        }).forEach(System.out::println);
    }

Stream流的终止操作

 // stream流的终止操作
    // 1、匹配与查找
    @Test
    public void test8(){
        // allMatch(Predicate e) 判断是否匹配所有元素
        List<User> userList = new UserData().getUserList();
        boolean b = userList.stream().allMatch(e -> e.getId() > 2);
        System.out.println(b);  // ----false
        List<User> userList2 = new UserData().getUserList();
        boolean c = userList.stream().allMatch(e -> e.getId() > 0);
        System.out.println(c); // ----true

        // anyMatch 判断是否至少匹配一个元素
        boolean d = userList.stream().anyMatch(e -> e.getId() > 0);
        System.out.println(d); // ----true

        // noneMatch 没有一个存在的，判断是否没有匹配的元素
        boolean f = userList.stream().noneMatch(e -> e.getId() < 0);
        System.out.println(f); // ----true

        // findFirst --返回第一个元素

        // findAny 返回任意一个元素
        Optional<User> any = userList.parallelStream().findAny();
        System.out.println(any);

        // count 返回元素的个数
        // max 返回流中的最大值
        // min 返回流中的最小值 --返回id最小的用户
        Optional<User> min = userList.stream().min(Comparator.comparingInt(User::getId));
        System.out.println(min);

    }

// 归约 reduce  收集collect
    @Test
    public void test9(){
        // 求1-5的和
        List<Integer> list = Arrays.asList(1,2,3,4,5);
        Integer reduce = list.stream().reduce(0, Integer::sum);
        System.out.println(reduce);
    }

在这里插入图片描述

七、Optional类

Optional类是一个容器类。可以避免空指针异常。是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回这个对象
在这里插入图片描述
在这里插入图片描述

m0_49569564
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JAVA8新特性
04-05 172
Lambda表达式 Lambda 是一个匿名函数，我们可以把Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。 1.从匿名类到Lambda 的转换 匿名内部类：内部使用的变量必须是final的；如final int num = 1; 2.Lambda表达式语法 Lambda 表达式在Java 语言中引入了一个新的语法元素和操作符。这个操作符为“->” ，.
Java8 新特性
06-17
java8的新特性，包含lambda表达式，stream流以及Optional和日期
java8新特性
01-23
java8新特性java8新特性java8新特性java8新特性java8新特性
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
Java 8 新特性详解
最新发布
编程之路
05-19 833
Java 8 于 2014 年发布，带来了许多重大更新和特性，这些特性极大地增强了 Java 语言的功能和灵活性。本文将详细介绍 Java 8 的一些重要新特性，包括 Lambda 表达式、Stream API、默认方法和新的日期时间 API。Lambda 表达式是 Java 8 引入的最重要的特性之一，它使得 Java 具备了类似函数式编程的能力。新的日期时间 API 提供了丰富的方法来处理日期和时间，例如日期加减、格式化、解析等。提供了一种优雅的方式来处理可能为空的值，避免了显式的空值检查。
Java8新特性都到碗里来
你听___
04-15 264
对于Java开发者来说，Java8的版本显然是一个具有里程碑意义的版本，蕴含了许多令人激动的新特性，如果能利用好这些新特性，能够大大提升我们的开发效率。Java8的函数式编程能够大大减少代码量和便于维护，同时，还有一些跟并发相关的功能。开发中常用到的新特性如下： 1. 接口的默认方法和静态方法 2. 函数式接口FunctionInterface与lambda表达式 3. 方法引用 4....
Java9都快发布了，Java8的十大新特性你了解多少呢？
weixin_30784141的博客
08-03 289
Java 9预计将于今年9月份发布，这是否会是一次里程碑式的版本，我们拭目以待。今天，我们先来复习一下2014年发布的Java 8的十大新特性。 Java 8可谓是自Java 5以来最具革命性的版本了，她在语言、编译器、类库、开发工具以及Java虚拟机等方面都带来了不少新特性。我们来一一回顾一下这些特性。 一、Lambda表达式 Lambda表达式可以说是Java 8最大的卖点，她将函数...
java8 新特性
02-28
介绍了Java 8 这个里程碑版本的新特性，包括Lambdas、流和函数式编程。有了函数式的编程 特性，可以让代码更简洁，同时也能自动化地利用多核硬件。全书分四个部分：基础知识、函数式数据处理、 高效Java 8 编程和...
JAVA8新特性讲解
12-15
Java 8是Java语言发展的一个重要里程碑，引入了许多创新特性，极大地提升了开发效率和代码质量。以下是关于Java 8新特性的详细讲解： ...通过观看“Java8 新特性视频教程”，你可以深入理解并熟练运用这些特性。
Java8新特性共76页
11-18
Java8新特性共76页
java8新特性-最新
12-18
在Java 8中，最重要的两个新特性无疑是Lambda表达式和Stream API。这两个特性都与函数式编程思想密切相关，让Java开发者能够更加灵活地处理数据。 ### Lambda表达式 Lambda表达式是Java 8中最显著的新特性之一，它...
全网详解(波哥)Java8新特性(Lambda、Stream、LocalDate等)新特性
09-02
全网详解(波哥)Java8新特性(Lambda、Stream、LocalDate等)新特性 自学java的同行们应该都要学习java8的新特性，譬如：（Lambda、Stream、LocalDate等）！本人在学习java的时候看的是波哥的视频，确实讲的不错，很...
java 8新特性
qq_35932990的博客
01-20 2806
Java 8 概述 Java 8 是 Java 语言历史上一个非常重要的版本，它引入了多项新特性，大大提高了 Java 语言的现代化程度和生产力。以下是 Java 8 的一些主要新特性介绍。
JAVA 8 的新特性
qq_36488864的博客
06-02 3037
前段时间面了完美世界，被问到Java8的新特性，在此特地记录一下，虽然现在Java的版本可能已经很高了，但是Java8的新特性依然值得学习一下！
Java 8 再不知道就老了
WSRspirit的专栏
08-11 7426
Java 8 特性介绍1.简介毫无疑问，Java 8是自Java 5（2004年）发布以来Java语言最大的一次版本升级，如果不学习，你会怀疑自己面前的代码是不是Java。Java 8带来了很多的新特性，比如编译器、类库、开发工具和JVM（Java虚拟机），但最最主要的还是函数式编程。接下来将会结合代码去展示Java 8的新特性。下面主要介绍Java 8的最显著特性： 接口增强 La
深入解析Java8新特性
" Beginning Java 8 Language Features 是一本关于了解Java 8新特性的书籍，涵盖了从注解、内部类到流等广泛的主题，旨在帮助读者深入理解Java 8的重要更新。" Java 8作为Java语言的一个重大版本更新，引入了许多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值