Java基础-Java8新特性

最新推荐文章于 2024-04-30 17:28:01 发布
最新推荐文章于 2024-04-30 17:28:01 发布
阅读量47 收藏
点赞数
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014215131/article/details/113566138
版权

1. Lambda表达式

  • Lambda是一个匿名函数，可以把Lanbda表达式理解为一段可以传递的代码
import org.junit.Test;

import java.util.Comparator;

/**
 * @author gai
 * @create 2021--02--03
 */
//Lambda表达式的使用举例
public class LambdaTest {


    @Test
    public void test1() {
        Runnable r1 = new Runnable() {

            @Override
            public void run() {
                System.out.println("我爱中国");
            }
        };
        r1.run();
        System.out.println("**************");

        Runnable r2 = () -> System.out.println("我爱中国");
        r2.run();

        Comparator<Integer> com1 = new Comparator<>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1, o2);
            }
        };
        System.out.println(com1.compare(12, 21));

        //Lambda表达式
        Comparator<Integer> com2 = (o1, o2) -> Integer.compare(o1, o2);
        System.out.println(com2.compare(22, 21));

        //方法引用
        Comparator<Integer> com3 = Integer::compare;
        System.out.println(com2.compare(22, 21));
    }
}


/*
(o1,o2)->Integer.compare(o1,o2)
->:lambda操作符
左边：lambda形参列表，就是接口中的抽象方法的形参列表
右边：lambda体，就是重写的抽象方法的方法体
本质还是作为接口的实例
总结：->左边:形参列表的参数类型可以省略(类型推断)；如果形参列表只有一个参数，()可以省略
右边：lambda应该使用{}包裹，如果只有一条执行语句可以省略{}、return

Lambda表达式的使用
*/
public class LambdaTest1 {
    //语法格式1：无参，无返回值
    @Test
    public void test1() {
        Runnable r1 = new Runnable() {

            @Override
            public void run() {
                System.out.println("我爱中国");
            }
        };
        r1.run();
        System.out.println("**************");

        Runnable r2 = () -> {
            System.out.println("我爱中国");
        };
        r2.run();
    }

    //语法格式2：需要一个参数，但是没有返回值
    @Test
    public void test2() {
        Consumer<String> con = new Consumer<>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("我爱中国");
        System.out.println("*************");

        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };
        con1.accept("我爱中国");
    }

    //语法格式3：数据类型可以省略，可以由编译器推断得出，“类型推断”
    @Test
    public void test3() {
        Consumer<String> con1 = (s) -> {
            System.out.println(s);
        };
        con1.accept("我爱中国");
    }

    //语法格式4：若只需要一个参数，参数的括号可以省略
    @Test
    public void test4() {
        Consumer<String> con1 = s -> {
            System.out.println(s);
        };
        con1.accept("我爱中国");
    }

    //语法格式5：需要两个以上参数，多条执行语句，并且有返回值
    @Test
    public void test5() {
        Comparator<Integer> com1 = new Comparator<>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }
        };

        System.out.println("***************");
        Comparator<Integer> com2 = (o1, o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
    }

    //语法格式6：当lambda体只有一条语句时，retrun与大括号都可以省略
    @Test
    public void test6() {
        Comparator<Integer> com1 = (o1, o2) -> {
            return o1.compareTo(o2);
        };
        Comparator<Integer> com2 = (o1, o2) -> o1.compareTo(o2);

    }
}

2. 函数式(Functional)接口

  • 如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口
  • 在java.util.function包中定义了Java 8的丰富的函数式接口
  • 以前用匿名实现类表示的现在都可以用Lambda表达式来写
@FunctionalInterface
public interface MyInterface {
    void method();
}

函数式接口
函数式接口

/*java内置的4大核心函数式接口
 * 消费型接口Consumer<T>    void accept(T t)
 * 供给型接口Supplier<T>    T get()
 * 函数型接口Function<T,R>  R apply (T t)
 * 断定型接口Predicate<T>   boolean test(T t)
 * */

public class LambdaTest2 {
    @Test
    public void test1() {
        happyTime(500, new Consumer<Double>() {
            @Override
            public void accept(Double aDouble) {
                System.out.println("价格为" + aDouble);
            }
        });

        happyTime(400, money -> System.out.println("价格为" + money));
    }

    public void happyTime(double money, Consumer<Double> con) {
        con.accept(money);
    }

    @Test
    public void test2() {
        List<String> list = Arrays.asList("北京", "东京", "天津");
        List<String> str = filterString(list, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.contains("京");
            }
        });
        System.out.println(str);

        List<String> string = filterString(list, s -> s.contains("天"));
        System.out.println(string);
    }

    //根据给定的规则，过滤集合中的字符串。此规则由Predicate的方法决定
    public List<String> filterString(List<String> list, Predicate<String> pre) {
        ArrayList<String> filterList = new ArrayList<>();
        for (String s : list) {
            if (pre.test(s)) {
                filterList.add(s);
            }
        }
        return filterList;
    }
}

3. 方法引用与构造器引用

  • 当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用(Method References)
  • 实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法参数列表和返回值类型保持一致
  • 对象::实例方法名 类::静态方法名 类::实例方法名
//方法引用举例
public class MethodRefTest {
    //情况1？：对象::实例方法
    @Test
    public void test1() {
        Consumer<String> con1 = str -> System.out.println(str);
        con1.accept("北京");
        System.out.println("******");

        Consumer<String> con2 = System.out::println;
        con2.accept("上海");
    }

    //情况2：类::静态方法
    @Test
    public void test2() {
        Comparator<Integer> com1 = (t1, t2) -> Integer.compare(t1, t2);
        System.out.println(com1.compare(12, 21));

        Comparator<Integer> com2 = Integer::compare;
        System.out.println(com2.compare(12, 21));

        Function<Double, Long> func1 = d -> Math.round(d);
        Function<Double, Long> func2 = Math::round;
    }

    //情况3：类::实例方法
    @Test
    public void test3() {
        Comparator<String> com1 = (s1, s2) -> s1.compareTo(s2);

        Comparator<String> com2 = String::compareTo;
    }
}
  • 构造器引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致
//数组引用
    @Test
    public void test1() {
        Function<Integer, String[]> function = length -> new String[length];
        String[] arr1 = function.apply(5);
        System.out.println(Arrays.toString(arr1));

        Function<Integer, String[]> function1 = String[]::new;
        String[] arr2 = function1.apply(15);
        System.out.println(Arrays.toString(arr2));
    }

4. 强大的Stream API

  • Stream API(java.util.stream)把真正的函数式编程引入到Java中，极大提供Java的生产力
  • 使用Stream API对集合数据进行操作，就类似于使用SQL执行的数据库查询，也可以使用Stream API来并行执行操作，提供了一种高效易于使用的处理数据的方式
  • Stream自己不存储元素，不会改变源对象

Stream和Collection集合的区别：Collection是静态的内存数据结构，而Stream是有关计算的。前者主要面向内存，存储在内存中，后者面向CPU，通过CPU实现计算

/*
 * Stream执行流程
 * 1.Stream的实例化
 * 2.一系列的中间操作（筛选与切片，映射，排序）
 * 3.终止操作：只有执行终止操作，才执行中间操作。
 * */
public class StreamAPITest {
    @Test
    public void test1() {
        //创建Stream方式1：通过集合
        //default Stream<E> stream():返回一个顺序流
        //default Stream<E> parallelStream():返回一个并行流

        //创建Stream方式2：通过数组
        int[] arr = new int[]{1, 2, 3, 4, 5, 6};
        //调用Arrays类的static <T> Stream<T> stream(T[] array):返回一个流
        IntStream stream = Arrays.stream(arr);

        //创建Stream方式3：通过of()
        Stream<Integer> stream1 = Stream.of(1, 2, 3, 4, 5, 6);

        //创建Stream方式4：创建无限流
        //迭代
        Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);
        //生成
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }
}

//Stream的中间操作
public class StreamAPITest1 {

    //1.筛选与切片
    @Test
    public void test1() {
        int[] arr = new int[]{1, 1, 2, 3, 4, 5, 6};
        IntStream stream = Arrays.stream(arr);
        //filter(Predicate p)接受Lambda，从流中排除某些元素
        //stream.filter().forEach(System.out::println);

        //limit(n)截断流，使其元素不超过给定数量
        //stream.limit(3).forEach(System.out::println);

        //skip(n)跳过元素
        //stream.skip(30).forEach(System.out::println);

        //distinct()筛选，通过流所生成元素的hashCode()和equals()去重元素
        stream.distinct().forEach(System.out::println);
    }

    //2.映射
    @Test
    public void test2() {
        //map(Function f)
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
        list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);

        //flatMap(Function f)
        Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest1::fromStringToStream);
        streamStream.forEach(s -> {
            s.forEach(System.out::println);
        });

        Stream<Character> characterStream = list.stream().flatMap(StreamAPITest1::fromStringToStream);
        characterStream.forEach(System.out::println);
    }


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

    //3.排序
    @Test
    public void test3() {
        //sorted()自然排序
        List<Integer> list = Arrays.asList(12, 235, 8796, 13, 7964, 44);
        list.stream().sorted().forEach(System.out::println);

        //sorted(Comparator com)定制排序
        list.stream().sorted((o1, o2) -> 0).forEach(System.out::println);
    }
}

//Stream的终止操作
public class StreamAPITest2 {
    //1-匹配与查找
    @Test
    public void test1() {
        //allMatch(Predicate p)检查是否匹配所有元素

        //anyMatch(Predicate p)检查是否至少匹配一个元素

        //noneMatch(Predicate p)检查是否没有匹配的元素

        //findFirst返回第一个元素

        //findAny 返回当前流中的任意元素
        //count返回流中元素的个数
        //max(Comparator c) 返回流中最大值
        //min(Comparator c)返回流中最小值

        //forEach(Consumer c)内部迭代
    }

    //2-归约
    @Test
    public void test2() {
        //reduce(T identity,BinaryOperator)
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Integer sum = list.stream().reduce(0, Integer::sum);
        System.out.println(sum);
    }

    //3-收集
    @Test
    public void test3(){
        //Collet(Collector c)将流转换为其他形式

    }
}

5. Optional类

  • 空指针异常是导致Java应用程序失败的最大原因，为了解决空指针异常，Optional类成为了Java8类库的一部分
  • Optional< T>类(java.util.Optional)是一个容器类，可以保存类型T的值，代表这个值存在。或仅仅保存null，表示这个值不存在，原来用null表示一个值不存在，现在Optional可以更好的表达这个概念，并且可以避免空指针异常
public class OptionalTest {
    @Test
    public void test1() {
        //Optional.of(T t)创建一个Optional实例，t必须非空
        //Optional.empty()创建一个空的Optional实例
        //Optional.ofNullable(T t) t可以为null

        Girl girl = new Girl();
        //girl = null;
        Optional<Girl> optionalGirl = Optional.of(girl);
        Optional<Girl> optionalGirl1 = Optional.ofNullable(girl);

        //orElse(T t1) 如果当前的Optional 内部封装的t是非空的，则返回内部的t；不如果内部t是空的，则返回t1
        Girl girl1 = optionalGirl1.orElse(new Girl("SSS"));
        System.out.println(girl1);
        System.out.println(optionalGirl1);
    }

    public String getGirlName(Boy boy) {
        //原来的写法
        //return boy.getGirl().getName();
        //优化后的
        Optional<Boy> boyOptional = Optional.ofNullable(boy);
        Boy boy1 = boyOptional.orElse(new Boy(new Girl("迪丽热巴")));
        Girl girl = boy1.getGirl();
        Optional<Girl> optional = Optional.ofNullable(girl);
        Girl girl1 = optional.orElse(new Girl("古力娜扎"));
        return girl1.getName();
    }

    @Test
    public void test2() {
        Boy boy = new Boy(new Girl("苍"));
        String girlName = getGirlName(boy);
        System.out.println(girlName);
    }
}
盖大大
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 14万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
Java-Java8十大特性详解教程
11-08
Java8 十大特性详解教程 资源为视频教程资源 希望对你的 Java 学习有所帮助。
Java8 - Java17新特性说明
h295928126的博客
07-06 3417
Java8 - Java17新特性说明
Java8新特性-Lambda表达式
ThinkWon的博客
02-08 1万+
文章目录简介使用Lambda表达式的优缺点基本概念函数式接口接口默认方法嵌套类(Nested Classes)使用Lambda表达式的前提基础语法Lambda表达式的重要特征目标类型与类型推断作用域方法引用静态方法引用指定对象实例方法引用特定类型任意对象方法引用超类方法引用构造器方法引用数组构造器方法引用Java8内置的函数式接口消费型接口供给型接口函数型接口断言型接口 简介 Lambda表达式（也称闭包），是Java8中最受期待和欢迎的新特性之一。Lambda表达式本质是一个匿名函数，但是它并不是匿名类的
java基础 -- java8,9,10,11新特性
weixin_42469070的博客
03-31 1275
java基础 -- TODOjava8 新特性接口中的新特性可重复注解、类型注解 连接视频 java8 新特性 接口中的新特性 JDK7及以前：只能定义全局常量和抽象方法 全局常量：public static final的，但是书写时，可以省略不写 抽象方法：public abstract的 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法 Java 8 中，你可以为接口添加 静态方法 和 默认方法。从技术角度来说，这是完全合法的，只是它看起来违反了接口作为一个抽象定义的理念。 静
JAVA8新特性(吐血整理)
热门推荐
yitian_66的博客
07-12 11万+
一、Java 8 Lambda 表达式... 31.1 语法... 31.2 Lambda 表达式实例... 3Java8Tester.java 文件... 31.3 变量作用域... 5Java8Tester.java 文件... 5Java8Tester.java 文件... 5二、Java 8 方法引用... 72.1方法引用... 72.2方法引用实例... 8Java8Tester.j...
Java-JDK8新特性总结-接口方法/Lambda/方法引用/Optional
07-12
总结JDK8新特性，内容言简意赅，突出重点 内容：包括接口中的方法/Lambda/方法引用/Optional/函数式接口 适合人群：有一定编程基础及Java基础的伙伴 使用场景：开发和面试题中都会用到，开发中合理运用Java 8新特性...
Java零基础 - Java语言特性简介.md
08-11
本文档介绍了Java语言的一些基本特性和常见用法，并附带了一个简单的Java示例代码。 内容概要 本文档涵盖以下内容： Java语言的面向对象编程特性 Java的跨平台性和内存管理机制 Java的异常处理机制 一个简单的Java...
大学课程讲义-Java基础-高级类特性.pptx
08-14
大学课程讲义_Java基础_高级类特性.pptx
Java基础－漫谈EJB在Java中的应用
02-04
它是为了实现嵌入式的消费类电子产品应用而产生的，它的作者是JamesGosling.EdFrank，PatrickNaughton，JonathanPayne，ChrisWarth在随后的几年时间中为Java语言加入了大量的特性，并把Java语言的目标做了一个重新的...
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 893
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 867
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
链表刷题集
最新发布
yajunjiao的专栏
04-30 267
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
PageHelper实现分页查询
m0_63849044的博客
04-24 1144
这行代码是在使用 MyBatis Generator (MBG) 或类似的 MyBatis 工具生成的代码来构建查询条件。（可能是MyBatis的Mapper接口）来执行基于前面定义的查询条件的查询，并获取结果列表。实例之后会被用来设置各种查询条件，如字段的等于、不等于、大于、小于、模糊查询等。实体类生成的辅助类，它通常包含了一些静态内部类和方法，用于构建查询条件。在MyBatis中，这样的对象通常用于构建查询条件。对象，可能用于作为查询条件）。的一个内部类，用于定义查询的具体条件。
MSE实现全链路灰度实践
云计算、数据库、大数据、深度学习、NLP、Python
04-24 369
待更新。
Java | 冒泡排序算法实现
yingzix688的博客
04-24 853
题目描述 编写一个Java程序，实现冒泡排序算法。程序需要能够接收一个整型数组作为输入，并输出排序后的数组。 冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
【限流】基于springboot（拦截器） + redis（执行lua脚本）实现注解限流
qq_43209531的博客
04-30 86
基于springboot（拦截器） + redis（执行lua脚本）实现注解限流
公考学习平台|基于SprinBoot+vue的公考学习平台(源码+数据库+文档)
weixin_66413741的博客
04-30 700
本共享汽车管理系统有管理员和用户。管理员功能有个人中心，用户管理，投放地区管理，汽车信息管理，汽车投放管理，汽车入库管理，使用订单管理，汽车归还管理。用户可以在注册登录，可以对汽车进行使用产生订单，还可以归还。因而具有一定的实用性。本站是一个B/S模式系统，采用Spring Boot框架，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得共享汽车管理系统管理工作系统化、规范化。
Java设计模式_概述（设计模式类型和基本原则）
weisian的博客
04-25 857
通过合成，可以将已有的类组合成新的类，达到复用的目的，同时保持类的简单和清晰。设计模式（Design pattern）代表了最佳的实践，是软件开发人员在软件开发过程中面临一般问题的解决方案，是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。但不推荐刚入门的开发者学习，哪怕把代码搞的一塌糊涂，也要先将功能完成，初学者，迈过坑是必然的，只有对自己编写的代码不满意，你才会体会到设计模式的重要性，也才能更加理解。也就是说，一个类应该尽量减少与其他类的耦合度，只与它直接相关的类进行交互。
深入java虚拟机--jvm高级特性与最佳实践 pdf
08-06
《深入java虚拟机--jvm高级特性与最佳实践》是一本关于Java虚拟机（JVM）的专业著作。该书以深入全面的方式介绍了JVM的高级特性和最佳实践。 在该书中，作者首先介绍了Java虚拟机的基础知识，包括JVM的结构、运行时...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值