ToB企服应用市场:ToB评测及商务社交产业平台

标题: Java8知识梳理 [打印本页]

---

作者: 嚴華    时间: 2023-9-2 14:23
标题: Java8知识梳理
Java 8 的改进

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

一、Lambda 表达式

• Lambda表达式的重要特征
  

• 可选用类型声明：不需要声明参数类型，编译器可以统一识别参数值。
  
• 可选用的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
  
• 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
  
• 可选的返回关键字：如果主体只有一个表达式，返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。（即return…）
  
• Lambda表达式是对象，而不是函数。
  

• Lambda表达式基本语法
  

• 举例：
  1. (o1,o2) -> Integer.compare(o1,o2);

  复制代码
• 格式：
  

• -> ：lambda 操作符 或 箭头操作符
  
• -> 左边：lambda 形参列表 （其实就是接口中的抽象方法的形参列表）
  
• -> 右边：lambda 体（其实就是重写的抽象方法的方法体）
  

• 举例
  

1. public class Java8Tester {
2.    public static void main(String args[]){
3.       Java8Tester tester = new Java8Tester();
4.         
5.       // 类型声明
6.       MathOperation addition = (int a, int b) -> a + b;
7.         
8.       // 不用类型声明
9.       MathOperation subtraction = (a, b) -> a - b;
10.         
11.       // 大括号中的返回语句
12.       MathOperation multiplication = (int a, int b) -> { return a * b; };
13.         
14.       // 没有大括号及返回语句
15.       MathOperation division = (int a, int b) -> a / b;
16.         
17.       System.out.println("10 + 5 = " + tester.operate(10, 5, addition));//10 + 5 = 15
18.       System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));//10 - 5 = 5
19.       System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));//10 x 5 = 50
20.       System.out.println("10 / 5 = " + tester.operate(10, 5, division));//10 / 5 = 2
21.         
22.       // 不用括号
23.       GreetingService greetService1 = message ->
24.       System.out.println("Hello " + message);
25.         
26.       // 用括号
27.       GreetingService greetService2 = (message) ->
28.       System.out.println("Hello " + message);
29.         
30.       greetService1.sayMessage("Runoob");//Hello Runoob
31.       greetService2.sayMessage("Google");//Hello Google
32.    }
33.    
34.    interface MathOperation {
35.       int operation(int a, int b);
36.    }
37.    
38.    interface GreetingService {
39.       void sayMessage(String message);
40.    }
41.    
42.    private int operate(int a, int b, MathOperation mathOperation){
43.       return mathOperation.operation(a, b);
44.    }
45. }

复制代码

• 变量作用域
  

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

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

复制代码

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

1. int num = 1;  
2. Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
3. s.convert(2);
4. num = 5;  
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注解可以用于检验该接口是否为一个函数式接口。

• 四大核心函数式接口
  

1. public class LambdaTest3 {
2.     //消费型接口 Consumer<T>     void accept(T t)
3.     @Test
4.     public void test1() {
5.         //未使用Lambda表达式
6.         Learn("java", new Consumer<String>() {
7.             @Override
8.             public void accept(String s) {
9.                 System.out.println("学习什么？ " + s);
10.             }
11.         });
12.         System.out.println("====================");
13.         //使用Lambda表达
14.         Learn("html", s -> System.out.println("学习什么？ " + s));
16.     }
18.     private void Learn(String s, Consumer<String> stringConsumer) {
19.         stringConsumer.accept(s);
20.     }
22.     //供给型接口 Supplier<T>     T get()
23.     @Test
24.     public void test2() {
25.         //未使用Lambda表达式
26.         Supplier<String> sp = new Supplier<String>() {
27.             @Override
28.             public String get() {
29.                 return new String("我能提供东西");
30.             }
31.         };
32.         System.out.println(sp.get());
33.         System.out.println("====================");
34.         //使用Lambda表达
35.         Supplier<String> sp1 = () -> new String("我能通过lambda提供东西");
36.         System.out.println(sp1.get());
37.     }
39.     //函数型接口 Function<T,R>   R apply(T t)
40.     @Test
41.     public void test3() {
42.         //使用Lambda表达式
43.         Employee employee = new Employee(1001, "Tom", 45, 10000);
45.         Function<Employee, String> func1 =e->e.getName();
46.         System.out.println(func1.apply(employee));
47.         System.out.println("====================");
49.         //使用方法引用
50.         Function<Employee,String> func2 = Employee::getName;
51.         System.out.println(func2.apply(employee));
53.     }
55.     //断定型接口 Predicate<T>    boolean test(T t)
56.     @Test
57.     public void test4() {
58.         //使用匿名内部类
59.         Function<Double, Long> func = new Function<Double, Long>() {
60.             @Override
61.             public Long apply(Double aDouble) {
62.                 return Math.round(aDouble);
63.             }
64.         };
65.         System.out.println(func.apply(10.5));
66.         System.out.println("====================");
68.         //使用Lambda表达式
69.         Function<Double, Long> func1 = d -> Math.round(d);
70.         System.out.println(func1.apply(12.3));
71.         System.out.println("====================");
73.         //使用方法引用
74.         Function<Double,Long>func2 = Math::round;
75.         System.out.println(func2.apply(12.6));
77.     }
78. }

复制代码

• 其他函数式接口
  

三、方法引用

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

现有一个Car类如下：

1. @FunctionalInterface
2. public interface Supplier<T> {
3. T get();
4. }
6. class Car {
7. //Supplier是jdk1.8的接口，这里和lamda一起使用了
8. public static Car create(final Supplier<Car> supplier) {  //静态方法
9.      return supplier.get();
10. }
12. public static void collide(final Car car) {  //静态方法
13.      System.out.println("Collided " + car.toString());
14. }
16. public void follow(final Car another) {  //非静态方法
17.      System.out.println("Following the " + another.toString());
18. }
20. public void repair() {  //非静态方法
21.      System.out.println("Repaired " + this.toString());
22. }
23. }

复制代码

• 构造器引用：Class::new
  1. final Car car = Car.create( Car::new );
  2. final List< Car > cars = Arrays.asList( car );

  复制代码
• 静态方法引用：Class::static_method
  1. cars.forEach( Car::collide );

  复制代码
• 特定类的任意对象的方法引用：Class::method
  1. cars.forEach( Car::repair );

  复制代码
• 特定对象的方法引用：instance::method
  1. final Car police = Car.create( Car::new );
  2. 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的操作三个步骤
  

<blockquote>

• 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 筛选与切片

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

复制代码

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);    //
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

---

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)

Powered by Discuz! X3.4