java基础之java 新特性（8-17）

已于 2023-10-22 12:16:19 修改
阅读量166 收藏 1
点赞数 1
文章标签： java 开发语言
于 2023-10-20 20:46:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46375204/article/details/133949150
版权
1. Lambda表达式
        1.1 什么是函数式接口？

                有且仅有一个抽象方法的接口。

        1.2 怎么判断一个接口是不是函数式接口？

                使用@FunctionalInterface进行标记判，标记不报错则为函数式接口，例如创建线程的Runnable接口。

package com.example.javaee.newfeatures.lambda.inf;

@FunctionalInterface
public interface Usb {
    public void print(String str);
}
        1.3 @FunctionalInterface注解
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface FunctionalInterface {}
        1.4 java8中声明的函数式接口所在包

java.util.function

         1.5 四大基本函数式接口
        

接口

对应方法
消费型 
Consumer<T>
 
void accept(T t);
供给型 
Supplier<T>
 
T get();
函数型 
Function<T, R>
 
R apply(T t);
判断型 
Predicate<T>
 
boolean test(T t);
          
        1.6 Lambda的本质是什么？

              Lambda本质是一种匿名实现类对象。  

package com.example.javaee.newfeatures.lambda.inf;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
/**
 *
 * @author 
 */
@SpringBootTest
class UsbTest {
    /**
     * 例如线程的runnable接口的使用,要创建接口的匿名实现类
     */
    @Test
    public void testCommon(){
        Usb usb = new Usb(){
            @Override
            public void print(String str) {
                System.out.println(str);
            }
        };
        usb.print("接口匿名实现类对象");
    }
    /**
     *  Lambda实现
     */
    @Test
    public void testLambda(){
        Usb usb =  str -> System.out.println(str);
        usb.print("Lambda实现");
    }
    /**
     *  方法引用
     */
    @Test
    public void testMethodReference(){
        Usb usb = System.out::println;
        usb.print("方法引用实现");
    }

}
        1.7 Lambda的具体使用

                给函数式接口提供实例时，可以考虑Lambda表达式。 

2. Stream API
        2.1 什么是Stream API，有什么用？

               是一系列用于专门操作集合中数据的API，是面向 CPU的。

        2.2 Stream API的执行流程

               实例化——>中间操作——>终止操作

        2.3 Stream API所在的包
java.util.stream
        2.4 Stream 实例化
 @Test
    public void testCreateStream(){
        /**
         * 集合
         */
        //顺序流
        Stream<Employee> stream = list.stream();
        //并行流
        Stream<Employee> parallelStream = list.parallelStream();
        /**
         * 数组
         */
        Stream<Employee> arrStream = Arrays.stream(objs);

        Stream<String> streamOf = Stream.of("AA", "BB", "CC");
    }
        2.5 Stream 中间操作 
 /**
     * 过滤
     *
     */
    @Test
    public void testFilter(){
        list.stream().filter(obj -> obj.getSalary() > 7000).forEach(System.out::println);
    }

    /**
     *  截断
     */
    @Test
    public void testLimit(){
        list.stream().limit(2).forEach(System.out::println);
    }

    /**
     *  跳过
     */
    @Test
    public void testSkip(){
        list.stream().skip(2).forEach(System.out::println);
    }

    /**
     *  去重      根据hashCode() 和 equals()去重
     */
    @Test
    public void testDistinct(){
        list.stream().distinct().forEach(System.out::println);
    }

    /**
     *  映射
     */
    @Test
    public void testMap(){
        Arrays.stream(strArr).map(String::toLowerCase).forEach(System.out::println);
    }

    /**
     *  排序
     */
    @Test
    public void testSorted(){
        //自然排序
        Arrays.stream(strArr).sorted().forEach(System.out::println);
        //定制排序
        Arrays.stream(strArr).sorted((s1, s2) -> -s1.compareTo(s2)).forEach(System.out::println);
    }
2.6Stream 终止操作
        2.6.1 查找遍历
 /**
     *  全部匹配
     */
    @Test
    public void testAllMatch(){
        System.out.println(list.stream().allMatch(emp -> emp.getAge() > 18));
    }
    /**
     *  至少一个
     */
    @Test
    public void testAnyMatch(){
        System.out.println(list.stream().anyMatch(emp -> emp.getAge() > 18));
    }
    /**
     *  返回第一个元素
     */
    @Test
    public void testFindFirst(){
        System.out.println(list.stream().findFirst().get());
    }
    /**
     *  计数
     */
    @Test
    public void testCount(){
        System.out.println(list.stream().count());
    }
    /**
     *  最大值
     */
    @Test
    public void testMax(){
        System.out.println(list.stream().max((e1,e2) -> (int) Math.round(e1.getSalary() - e2.getSalary())));
    }
    /**
     *  最小值
     */
    @Test
    public void testMin(){
        System.out.println(list.stream().min((e1,e2) -> (int) Math.round(e1.getSalary() - e2.getSalary())));
    }
    /**
     *  遍历
     */
    @Test
    public void testForEach(){
        list.stream().forEach(System.out::println);
    }
    /**
     *  遍历  @since 1.8
     */
    @Test
    public void testForEachNew(){
        list.forEach(System.out::println);
    }
        2.6.2 归约收集
    /**
     *  归约
     */
    @Test
    public void testForReduce(){
        System.out.println(integers.stream().reduce(0, Integer::sum));
    }
    /**
     *  收集
     */
    @Test
    public void testForCollect(){
        list.stream().filter(emp -> emp.getSalary()>5000).collect(Collectors.toList()).forEach(System.out::println);
    }
2.7Stream使用说明
  1.         Stream只是一系列对于数据处理的操作，自己并不会 存储数据。
  2.         Stream不会改变源对象。
  3.         Stream的 操作是延迟操作，需要执行终止操作才会执行。
  4.         Stream一旦执行了终止操作，就不会再执行中间操作和终止操作，否则会报异常java.lang.IllegalStateException: stream has already been operated upon or closed
3. 新的try—catch
/**
     *      JDK7之前的try——catch
     */
    @Test
    public void test(){

        FileWriter fileWriter = null;
        BufferedWriter bufferedWriter = null;
        try {
            fileWriter = new FileWriter("D://aaa.txt");
            bufferedWriter = new BufferedWriter(fileWriter);
            bufferedWriter.write("Hello");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally{
            try {
                if(bufferedWriter != null){
                    bufferedWriter.close();
                }
            } catch (IOException e) {
               e.printStackTrace();
            }
        }
    }
    /**
     *      JDK7的try——catch
     *      要求资源实现   AutoCloseable  @since 1.7
     */
    @Test
    public void testJDK7(){

        try (FileWriter fileWriter =new FileWriter("D://aaa.txt");
             BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
        ){

            bufferedWriter.write("Hello");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    /**
     *      JDK9
     */
    @Test
    public void testJDK9(){

        InputStreamReader inputStreamReader = new InputStreamReader(System.in);
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(System.out);
        try (inputStreamReader;outputStreamWriter
        ){

        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
4.类型推断
    /**
     *     @since JDK10
     *     类型推断
     */
    @Test
    public void testVar(){
       var lists = new ArrayList<>();
       lists.add("1");

        for (var list : lists) {
            System.out.println(list);
        }

        var iterator = lists.iterator();

    }
5.新的instanceof
    /**
     * JDK14之前
     */
    @Test
    public void testInstanceof(){

        Object obj = new String("hello");

        if (obj instanceof String) {
            String str = (String) obj;
            System.out.println("String 类型");
        }else {
            System.out.println("非 String 类型");
        }
    }
    /**
     * JDK14之后
     */
    @Test
    public void testNewInstanceof(){

        Object obj = new String("hello");

        if (obj instanceof String str) {
            System.out.println("String 类型");
        }else {
            System.out.println("非 String 类型");
        }
    }
6.Switch新特性

        新的Switch代码块中，我们可以使用 -> 操作符代替省略break，可以使用变量接收Switch返回的值，加入了yeild关键字，用于返回指定的数据，结束代码块，同时也引进了模式匹配。

/**
     * 使用 -> 省略break
     * 使用变量接收switch表达式的值
     */
    @Test
    public void testNewSwitch(){

        Season season = Season.WINTER;
        String expression = switch (season){
            case SPRING -> "SPRING";
            case SUMMER -> "SUMMER";
            case AUTUMN,WINTER -> "AUTUMN AND WINTER";
        };
        System.out.println(expression);
    }

    /**
     * yield可以返回指定的数据，结束switch表达式
     * break 用于无返回值 结束switch表达式
     */
    @Test
    public void testNewSwitch1(){

        Season season = Season.WINTER;
        String expression = switch (season){
            case SPRING :
                yield "SPRING";
            case SUMMER :
                yield "SUMMER";
            case AUTUMN,WINTER :
                yield "AUTUMN AND WINTER";
        };
        System.out.println(expression);
    }

    /**
     *  switch表达式模式匹配
     */
    @Test
    public void testNewSwitch2(){
        Object obj = new String("hello");

        String expression = switch (obj){
            case Integer integer :
                yield "Integer:" + integer;
            case Double dou :
                yield "Double:" + dou;
            case String str:
                yield "String:" +str;
            default :
                yield obj.toString();
        };
        System.out.println(expression);
    }
7. 代码块的使用
    /**
     *         \ 取消换行
     *         \s 代表空格
     */
    @Test
    public void testBlock(){
        String sql = """
                select * from\s\
                dual
                where 1 = 1
                """;
        System.out.println(sql);
    }
8. record类的使用
  1. record 可以避免编写构造器、访问器、equal方法、hashCode()、toString()。
  2. record中还可以定义静态变量、静态方法、构造器、实例方法。
  3. record本质是final类，不可被继承和使用abstract，属性也是final修饰的。
  4. 不能显示声明父类。
  5. record 不能替代java Bean 因为 java Bean 通常都是可变的，而 record 是不可变的。
public record Record(Integer id, String name){
}

        class文件反编译的内容：

public record Record(Integer id, String name) {
    public Record(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

    public Integer id() {
        return this.id;
    }

    public String name() {
        return this.name;
    }
}
9. 密封类

        用于指定子类类型，哪些可以被继承，并且之类类型是final、sealed、non-sealed之一。

public sealed class Person permits Worker,Student,Teacher {}
final class Worker extends Person {}
non-sealed class Student extends Person {}
sealed class Teacher extends Person permits MathTeacher{}
final class MathTeacher extends Teacher {}
 10. Optional类

                Optional类是为了解决空指针异常。

    @Test
    public void testOptional(){

        String language = "java";
        String otherLanguage = "C";
        language = null;
        Optional<String> optional = Optional.ofNullable(language);
        String finalLanguage = optional.orElse(otherLanguage);
        System.out.println(finalLanguage);
    }

        

cancanneedmaomao
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java基础-Java 9&10&11新特性
u014215131的博客
02-14 383
1. Java 9新特性 Java9提供了超过150项新功能特性，包括模块化系统、可交互的REPL工具：jshell、JDK编译工具，Java公共API和私有代码，以及安全增强、扩展提升、性能管理改善等 JDK和JRE目录结构改变：JDK8: /bin /include /jre /lib; JDK9: /bin /conf /indlude /jmods /legal /lib 1.1 模块化系统 Jigsaw项目->Modularity，Java运行越来越臃肿，每次启动JVM时，不管其中的
Java 16 新特性：instanceof增强
程序猿DD
05-04 716
instanceof这个关键词，主要用来判断某个对象是不是某个类的实例。比如，有时候我们要处理一个类似这样的数据集：Map<String,Object>data=newHashMap<>(); data.put("key1","aaa"); data.put("key2",111);这个Map中的Value值因为可能是不同的对象，所以...
Java8 ~ Java17 新特性
adolph09的博客
04-19 680
主要特性：函数式接口就是有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。可以隐式转化为 Lambda 表达式。 通过方法引用，可以使用方法的名字来指向一个方法。使用一对冒号来引 "::" 用方法。构造方法引用使用Class:new 静态方法引用使用方式：Class::staticMethod 实例方法引用使用方式：instance::method Java 8 新增了接口的默认实现，通过 default 关键字表示。 Java 8 支持了重复注解。在 Java 8 之前想实现重复注
轻松搞懂java8-17新特性
BASK2312的博客
04-23 576
随着SpringBoot 3.0 将Java 17 设置为最低版本 我们应该明白 Java8的时代总有一天会过去。而不再是"他发任他发，我用Java8"。就像Java6是主流的时候，我们认为Java8不会替代6一样，所以随着时间的到来，Java17代替Java8也是必然的！那么 就让我们来回顾并且学习一下这些新特性吧！！！
JAVA8~17新特性
weixin_72388638的博客
07-12 812
你还会继续使用java8吗？
Java9、10、11、12、13、14、15、16、17个版本新特性
small_to_large的博客
04-17 7417
Java9新特性 1 模块化系统 模块(module)的概念，其实就是package外再裹一层，也就是说，用模块来管理各个package，通过声明某个package暴露，不声明默认就是隐藏。因此，模块化使得代码组织上更安全，因为它可以指定哪些部分可以暴露，哪些部分隐藏。 导出模块 被引用模块需要导出指定的文件夹，并且在根目录下定义 module-info.java 文件，编写需要导出的文件包全路径名。 module modulea { exports com.lz.java9.bean2;
Java17新特性详解含示例代码（值得珍藏）
最新发布
01-20
【Java 17新特性详解含示例代码】 Java 17作为Java的最新版本，引入了一系列提升...通过这些新特性，Java 17不仅提高了开发者的生产力，还强化了Java语言的性能和安全性，为未来的Java应用程序开发奠定了坚实的基础。
Java-Java8十大特性详解教程
11-08
Lambda表达式是Java 8中最显著的特性之一，它简化了函数式编程，使得处理集合数据变得更加简洁。Lambda允许你将匿名函数作为方法参数，或者作为一个可以赋值的对象。它们可以替代那些只包含单个抽象方法的接口的...
java基础教程----精华版
09-22
这个"java基础教程----精华版"显然是一份精心整理的资料，旨在帮助初学者快速掌握Java编程的基础知识。下面将详细介绍Java语言的核心概念和关键知识点。 1. **Java语法基础**： - **变量**：在Java中，变量是存储...
Java基础8共17页.pdf.zip
10-30
【Java基础8共17页.pdf.zip】是一个压缩文件，其中包含了关于Java编程语言基础知识的教程，共计17页。这个文件很可能是针对初学者设计的，旨在帮助他们理解和掌握Java编程的核心概念。标签"Java基础8共17页.pdf....
Java零基础 - Java语言特性简介.md
08-11
本文档介绍了Java语言的一些基本特性和常见用法，并附带了一个简单的Java示例代码。 内容概要 本文档涵盖以下内容： Java语言的面向对象编程特性 Java的跨平台性和内存管理机制 Java的异常处理机制 一个简单的Java...
JavaSE学习笔记——Java8-17新特性
hongjianxiang的博客
03-06 257
Java学习笔记之Java新特性
Java 14 中令人期待的五大新特性！
数智物语
11-28 2098
文章发布于公号【数智物语】（ID：decision_engine），关注公号不错过每一篇干货。 作者|Sylvain Saurel 译者 |苏本如，责编 | 郭芮 出品 | CSDN（ID：CSDNnews） 随着新的 Java 发布生命周期的到来，新版本预计将于 2020 年 3 月发布，本文将对其中的 5 个主要特性作些概述。 ...
Java8 - Java17新特性说明
h295928126的博客
07-06 3561
Java8 - Java17新特性说明
Java8-17新特征总结
木子Teng的博客
08-20 523
Java8-17新特征
JDK8-17新特性总结
长安不及十里的博客
07-01 3328
最近写项目用到了Spring3.0，JDK8不行了，一看原来JDK已经更新到了22了，下面是我总结的一些新特性。
JDK8-JDK17新特性总结
BASK2311的博客
07-02 2648
前言：最近写项目用到了Spring3.0，JDK8不行了，一看原来JDK已经更新到了22了，下面是我总结的一些新特性 具体可以参考：openjdk.org/projects/jd…Lambda表达式是Java 8引入的一个重要特性，它允许以更简洁的方式编写匿名函数，Lambda表达式可以看作是一种轻量级的函数式编程的语法表示 Lambda表达式的基本语法如下： rust复制代码Lambda表达式包含以下几个部分：Lambda表达式的主要用途是简化代码，尤其是在使用函数式接口时非常方便。函数式接口是只包
Java14新特性-instanceof模式匹配
jun1989591的博客
04-30 1309
Java14中对instanceof进行了升级，不仅仅是直接用来进行类型匹配，还可以直接转换成相应的实例。 在Java14之前只能这样写： public class Java14Before { public static void main(String[] args) { Person person = new Person("小明", 10, "男");...
Java9到Java11新特性详解 - 宋红康教程
本教程详细介绍了Java 9、10和11这三个重要版本的新特性，由知名讲师宋红康讲解，旨在帮助初学者和有一定基础的学习者深入理解Java最新版本的变化。教程内容丰富，不仅涵盖了Java的基础和高级知识，还与时俱进地加入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值