一、前言

二、JAVA8

Lambda表达式

Stream API

创建方式

中间操作

终止操作

Optional类

三、JAVA9

模块机制

JShell交互式编程

接口

新增集合工厂方法

四、JAVA10

局部变量类型判断

五、JAVA11

Lambda表达式补充

String方法的补充

全新的HttpClient 使用

六、JAVA12-16

新的switch语法

文本块

新的instanceof语法

空指针异常的改进

记录类型（record）

七、Java 17

密封类型（sealed关键字）

总结

一、前言

springboot3 最低dk17，java8估计要被弃用了

二、JAVA8

Lambda表达式

相当于匿名内部类的简写

public void test() {Thread t1 = new Thread(()-> System.out.println("你好"));  //lambda 表达式  t1.start();}

规范：

(名称)-> {代码语句，包括返回值}

和匿名内部类不同，只支持接口，不支持抽象类

接口有且只有一个抽象方法

接口上有@FunctionalInterface 标识

自定义接口

@FunctionalInterface
public interface myBy {Integer getAdd(Integer a,Integer b);}

使用

public void test02() {myBy  myBy=(a,b)-> a+b;    //实现接口System.out.println(myBy.getAdd(1,2));}

有现成的实现可以直接代替

private static Integer Add(Integer a, Integer b){ //加法return a+b;}public void test02() {// myBy  myBy=(a,b)-> a+b; myBy my=(OneTest::Add);    //借用别人的实现方法System.out.println(myBy.getAdd(1,2));}

线程安全性，（十分局限，不允许对外部数据进行赋值操作）

错误案例

  List<Integer> list=Arrays.asList(1,1,23,23,456,9,9,12,678,23);  Integer a=0;  list.forEach(i->{a+=i; //请注意，这个写法是错误的，lambda表达式为了保证线程安全不允许对外部数据进行赋值操作，当前编译阶段就会报错});  System.out.println(a);

Stream API

函数式编程

作用：对集合、数组操作

对比Collections（集合操作工具类），Arrays（数组操作工具类）：

Collections和Arrays会改变原来的集合数据;Stream则不会，它会返回一个新的带有结果的Stream;不想改变原有数据的情况下操作集合和数组可以使用Stream;操作集合和数组建议使用这种方式，进一步减少被优化的可能，能少写for就少写一个

创建方式

public void test012()  {List<Integer> list=Arrays.asList(1,23,456,12,678,23);    // 顺序流 按元素顺序返回Stream<Integer> stream1 = list.stream();   // 并行流 ，同时取数据    Stream<Integer> stream2 = list.parallelStream();    //数组类型    int[] arr =new int[]{1,2,3,4,5};    IntStream stream3 = Arrays.stream(arr);    Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5);
}//Math.random() 生成 [0,1)的 double数
//生成10个数
Stream.generate(Math::random).limit(10).forEach(System.out::println);

中间操作

数据过滤(filter)

//数据过滤 保留大于10的数据
// 当filter(e->{return true;}) 返回true才保留当前操作数据
List<Integer> list=Arrays.asList(1,23,456,9,12,678,23);
list.stream().filter(e->e>10).forEach(System.out::println);
//结果 23,456,12,678,23

截取片段(limit)

List<Integer> list=Arrays.asList(1,23,456,9,12,678,23);
//获得前4条数据 结果 1,23,456,9
list.stream().limit(4).forEach(System.out::println);

舍弃片段(skip)(截取片段相反)

List<Integer> list=Arrays.asList(1,23,456,9,12,678,23);
//丢弃前面4个数据，结果为12,678,23
list.stream().skip(4).forEach(System.out::println);

去重(distinct)

List<Integer> list=Arrays.asList(1,1,23,23,456,9,9,12,678,23);
//去重 根据equals和hashCode, 结果为：1,23,456,9,12,678list.stream().distinct().forEach(System.out::println);

映射(map)

自定义操作

map(e->{return "结果"}) 和filter类似，只是return是自定义的结果

List<String> list=Arrays.asList("aa","bb","cc","dd");// 还是操作数据 ，自定义操作数据,用来返回一些特定数据; str.toUpperCase()转化成大写// map(e->{return "结果"}) 和filter类似 只是return是自定义的结果//结果 AA,BB,CC,DDlist.stream().map(str->str.toUpperCase()).forEach(System.out::println);

排序(sorted)

List<Integer> list=Arrays.asList(1,1,23,23,456,9,9,12,678,23);// 自然排序 ,结果：1,1,9,9,12,23,23,23,456,678// 对类对象的排序需要实现 Comparable 接口list.stream().sorted().forEach(System.out::println);//自定义排序，即使是类对象也不用实现Comparable 接口//自定义排序结果为：687,456,23,23,23,12,9,9,1,1list.stream().sorted((a,b)->{return  Integer.compare(b,a); }).forEach(System.out::println);

终止操作

匹配与查找

allMatch(lambda) 检查是所有元素满足条件
anyMatch(lambda) 检查是否至少匹配一个元素
noneMatch(lambda) 检查是否没有匹配的元素
findFirst() 返回第一个元素
findAny() 返回当前流中的任意元素
count() 返回流元素的总个数
max(Double::compare) 返回流中最大值
min(Double::compare)返回流中最小值
forEach(lambda) 内部迭代

匹配与查找示例：

// 1、allMatch 验证是否全部元素满足条件
List<Integer> list=Arrays.asList(1,1,23,23,456,9,9,12,678,23);
// 是否全部元素大于 30；返回false,true；当前结果为false
boolean b = list.stream().allMatch(e -> e > 30);
System.out.println(b);//2、noneMatch 检查全部元素，是否全部不满足条件
// 全部不满足条件为true
List<Integer> list=Arrays.asList(1,1,23,23,456,9,9,12,678,23);
// 判断全部元素是否没有0，结果为true
boolean b1 = list.stream().noneMatch(e -> e == 0);
System.out.println(b1);//3、findFirst 返回第一个元素
// 当前结果为 1
List<Integer> list=Arrays.asList(1,1,23,23,456,9,9,12,678,23);
Optional<Integer> first = list.stream().findFirst();
System.out.println(first);// 4、 findAny 随机返回一个元素
List<Integer> list=Arrays.asList(1,1,23,23,456,9,9,12,678,23);
// ？？ 有BUG? 每次都是同一个结果
//Collections.shuffle(list); 还是洗牌好用Optional<Integer> first = list.stream().findAny();System.out.println(first);//5、count 求元素总数
// 结果为 10
List<Integer> list=Arrays.asList(1,1,23,23,456,9,9,12,678,23);long count = list.stream().count();System.out.println(count);//5、max最大值 自然排列取右边值//最大值Optional<Integer> max = list.stream().max(Double::compare);//Optional<Integer> max = list.stream().max((a,b)->Double.compare(a,b));System.out.println(max.get());//6、最小值 自然排列取左边值
Optional<Integer> min = list.stream().min(Double::compare);
//Optional<Integer> min = list.stream().min((a,b)->Double.compare(a,b));
System.out.println(min.get());//7、遍历//  list.forEach(System.out::println); 集合自带了遍历list.stream().forEach(System.out::println);

归约(reduce)

// 计算结果，返回计算结果
// 0初始值，lambda累加操作 (a是初始值也是下一次结果值当前初始值设置是0，b是索引为i的元素)
//结果为1235
Integer reduce = list.stream().reduce(0, (a, b) -> a + b);

收集(collect)

把结果转化为list或set等

// 把结果转化为list
List<Integer> list=Arrays.asList(1,1,23,23,456,9,9,12,678,23);
List<Integer> collect = list.stream().filter(e -> e > 10).collect(Collectors.toList());
System.out.println(collect);//把结果转化为set
List<Integer> list=Arrays.asList(1,1,23,23,456,9,9,12,678,23);
Set<Integer> collect = list.stream().filter(e -> e > 10).collect(Collectors.toSet());
System.out.println(collect);

Optional类

可以预防空指针异常，

有if(a!=null) 时就优先使用这个类；

可以将任何一个类包装进Optional类中

API方法：

//创建
Optional.of(A) // A必须非空，A为空会报错
Optional.empty() //创建一个非空的Optional实例
Optional.ofNullable(A) //A可以为空 ，A为空不会报错； 使用这个//返回数据
Optional.ofNullable(A).get() 返回包装的A
Optional.ofNullable(A).orElse(B)  当前A不为空就返回A,否则返回B，(A和B需要是同一个类型)
Optional.ofNullable(A).orElseGet() 如果有值则返回，否则返回有接口实现提供的对象
Optional.ofNullable(A).orElseThrow() 如果有值则将其返回，否则抛出由Supplier接口实现提供的异常

示例：

// 如果A为空就返回B
String A=null;
String a = Optional.ofNullable(A).orElse("A为空");
System.out.println(a);private  static void hello(String str){Optional.ofNullable(str) //包装进入Optional，空的也会放入            .ifPresent(i->{System.out.println(i); //打印            });}

Optional不太方便，Lambda里面不能执行对外部属性执行赋值操作还是挺多限制的不如使用Objects.isNull(A)

三、JAVA9

模块机制

module-info.java文件

//暴露出去
module module.a {exports com.test;
}// 只暴露给指定的模块
module module.a {exports com.test to module.b;
}//导入module.a 中暴露的内容
module module.b {requires module.a;
}//依赖的传递性
module module.a {exports com.test;requires transitive java。logging; // 传递到引用的模块
}//暴露出去，并且开放反射权限
open module module.a {exports com.test;
}

JShell交互式编程

接口

接口可以存在私有方法（私有方法必须要实现）

新增集合工厂方法

public void test04() {Map<String, Integer> map = Map.of("A", 1, "B", 2); //生成只读map    List<Integer> list = List.of(1, 2, 3, 4, 5); // 和Arrays.asList(1, 2, 3, 4, 5)一样，生成只读list        //list.add(6); 错误 list是只读的    System.out.println(map);}

四、JAVA10

局部变量类型判断

怎么变成js了，

public void test05() {var a="hello,word";  // 只能定义在方法局部变量  // var b; 错误，不能定义未赋值的变量    System.out.println(a);}

五、JAVA11

Lambda表达式补充

内可以定义 var类型变量；

String方法的补充

public void test06() {String str=" ";    System.out.println(str.isEmpty()); // 判断内容是否为空(有空格也是false)    System.out.println(str.isBlank()); //判断外形是否为空(肉眼观察,即使有空格也是true)// str.repeat(2) 重复拼接2次成新字符串// str.lines()   根据 \n分割//str.strip()  去除首位空格// str.stripLeading() 去除首部位空格// str.stripTrailing() 去除尾部空格}

全新的HttpClient 使用

public void test07() throws URISyntaxException, IOException, InterruptedException {//创建    HttpClient client=HttpClient.newHttpClient();    //构建请求    HttpRequest request = HttpRequest.newBuilder(new URI("https://www.baidu.com")).GET().build();    HttpResponse<String> send = client.send(request, HttpResponse.BodyHandlers.ofString()); //发送请求        System.out.println(send.body());
}

六、JAVA12-16

新的switch语法

老方式

private static String grade(int score){score/=10;        String Gl="";       switch (score){case 10:case 9:Gl="优秀";                break;            case 8:case 7:Gl="良好";                break;            case 6:Gl="及格";                break;            default:Gl="不及格";        }return Gl;
}

switch允许有返回值，不写break

为switch表达式

private static String grade2(int score){score/=10;    return   switch (score){case 10,9->"优秀";                case 8,7->"良好";                case 6->"及格";                default->"不及格";    };}

返回值yield

private static String grade2(int score){score/=10;    return   switch (score){case 10,9->{//可以执行其他逻辑                    System.out.println("优秀");                    yield "优秀";                }case 8,7->"良好";                case 6->"及格";                default->"不及格";    };}

文本块

public void test09()  {// 普通字符串String str="adbc\nsdawd";    System.out.println(str);    //文本块    String str2="""            文本块内容：            asaiddawjid            "sdfsef"fsef            mdkaslekf            <a herf="fsdf">             """;    System.out.println(str2);}

新的instanceof语法

旧的用法a  instanceof  Atrue: a是A的实例或者 ，a是A类的后代
新补充：a  instanceof  A b为true时候相当于多执行了一步 A  b=(A)a

可以直接转化对应的类型

//旧的写法
@Override
public boolean equals(Object obj) {if(obj ==this) return true;   if (obj instanceof Student){Student test=(Student) obj;    return  test.name.equals(this.name);}return false;
}//新写法省一行代码
@Override
public boolean equals(Object obj) {if(obj ==this) return true;   if (obj instanceof Student test){ // ture时候把obj转化成 了(Student)testreturn  test.name.equals(this.name);   }return false;}

空指针异常的改进

这个特性应该最容易感知出来（笑~）

有空指针异常时候打印的错误信息明确的指出了哪个参数空指针异常

记录类型（record）

在编译时候自动编译出 get、hashcode、equals、toString等方法

支持实现接口，不支持继承(位置已经被占用)

内部不能定义成员变量

//记录类型
public record Account(String user,String pwd) {//private String adb; 错误，不能定义成员变量       //定义方法    public void Add(){System.out.println("调用Add");    }
}
//使用
public void test010()  {Account account1=new Account("123","2334");    account1.Add();    System.out.println(account1);
}

七、Java 17

密封类型（sealed关键字）

以前final修饰的类不能被继承

sealed 修饰的类可以定点继承，只允许指定的类继承

要求：

1、可以基于普通类、抽象类、接口也可以是继承自其他抽象类的子类或是实现其他接口的类等
2、必须有子类继承，且不能是匿名内部类或者是lambda的形式
3、sealed写在原来final的位置，但是不能和final、non-selaled关键字同时出现，只能选择其一
4、继承的子类必须标记为final、sealed、non-sealed类型

示例：

//A类
public sealed class A permits B { //只允许B继承A (且B需要是final或者sealed 修饰的)    public String name;
}//B类
public non-sealed class B extends A {// B为final时候不允许其他类继承    // B为sealed 允许指定类继承    // B为B是non-sealed ,重新开放继承权限，使其他类可以继承B来间接继承A ，(关键字怎么还带个 - ，难看)
}
//C类
public class C extends B{
}
// 测试
public void test011()  {A a=new A();    B b=new B();   C c=new C();    //A是sealed ,B是non-sealed ,c依旧继承了A中name属性    c.name="王";    System.out.println(c.name);}

总结

你还会继续使用java8吗？

JAVA8~17新特性相关推荐

2022年最细Java 17新特性，是真的猛，被征服了！
SpringBoot 正式支持Java 17,Kafka3.0弃用Java8 Spring Boot 2.5.5是Spring Boot 第一个支持Java 17的版本.现在你已经可以从Spring ...
Java 17新特性，快到起飞？惊呆了！
都说Java 8 是YYDS,那你注意到 Java 17 也是长期支持版本吗?目前按计划 JDK 19 将于今年 9 月发布 SpringBoot 正式支持Java 17,Kafka3.0弃用Java ...
深圳Java培训学习：Java8.0新特性之Lambda表达式--【千锋】
深圳Java培训学习:Java8.0新特性之Lambda表达式–[千锋] 前言 Java 8 已经发布很久了,很多报道表明Java 8 是一次重大的版本升级.本篇文章,主要给大家介绍的是lambda表 ...
学习笔记之-java8的新特性-函数式接口,lambda表达式,方法引用,Stream API，Optional类
1.Lambda表达式用匿名内部类的方法去创建多线程1.new Thread2.参数传递new Runnable3.重写run方法4.在run方法中去设置线程任务5.调用start问题:我们最终目标 ...
java8的新特性_Java8的
java8的新特性 Java8没有安排释放,直到2014年3月,但早期发行版本已经可用了一段时间. 一些最有趣的新功能是: 流功能接口默认方法 Lambdas Java时间流新的java.ut ...
JAVA8的新特性之Stream
JAVA8的新特性之Stream 1.概述: 在jdk1.8中,提供了一个Stream,可以对数据进行过滤 2.好处: 比不断自定义循环,要简单很多 Stream类型数据的获取 1.Collectio ...
JAVA8的新特性之函数式接口
JAVA8的新特性之函数式接口 1.Lambda表达式使用的前提,就是接口必须是一个函数式接口 2.定义在接口中,只有一个抽象方法 3.检查是否是函数式接口用的注解 @FunctionalInter ...
java8：新特性及Lamber表达式语法及四大函数接口
java8:新特性及Lamber表达式如果左侧只有一个参数可以省略括号,如果右侧只有一个表达式可以省略括号如果左侧有一个参数也可以添加括号,可以不写参数类型,有类型推断如果右侧有返回值,一个表达 ...
k8s v1.17 新特性预告: 拓扑感知服务路由
大家好,我是 roc,来自腾讯云容器服务(TKE)团队,今天给大家介绍下我参与开发的一个 k8s v1.17 新特性: 拓扑感知服务路由. 01 名词解释拓扑域: 表示在集群中的某一类 " ...

JAVA8~17新特性

一、前言

二、JAVA8

Lambda表达式

Stream API

创建方式

中间操作

终止操作

Optional类

三、JAVA9

模块机制

JShell交互式编程

接口

新增集合工厂方法

四、JAVA10

局部变量类型判断

五、JAVA11

Lambda表达式补充

String方法的补充

全新的HttpClient 使用

六、JAVA12-16

新的switch语法

文本块

新的instanceof语法

空指针异常的改进

记录类型（record）

七、Java 17

密封类型（sealed关键字）

总结

JAVA8~17新特性相关推荐

最新文章

热门文章