Java8知识梳理

嚴華 · 2023-9-2 14:23:27

Java 8 的改进

速度更快
代码更少（Lambda表达式）
引入强大的Stream API
便于并行
最大化减少空指针异常（Optional）
Nashorn引擎，允许在JVM上运行js应用
并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。相比较串行的流，并行的流可以很大程度上提高程序的执行效率。

一、Lambda 表达式

Lambda表达式的重要特征

可选用类型声明：不需要声明参数类型，编译器可以统一识别参数值。

可选用的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。

可选的大括号：如果主体包含了一个语句，就不需要使用大括号。

可选的返回关键字：如果主体只有一个表达式，返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。（即return…）

Lambda表达式是对象，而不是函数。

Lambda表达式基本语法

举例：
(o1,o2) -> Integer.compare(o1,o2);
复制代码
格式：

-> ：lambda 操作符或箭头操作符

-> 左边：lambda 形参列表（其实就是接口中的抽象方法的形参列表）

-> 右边：lambda 体（其实就是重写的抽象方法的方法体）

举例

public class Java8Tester {
public static void main(String args[]){
Java8Tester tester = new Java8Tester();
// 类型声明
MathOperation addition = (int a, int b) -> a + b;
// 不用类型声明
MathOperation subtraction = (a, b) -> a - b;
// 大括号中的返回语句
MathOperation multiplication = (int a, int b) -> { return a * b; };
// 没有大括号及返回语句
MathOperation division = (int a, int b) -> a / b;
System.out.println("10 + 5 = " + tester.operate(10, 5, addition));//10 + 5 = 15
System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));//10 - 5 = 5
System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));//10 x 5 = 50
System.out.println("10 / 5 = " + tester.operate(10, 5, division));//10 / 5 = 2
// 不用括号
GreetingService greetService1 = message ->
System.out.println("Hello " + message);
// 用括号
GreetingService greetService2 = (message) ->
System.out.println("Hello " + message);
greetService1.sayMessage("Runoob");//Hello Runoob
greetService2.sayMessage("Google");//Hello Google
}
interface MathOperation {
int operation(int a, int b);
}
interface GreetingService {
void sayMessage(String message);
}
private int operate(int a, int b, MathOperation mathOperation){
return mathOperation.operation(a, b);
}
}

复制代码

变量作用域

lambda 表达式只能引用标记了 final 的外层局部变量，即不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。

public class Java8Tester {
public static void main(String args[]) {
final int num = 1;
Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));//访问外层的局部变量num
s.convert(2); // 输出结果为 3
}
public interface Converter<T1, T2> {
void convert(int i);
}
}

复制代码

lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义）

int num = 1;
Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
s.convert(2);
num = 5;
//报错信息：Local variable num defined in an enclosing scope must be final or effectively final

复制代码

在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量。
1. String first = "";
2. Comparator<String> comparator = (first, second) -> Integer.compare(first.length(), second.length()); //编译会出错
复制代码

Lambda表达式的本质：作为函数式接口的实例（关于函数式接口的概念在下一点）

二、函数式接口

什么是函数式接口

如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口。在接口中加上@FunctionalInterface注解可以用于检验该接口是否为一个函数式接口。

四大核心函数式接口

public class LambdaTest3 {
//消费型接口 Consumer<T> void accept(T t)
@Test
public void test1() {
//未使用Lambda表达式
Learn("java", new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println("学习什么？ " + s);
}
});
System.out.println("====================");
//使用Lambda表达
Learn("html", s -> System.out.println("学习什么？ " + s));
}
private void Learn(String s, Consumer<String> stringConsumer) {
stringConsumer.accept(s);
}
//供给型接口 Supplier<T> T get()
@Test
public void test2() {
//未使用Lambda表达式
Supplier<String> sp = new Supplier<String>() {
@Override
public String get() {
return new String("我能提供东西");
}
};
System.out.println(sp.get());
System.out.println("====================");
//使用Lambda表达
Supplier<String> sp1 = () -> new String("我能通过lambda提供东西");
System.out.println(sp1.get());
}
//函数型接口 Function<T,R> R apply(T t)
@Test
public void test3() {
//使用Lambda表达式
Employee employee = new Employee(1001, "Tom", 45, 10000);
Function<Employee, String> func1 =e->e.getName();
System.out.println(func1.apply(employee));
System.out.println("====================");
//使用方法引用
Function<Employee,String> func2 = Employee::getName;
System.out.println(func2.apply(employee));
}
//断定型接口 Predicate<T> boolean test(T t)
@Test
public void test4() {
//使用匿名内部类
Function<Double, Long> func = new Function<Double, Long>() {
@Override
public Long apply(Double aDouble) {
return Math.round(aDouble);
}
};
System.out.println(func.apply(10.5));
System.out.println("====================");
//使用Lambda表达式
Function<Double, Long> func1 = d -> Math.round(d);
System.out.println(func1.apply(12.3));
System.out.println("====================");
//使用方法引用
Function<Double,Long>func2 = Math::round;
System.out.println(func2.apply(12.6));
}
}

复制代码

其他函数式接口

三、方法引用

方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法。（Lambda表达式深层次的表达）
当要传递给Lambda体的操作，已经有实现的方法了，就可以使用方法引用。
4种不同方法的引用

现有一个Car类如下：
@FunctionalInterface
public interface Supplier<T> {
T get();
}
class Car {
//Supplier是jdk1.8的接口，这里和lamda一起使用了
public static Car create(final Supplier<Car> supplier) {  //静态方法
   return supplier.get();
}
public static void collide(final Car car) {  //静态方法
   System.out.println("Collided " + car.toString());
}
public void follow(final Car another) {  //非静态方法
   System.out.println("Following the " + another.toString());
}
public void repair() {  //非静态方法
   System.out.println("Repaired " + this.toString());
}
}
复制代码

构造器引用：Class::new
final Car car = Car.create( Car::new );
final List< Car > cars = Arrays.asList( car );
复制代码
静态方法引用：Class::static_method
cars.forEach( Car::collide );
复制代码
特定类的任意对象的方法引用：Class::method
cars.forEach( Car::repair );
复制代码
特定对象的方法引用：instance::method
final Car police = Car.create( Car::new );
cars.forEach( police::follow );
复制代码

数组引用
1. public void test4() {
2. Function<Integer, String[]> func1 = length -> new String[length];
3. String[] arr1 = func1.apply(5);
4. System.out.println(Arrays.toString(arr1));
6. System.out.println("====================");
8. //使用方法引用
9. Function<Integer,String[]> func2 = String[]::new; //数组引用
10. String[] arr2 = func2.apply(10);
11. System.out.println(Arrays.toString(arr2));
12. }
复制代码

三、Stream API

Java8中有两大最为重要的改变。第一个是Lambda 表达式；另外一个则是Stream API。
Stream API ( java.util.stream)把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
Stream 是Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用SQL 执行的数据库查询。也可以使用Stream API 来并行执行操作。简言之，Stream API 提供了一种高效且易于使用的处理数据的方式。
为什么要使用Stream API：实际开发中，项目中多数数据源都来自于Mysql，Oracle等。但现在数据源可以更多了，有MongDB，Radis等，而这些NoSQL的数据就需要Java层面去处理。
Stream 和Collection 集合的区别：Collection 是一种静态的内存数据结构，而Stream 是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向CPU，通过CPU 实现计算。
注意
- Stream自己不会存储元素
- Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream。
- Stream操作是延迟执行的。
Stream的操作三个步骤

Stream的实例化：一个数据源（如集合、数组），获取一个流
1. //创建Stream的方式一：通过集合
2. public void test1(){
3. List<Employee> employees = EmployeeData.getEmployees();
5. //default Stream<E> stream()：返回一个顺序流
6. Stream<Employee> stream = employees.stream();
8. //default Stream<E> parallelStream()：返回一个并行流
9. Stream<Employee> parallelStream = employees.parallelStream();
10. }
12. //创建Stream方式二：通过数组
13. public void test2(){
14. int[] arr = new int[]{1, 2, 3, 4, 5, 6};
15. //调用Arrays类的static<T> Stream<T> stream(T[] array)：返回一个流
16. IntStream stream = Arrays.stream(arr);//int数组
18. Employee e1 = new Employee(1001, "Tom");
19. Employee e2 = new Employee(1002, "Jerry");
20. Employee[] arr1 = new Employee[]{e1, e2};
21. Stream<Employee> stream2 = Arrays.stream(arr1);//Employee类数组
22. }
24. //创建Stream方式三：通过Stream的of()函数
25. public void test3(){
26. Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);//这里的1~6不是int类型数据，而是一个包装类
27. }
29. //创建Stream方式四：创建无限流
30. public void test4(){
31. //①迭代
32. //public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
33. //遍历前10个偶数
34. Stream.iterate(0, t->t+2).limit(10).forEach(System.out::println);
36. //②生成
37. //public static<T> Stream<T> generate(Supplier<T> s)
38. //输出10个随机数
39. Stream.generate(Math::random).limit(10).forEach(System.out::println);
40. }
复制代码
- 顺序流与并行流的区别：顺序流的集合元素时按存入顺序储存的，取出时按顺序取出；并行流的集合元素是并行存储的，取出时是随机的。

<ol start="2">一系列的中间操作：一个中间操作链，对数据源的数据进行处理。多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。
2.1 筛选与切片

public void test1(){
List<Employee> employees = EmployeeData.getEmployees();
Stream<Employee> employeeStream = employees.stream();
//filter(Predicate p)——接收 Lambda ，从流中排除某些元素。
employeeStream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);//查询员工表中薪资大于7000的员工信息
System.out.println();
//limit(n)——截断流，使其元素不超过给定数量。
employees.stream().limit(3).forEach(System.out::println);//因为上一条代码中的Stream已经执行了终止操作，所以不能使用【employeeStream.limit(3).forEach(System.out::println)】，而是要重新创建一个Stream
System.out.println();
//skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
employees.stream().skip(3).forEach(System.out::println);
System.out.println();
//distinct()——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
employees.add(new Employee(1010,"刘庆东",56,8000));
employees.add(new Employee(1010,"刘庆东",56,8000));
employees.add(new Employee(1010,"刘庆东",56,8000));
employees.add(new Employee(1010,"刘庆东",56,8000));
employees.stream().distinct().forEach(System.out::println);
}

复制代码

2.2 映射

[code]public void test2(){ List list = Arrays.asList("aa", "bb", "cc", "dd"); //map(Function f)——接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，并将其映射成一个新的元素。 list.stream().map(str -> str.toUpperCase()).forEach(System.out::println); //练习1：获取员工姓名长度大于3的员工的姓名。 List employees = EmployeeData.getEmployees(); Stream nameStream = employees.stream().map(Employee::getName); nameStream.filter(name -> name.length() >3).forEach(System.out::println); System.out.println(); //练习2：使用map()中间操作实现flatMap()中间操作方法 Stream streamStream = list.stream().map(StreamAPITest2::fromStringToStream); streamStream.forEach(s ->{ s.forEach(System.out::println); }); System.out.println(); //flatMap(Function f)——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。 Stream characterStream = list.stream().flatMap(StreamAPITest2::fromStringToStream); characterStream.forEach(System.out::println); //
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

		自动登录	找回密码
密码			立即注册

Java8知识梳理

本帖子中包含更多资源

0 个回复

快速回复

楼主热帖

标签云