本文深入探讨Java 8的重要特性，包括Lambda表达式、函数式接口、方法引用与构造器引用、强大的Stream API以及Optional类。Lambda简化了代码，Stream API提供了高效的处理数据方式，而Optional类则帮助避免空指针异常。通过实例分析，了解如何使用这些新特性提高代码质量和执行效率。
目录
Java8概述
- Java 8 (又称为jdk 1.8) 是Java 语言开发的一个主要版本。
- Java 8 是oracle公司于2014年3月发布，可以看成是自Java 5 以来最具革命性的版本。Java 8为Java语言、编译器、类库、开发工具与JVM带来了大量新特性。
- 下图为Java8新特性图形概括
- 日期API
- 类型注解、重复注解
- 集合底层延迟创建数组、HashMap变成红黑树
- Java8新特性好处概括
- 速度更快
- 代码更少(增加了新的语法：Lambda 表达式)
- 强大的Stream API
- 便于并行
- 最大化减少空指针异常：Optional类
- Nashorn引擎，改进之前JDK6的允许在JVM上运行JS应用引擎（目前Java虚拟机是最强的）
- 演示Nashorn引擎在JVM上运行JS应用 jjs.exe
- 演示Nashorn引擎在JVM上运行JS应用 jjs.exe
并行流与串行流
- 并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。相比较串行的流，并行的流可以很大程度上提高程序的执行效率，因为更大程度发挥CPU的作用。
- Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。Stream API 可以声明性地通过parallel() 与sequential() 在并行流与顺序流之间进行切换。
Lambda表达式
- Lambda 是一个匿名函数，我们可以把Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。
- 简单来说就是别人用的好Java也要学着用
- Lambda表达式的本质：是函数式接口（的匿名实现类）的实例
- 格式：
- 结构说明:
- -> : Lambda操作符,也可以称为箭头操作符
- ->的左边：接口中的抽象方法的形参列表
- ->的右边：重写的抽象方法的方法体
- 组合：
- 匿名内部类数据类想 变量名 = 接口中的抽象方法的形参列表 -> {重写的抽象方法的方法体}
- 特殊写法注意：
- 该接口只有一个待实现的方法，也就是函数式接口（后面会细说），二者配合使用
- 形参列表的参数可以选择性声明数据类型
- 如果形参列表的只有一个参数,小括号()可以省略
- 如果lambda体只有一条执行语句（可能是return语句），省略这一对{}和return关键字
- 下面"总结分析"有详细说明
- 举例：
- Comparator<Integer> comparable2 = (o1, o2) -> Integer.compare(o1, o2);
- Runnable r2 = () -> { System.out.println("我爱广东广州塔"); };
- 结构说明:
- 总结分析：
- 可以省略new 接口<泛型>是因为编译器通过变量数据类型<泛型>就知道你要创建的是接口
- 可以省略重写的方法名是因为Lambda表达式规定接口只允许有一个待实现的方法,既然只有一个方法就不需要强调去区分
- 匿名内部类的非匿名变量中的数据类型已经声明了接口泛型,意味着接口的所有数据类型已经确定,因此里面的方法的形参列表也是可以选择性声明数据类型的
- 如果方法形参只有一个参数,编译器也知道你这个位置是在Lambda操作符"->"左边,是写方法形参的,因此小括号可以省略.但多个参数时就要用小括号括起来,如果没有参数也需要用括号括起来,不然就是"="与"->"对接编译器就会判定为漏写方法形参
- 如果lambda体只有一条执行语句（可能是return语句），省略这一对{}和return关键字,因为编译器也知道你这个位置是在Lambda操作符"->"右边,且只有一条执行语句,因此可以省略{}.根据方法返回值是否为void就可以省略return;
代码举例入门Lambda表达式
package javase18;
import org.junit.Test;
import java.util.Comparator;
/*Lambda表达式使用举例
* 使用条件是Lambda表达式只有一个要实现的方法*/
public class NewFeature1 {
@Test
public void test1() {
//普通写法
Runnable r1 = new Runnable() {//实现Runnable的匿名实现类的非匿名对象
@Override
public void run() {
System.out.println("我爱北京天安门");
System.out.println("************");
}
};
r1.run();//单线程执行
//Lambda表达式写法改写普通写法的方式1: "->"为Lambda操作符,也可称为箭头操作符
/*格式:匿名内部类数据类想 变量名 = 匿名内部类重写的唯一方法的形参列表 -> {方法体}*/
Runnable r2 = () -> {
System.out.println("我爱广东广州塔");
};//如果方法体只有一条执行语句.则大括号可有可无
r2.run();
}
@Test
public void test2() {
//普通写法
Comparator<Integer> comparable1 = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return Integer.compare(o1, o2);
}
};
int compare1 = comparable1.compare(12, 1);
System.out.println(compare1);//1,也就是左边参数比右边大
System.out.println("*******************");
//Lambda表达式写法2
Comparator<Integer> comparable2 = (o1, o2) -> Integer.compare(o1, o2);
int compare2 = comparable2.compare(12, 1);
System.out.println(compare2);//1,也就是左边参数比右边大
//方法引用写法写实现Comparator接口的匿名内部类
Comparator<Integer> comparable3 = Integer::compare;
int compare3 = comparable2.compare(12, 1);
System.out.println(compare3);//1,也就是左边参数比右边大
}
}
Lambda表达式六种表现形式
package javase18;
import org.junit.Test;
import java.util.Comparator;
import java.util.function.*;
/**
* Lambda表达式使用深究——六种表现形式
*/
public class NewFeature2 {
//语法格式一: 无参无返回值
@Test
public void test1() {
// Runnable r1 = new Runnable() {//实现Runnable的匿名实现类的非匿名对象
// @Override
// public void run() {
// System.out.println("普通写法无参无返回值的匿名实现类");
// System.out.println("************");
// }
// };
// r1.run();
Runnable r2 = () -> System.out.println("Lambda写法无参无返回值的匿名实现类");
r2.run();
}
//语法格式二: 需要一个参数,但无返回值
@Test
public void test2() {
Consumer<String> c1 = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
c1.accept("普通写法一个参数无返回值的匿名实现类");//普通写法一个参数无返回值的匿名实现类
Consumer<String> c2 = (String s) -> System.out.println(s);
c2.accept("Lambda写法一个参数无返回值的匿名实现类");//Lambda写法一个参数无返回值的匿名实现类
}
//语法格式三:数据类型可以省略,由编译器推断得出,称为类型推断
@Test
public void test3() {
Consumer<String> c1 = (s) -> System.out.println(s);//变量的数据类型及声明的泛型参数决定了匿名内部类
c1.accept("Lambda写法一个参数无返回值的匿名实现类,参数类型可以省略");//Lambda写法一个参数无返回值的匿名实现类
}
//语法格式四: 只有一个参数,但无返回值,参数列表的小括号可以省略
@Test
public void test4() {
Consumer<String> c1 = s -> System.out.println(s);
c1.accept("只有一个参数,但无返回值,参数列表的小括号可以省略的匿名实现类");//只有一个参数,但无返回值,参数列表的小括号可以省略的匿名实现类
}
//语法格式五:Lambda需要两个或者以上的参数,多条执行语句,并且有返回值
@Test
public void test5() {
// Comparator<Integer> com1 = new Comparator<Integer>() {
// @Override
// public int compare(Integer o1, Integer o2) {
// System.out.println("开始对比");
// return o1.compareTo(o2);
// }
// };
// int compare1 = com1.compare(1, 2);//开始对比
// System.out.println(compare1);//-1
// Comparator<Integer> com2 = (Integer o1, Integer o2) -> {
// System.out.println("开始对比");
// return o1.compareTo(o2);
// };
// int compare2 = com2.compare(1, 2);//开始对比
// System.out.println(compare2);//-1
Comparator<Integer> com3 = (o1, o2) -> {
System.out.println("开始对比");
return o1.compareTo(o2);
};
int compare3 = com3.compare(1, 2);//开始对比
System.out.println(compare3);//-1
}
//语法格式6: 当Lambda方法体只要一条语句时,return与大括号如果有可以省略
@Test
public void test6() {
Comparator<Integer> com1 = (o1, o2) -> o1.compareTo(o2);//返回值和大括号都可以省略
int compare1 = com1.compare(1, 2);
System.out.println(compare1);//-1
Consumer<String> con1 = (s) -> System.out.println(s);//大括号可以省略
con1.accept("你好");//你好
}
}
函数式(Functional)接口
函数式接口概述
- 如果一个接口中,在忽视了别的结构情况下只声明了一个抽象方法,则此接口称为函数接口
- 在接口上方可以选择性添加@FunctionalInterface注解，功能与@Override一样，只是作为一个校验，验证注解下的接口类是否为函数接口。如果不是就会出现编译错误提示，提高代码排除故障的功能。同时javadoc也会包含一条声明，说明这个接口是一个函数式接口
- 在
java.util.function包下定义了Java 8 的丰富的函数式接口 - Java从诞生日起就是一直倡导“一切皆对象”，在Java里面面向对象(OOP)编程是一切。但是随着python、scala等语言的兴起和新技术的挑战，Java不得不做出调整以便支持更加广泛的技术要求，也即java不但可以支持OOP（面向对象）还可以支持OOF（面向函数编程）
- 在函数式编程语言当中，函数被当做一等公民对待。在将函数作为一等公民的编程语言中，Lambda表达式的类型是函数。但是在Java8中，有所不同。在Java8中，Lambda表达式是对象，而不是函数，它们必须依附于一类特别的对象类型——函数式接口。
- 简单的说，在Java8中，Lambda表达式就是一个函数式接口的实例。这就是Lambda表达式和函数式接口的关系。也就是说，只要一个对象是函数式接口的实例，那么该对象就可以用Lambda表达式来表示。
- 所以以前用匿名实现类表示的现在都可以用Lambda表达式来写。
Java内置的函数式接口介绍及使用举例
代码演示四大核心函数式接口中的消费性接口和断定型接口
package javase18;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
public class NewFeature3 {
//java四大核心函数式接口之消费型接口
@Test
public void test1() {
//调用需要传入函数接口对象时的普通写法
happyTime(500, new Consumer<Double>() {
@Override
public void accept(Double aDouble) {
System.out.println("接收到的钱是:"+aDouble);//接收到的钱是:500.0
}
});
//调用需要传入函数接口对象时的lambda写法
happyTime(500,aDouble -> System.out.println("接收到的钱是:"+aDouble));//接收到的钱是:500.0
}
//编写一个函数,函数的参数有消费性接口Consumer<T>
public void happyTime(double money, Consumer<Double> con){
con.accept(money);//执行Consumer匿名实现类实例的accept方法
}
//编写一个函数.用于过滤传入集合的字符串,过滤规则由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;
}
//java四大核心函数式接口之断定型接口
@Test
public void test2(){
List<String> strings = Arrays.asList("北京","南京","天津");
// List<String> list1 = filterString(strings, t -> "北京" != t);//自定义筛选字符串规则,不要元素是"北京"
// System.out.println(list1);//[南京, 天津]
List<String> list2 = filterString(strings, t -> t.contains("京"));//自定义筛选字符串规则,只要含字符串"京"的元素
System.out.println(list2);//[北京, 南京]
}
}方法引用与构造器引用
方法引用
-
方法引用:当要传递给Lambda体的操作，已经有实现的方法了，且要求接口中的抽象方法和返回值类型、形参列表和该方法被实现引用的方法的形参列表和返回值类型相同，可以使用方法引用！！！！并且只适用于下面的“情况一”、“情况二”。
并不适用“情况三”——“类::实例方法名” - 方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖。
- 方法引用本质上就是Lambda表达式,因此方法引用也是函数式接口的实现类
<
最低0.47元/天 解锁文章
扫一扫
1926
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
