Java8新特性 (jdk1.8)
**Java 8(又称为jdk 1.8)**是Java语言开发的一个主要版本。
Java 8是oracle公司于2014年3月发布,可以看成是自Java5以来最具革命性的版本。
Java 8为Java语言、编译器、类库、开发工具与JVM带来了大量新特性。
Java8 新特性的好处:
- 速度更快
- 代码更少(增加了新的语法: Lambda表达式 )
- 强大的 Stream API
- 便于并行
- 最大化减少空指针异常:Optional
- Nashorn引擎,允许在JVM上运行JS应用
① Lambda表达式
为什么使用Lambda表达式?
Lambda 是一个 匿名函数 ,我们可以把Lambda表达式理解为是 一段可以传递的代码 (将代码像数据一样进行传递)。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格,使Java的语言表达能力得到了提升。
Lambda表达式 在 Java 8 语言中引入 的 一 种 新的语法元素和操作符。
这个操作符为 “ -> ” 该操作符被称为 Lambda操作符 或 箭头操作符 。
它将 Lambda 分为两个部分:
- 左侧:
指定了 Lambda 表达式需要的 参数列表 - 右侧:
指定了 Lambda体 是抽象方法的实现逻辑,也 即Lambda 表达式要执行 的功能 。
package com.cs.java8;
import org.junit.Test;
import java.util.Comparator;
public class LambdaTest {
@Test
public void test1(){
//普通写法:
Runnable r1 = new Runnable() {
@Override
public void run(){
System.out.println("我爱北京天安门");
}
};
r1.run();
System.out.println("============================");
//Lambda表达式写法:
Runnable r2 = () -> System.out.println("华东师范给大家个");
r2.run();
}
@Test
public void test2(){
//1.普通写法
Comparator<Integer> com1 = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return Integer.compare(o1, o2);
}
};
System.out.println(com1.compare(67, 8));
System.out.println("-----------------------------------------------");
//2.Lambda表达式写法:
Comparator<Integer> com2 = (o1, o2) -> Integer.compare(o1, o2);
System.out.println(com2.compare(4 , 7));
System.out.println("-----------------------------------------------");
//3.方法引用的写法:
Comparator<Integer> com3 = Integer :: compare;
System.out.println(com3.compare(55 ,55));
}
}
② Lambda表达式的6种语法格式
2.1 语法格式一: 无参、无返回值
//普通写法:
Runnable r1 = new Runnable() {
@Override
public void run(){
System.out.println("我爱北京天安门");
}
};
-------------------------------------------
//Lambda表达式写法:
Runnable r2 = () -> {System.out.println("华东师范给大家个");};
2.2 语法格式二: Lambda 需要一个参数, 但是没有返回值。
//普通写法:
Consumer<String> consumer1 = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
-----------------------------------------
//Lambda表达式写法:
Consumer<String> consumer2 = (String s) -> {System.out.println(s);};
2.3 语法格式三: 数据类型可以省略
因为可由编译器推断得出,称为“类型推断“
//普通写法:
Consumer<String> consumer1 = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
-----------------------------------------
//Lambda表达式写法:
Consumer<String> consumer2 = (String s) -> {System.out.println(s);};
//数据类型省略写法:
Consumer<String> consumer2 = (s) -> {System.out.println(s);};
2.4 语法格式四: Lambda 若只需要一个参数时, 参数的小括号可以省略
//普通写法:
Consumer<String> consumer1 = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
-----------------------------------------
//Lambda表达式写法:
Consumer<String> consumer2 = (String s) -> {System.out.println(s);};
//数据类型省略写法:
Consumer<String> consumer3 = (s) -> {System.out.println(s);};
//参数小括号省略写法:
Consumer<String> consumer3 = s -> {System.out.println(s);};
2.5 语法格式五: Lambda 需要两个或以上的参数,多条执行语句,并且可以有返回值
//普通写法
Comparator<Integer> comparator1 = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
System.out.println("实现函数式接口方法");
return Integer.compare(o1, o2);
}
};
----------------------
//Lambda表达式写法:
Comparator<Integer> comparator2 = (o1, o2) -> {
System.out.println("实现函数式接口方法");
return Integer.compare(o1, o2);
};
2.6 语法格式六: 当 Lambda 体只有 一条 语句时, return 与大括号 若有,都可以省略
//普通写法
Comparator<Integer> comparator1 = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return Integer.compare(o1, o2);
}
};
----------------------
//Lambda表达式写法:
Comparator<Integer> comparator2 = (o1, o2) -> Integer.compare(o1, o2);
类型推断
③ 函数式(Functional)接口
- 只包含一个抽象方法的接口,称为 函数式接口
- 你可以通过 Lambda 表达式来创建该接口的对象。(若 Lambda 表达式抛出一个受检异常 即:非运行时异常 )),那么该异常需要在目标接口的抽象方法上进行声明)。
- 我们可以在一个接口上使用 @FunctionalInterface 注解,这样做可以检查它是否是一个函数式接口。同时 javadoc 也会包含一条声明,说明这个接口是一个函数式接口。
- 在 java.util.function 包下定义 了 Java 8 的丰富的函数式 接口
Lambda表达式的本质: 作为函数式接口的实例
3.1 如何理解函数式接口
-
Java 从诞生日起就是一直倡导 “一切皆对象”, 在 Java 里面面向对象 (编程是一切。但是随着 python 、 scala 等语言的兴起和新技
的挑战 Java 不得不做出调整以便支持更加广泛的技术要求,也即 java 不但可以支持 OOP 还可以支持 OOF (面向函数编程)
-
在函数式编程语言当中,函数被当做一等公民对待。在将函数作为一等公民的编程语言中, Lambda 表达式的类型是函数。但是在
Java8 中,有所不同。在Java8 中, Lambda 表达式是对象,而不是函数,它们必须依附于一类特别的对象类型 函数式接口 。
-
简单的说,在 Java8 中,Lambda 表达式就是一个函数式接口的实例。 这就是Lambda 表达式和函数式接口的关系。也就是说,
要一个对象是函数式接口的实例,那么该对象就可以用 Lambda 表达式来表示。
-
所以以前用 匿名实现类 表示的现在都可以用 Lambda 表达式来写。
3.2 Java内置四大核心函数式接口
(1) Consumer< T > 消费型接口
public class LambdaTest2 {
@Test
public void test1(){
//普通写法
happyTime(500.00, new Consumer<Double>() {
@Override
public void accept(Double aDouble) {
System.out.println("happy time cost " + aDouble);
}
});
//函数式接口,Lambda表达式
happyTime(488.00, (money) -> System.out.println("happy time " + money));
}
public void happyTime(Double money, Consumer<Double> con) {
con.accept(money);
}
}
(2) Predicate< T> 断定型接口
@Test
public void test2(){
List<String> list = Arrays.asList("hello","happy","good","morning","night","love");
//普通写法
List<String> filterStr1 = filterString(list, new Predicate<String>() {
@Override
public boolean test(String s) {
return s.length() > 4;//过滤出长度>4 的字符串
}
});
System.out.println(filterStr1);
//函数式接口,Lambda表达式 写法
List<String> filterStr2 = filterString(list,(s) -> s.length() > 4);
System.out.println(filterStr2);
}
//根据给定的规则,过滤集合中的字符串。此规则由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;
}
④ 方法引用与构造器引用
4.1 方法引用(Method References)
- 当要传递给Lambda体的操作已经有实现的方法了,可以使用方法引用!
- 方法引用可以看做是Lambda表达式深层次的表达。换句话说,方法引用就是Lambda表达式,也就是函数式接口的一个实例,通过方法的名字来指向一个方法,可以认为是Lambda表达式的一个语法糖。
- 要求 : 实现接口的抽象方法的参数列表和返回值类型,必须与方法引用的方法的参数列表和返回值类型保持一致!
- 格式 : 使用操作符 “ :: ” 将类(或对象) 与 方法名 分隔开来。
- 如下三种主要使用情况:
- 对象 :: 实例方法名
- 类 :: 静态方法名
- 类 :: 实例方法名
⑤ 强大的 Stream API
- Java8中有两大最为重要的改变。第一个是 Lambda表达式 ; 另外一个则是 Stream API。
- Stream APl ( java.util.stream) 把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充,因为Stream API可以极大提供Java程序员的生产力,让程序员写出高效率、干净、简洁的代码。
- Stream是Java8中处理集合的关键抽象概念,它可以指定你希望对集合进行的操作,可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API对集合数据进行操作,就类似于使用SQL执行的数据库查询。也可以使用Stream API来并行执行操作。简言之,Stream API提供了一种高效且易于使用的处理数据的方式。
5.1 为什么使用 Stream API
- 实际开发中,项目中多数数据源都来自于Mysql,Oracle等。但现在数据源可以更多了,有MongDB,Radis等,而这些NoSQL的数据就需要Java层面去处理。
- Stream和 Collection集合的区别:Collection是一种静态的内存数据结构,而Stream是有关计算的。前者是主要面向内存,存储在内存中,后者主要是面向CPU,通过CPU实现计算。
5.2 什么是 Stream
Stream到底是什么呢?
是数据渠道,用于操作数据源(集合、数组等)所生成的元素序列。
“集合讲的是数据,Stream讲的是计算!”
注意:
- Stream自己不会存储元素。
- stream不会改变源对象。相反,他们会返回一个持有结果的新Stream。
- Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
5.3 Stream 的三个步骤
-
1 - 创建 stream
一个数据源(如 集合、数组),获取一个流
-
2 - 中间操作
一个中间操作链,对数据源的数据进行处理 -
3 - 终止操作 (终端操作)
一旦执行终止操作,就执行中间操作链,并产生结果。之后,不会再被使用.
5.4 Stream的实例化
(1) 创建Stream方式一: 通过集合
Java8 中的Collection接口被扩展,提供了两个获取流的方法:
- default Stream< E > stream() : 返回一个顺序流
- default Stream< E > parallelStream() : 返回一个并行流
//创建Stream流的方式一: 通过集合
@Test
public void test1(){
List<Employee> employeeList = EmployeeData.getEmployees();
//default Stream<E> stream():返回一个顺序流
Stream<Employee> stream = employeeList.stream();
//default Stream<E> parallelStream(): 返回一个并行流
Stream<Employee> employeeStream = employeeList.parallelStream();
}
(2)创建Stream方式二: 通过数组
Java8中的Arrays的静态方法stream()可以获取数组流 :
-
**static < T > Stream< T > stream(T[ ] array) : 返回一个流 **
List<Employee> employeeList = EmployeeData.getEmployees(); Employee[] employeeArray = employeeList.toArray(new Employee[employeeList.size()]); Stream<Employee> stream = Arrays.stream(employeeArray);
重载形式,能够处理对应基本类型的数组:
- **public static IntStream stream( int[ ] array ) **
- **public static LongStream stream( long[ ] array ) **
- **public static DoubleStream stream( double[ ] array ) **
int[] arr = new int[]{1,3,4,5,7};
//public static IntStream stream(int[] array)
IntStream stream1 = Arrays.stream(arr);
(3)创建Stream方式三: 通过Stream的of
可以调用Stream类静态方法 of(),通过显示值创建一个流。它可以接收任意数量的参数。
- **public static< T > Stream< T > of(T… values) : 返回一个流 **
Stream<Integer> integerStream = Stream.of(1, 3, 8, 2, 9);
(4) 创建 Stream方式四: 创建无限流
可以使用静态方法 Stream.iterate()和 Stream.generate(),创建无限流。
- 迭代
public staticStream iterate(final T seed, final UnaryOperator f) - 生成
public static Stream generate(Suppliers)
//迭代: public static<T>Stream<T> iterate(final T seed, final UnaryOperator<T> f)
//遍历前10个偶数
Stream.iterate( 0, t -> t + 2).limit(10).forEach(System.out::println);
//生成: public static<T> Stream<T> generate(Supplier<T>s)
//生成10个随机数
Stream.generate(Math::random).limit(10).forEach(System.out::println);
5.5 Stream的中间操作
多个中间操作可以连接起来形成一个流水线,除非流水线上触发终止操作,否则中间操作不会执行任何的处理! 而在终止操作时一次性全部处理, 称为“惰性求值”。
(1) 筛选与切片
//1-筛选与切片
@Test
public void test1(){
List<Employee> employeeList = EmployeeData.getEmployees();
//1- filter(Predicate p) 接收Lambda,从流中排除某些元素
Stream<Employee> stream = employeeList.stream();
//查询员工表中薪资大于7000的员工信息
stream.filter(e -> e.getSalary() > 7000.00).forEach(System.out::println);
System.out.println("---------------------------");
//2- limit(long maxSize)截断流,使其元素不超过给定数量
employeeList.stream().limit(4).forEach(System.out::println);
System.out.println("---------------------------");
//3- skip(long n) 跳过元素,返回一个扔掉了前n个元素的流。若流中元素不足n个,则返回一个空流。与 limit(n)互补
employeeList.stream().skip(4).forEach(System.out::println);
System.out.println("---------------------------");
//4- distinct() 筛选,通过流所生成元素的 hashCode()和 equals()去除重复元素
employeeList.stream().distinct().forEach(System.out::println);
}
(2) 映射
public class StreamAPITest1 {
//2- 映射
@Test
public void test2(){
List<Employee> employeeList = EmployeeData.getEmployees();
// 1- map(Function f) 接收一个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个新的元素。
List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
System.out.println("---------------------------------------------");
// 练习:获取员工姓名长度大于3的员工的姓名。
employeeList.stream().map(e -> e.getName()).filter(name -> name.length() > 3).forEach(System.out::println);
System.out.println("--------------------------------------");
// 2- flatMap(Function f) 接收一个函数作为参数,将流中的每个值都换成另一个流,然后把所有流连接成一个流
Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest1::fromStringToStream);
streamStream.forEach(s -> {
s.forEach(System.out::println);
});
System.out.println("--------------------------------------");
Stream<Character> characterStream = list.stream().flatMap(StreamAPITest1::fromStringToStream);
characterStream.forEach(System.out::println);
}
//将字符串中的多个字符构成的集合转换为对应的Stream的实例
public static Stream<Character> fromStringToStream(String str) {//aa
ArrayList<Character> list = new ArrayList<>();
for (Character c : str.toCharArray()) {
list.add(c);
}
return list.stream();
}
}
map() :相当于 add()
flatMap : 相当于 addAll()
(3) 排序
//3- 排序
@Test
public void test3(){
// sorted() 产生一个新流,其中按自然顺序排序
List<Integer> integerList = Arrays.asList(78, 56, 199, 2, 36, 5, 67, 89, 200, 6, 5);
integerList.stream().sorted().forEach(System.out::println);
System.out.println("------------------------------------------");
// sorted(Comparator com)产生一个新流,其中按比较器顺序排序
List<Employee> employeeList = EmployeeData.getEmployees();
employeeList.stream().sorted((e1, e2) -> Integer.compare(e1.getAge(), e2.getAge()))
.forEach(System.out::println);
}
5.6 Stream的终止操作
(1) 匹配与查找
public class StreamAPITest2 {
//1-匹配与查找
@Test
public void test1(){
List<Employee> employeeList = EmployeeData.getEmployees();
// aLLMatch(Predicate p)—一检查是否匹配所有元素。
// 练习:是否所有的员工的年龄都大于18
boolean allMatch = employeeList.stream().allMatch(e -> e.getAge() > 18);
System.out.println(allMatch);//false
// anyMatch(Predicate p)—-检查是否至少匹配一个元素练习:
// 是否存在员工的工资大于10000
boolean anyMatch = employeeList.stream().anyMatch(e -> e.getSalary() > 10000);
System.out.println(anyMatch);
// noneMatch (Predicate p)—-检查是否没有匹配的元素。
// 练习:是否存在员工姓“雷”
boolean noneMatch = employeeList.stream().noneMatch(e -> e.getName().startsWith("雷"));
System.out.println(noneMatch);
// findFirst—-返回第一个元素
Optional<Employee> employee = employeeList.stream().findFirst();
System.out.println(employee);
// findAny -- 返回任意一个元素
Optional<Employee> employee1 = employeeList.stream().findAny();
System.out.println(employee1);
// count—-返回流中元素的总个数
long count = employeeList.stream().count();
System.out.println(count);
// max (Comparator c)-返回流中最大值
// 练习:返回最高的工资:
Optional<Double> max = employeeList.stream().map(Employee::getSalary).max((d1, d2) -> Double.compare(d1, d2));
System.out.println(max);
// min(Comparator c)—-返回流中最小值
// 练习:返回最低工资的员工
Optional<Double> min = employeeList.stream().map(Employee::getSalary).min((d1, d2) -> Double.compare(d1, d2));
System.out.println(min);
// forEach( consumer c)—-内部迭代
employeeList.stream().forEach(System.out::println);
}
}
(2) 归约
public class StreamAPITest3 {
@Test
public void test1(){
// reduce(T identity, BinaryOperator b)--可以将流中元素反复结合起来,得到一个值。返回T
// 练习1:计算1-10的自然数的和
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 = " + sum);//sum = 55
// reduce(BinaryOperator b) 可以将流中元素反复结合起来,得到一个值。返回Optional<T>
Optional<Integer> reduce = list.stream().reduce(Integer::sum);
System.out.println(reduce);//Optional[55]
}
}
(3) 收集
强大的Stream APl : Collectors
⑥ Optional类
- 到目前为止,臭名昭著的空指针异常是导致Java应用程序失败的最常见原因。
以前,为了解决空指针异常,Google公司著名的Guava项目引入了Optional类,Guava通过使用检查空值的方式来防止代码污染,它鼓励程序员写更干净的代码。受到Google Guava的启发,Optional类已经成为Java 8类库的一部分。 - Optional类(java.util.Optional)是一个容器类,它可以保存类型T的值,代表这个值存在。或者仅仅保存null,表示这个值不存在。原来用null表示一个值不存在,现在Optional可以更好的表达这个概念。并且可以避免空指针异常。
- Optional类的Javadoc描述如下:这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true,调用get()方法会返回该对象。