DevOps与敏捷开发Java8知识梳理 - Powered by Discuz! Archiver

嚴華发表于 2023-9-2 14:23:27

Java8知识梳理

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 表达式当中不允许声明一个与局部变量同名的参数或者局部变量。
String first = "";
Comparator<String> comparator = (first, second) -> Integer.compare(first.length(), second.length());//编译会出错

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

二、函数式接口

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

[*]四大核心函数式接口
https://images.cnblogs.com/cnblogs_com/blogs/789167/galleries/2329798/o_230728080012_%E5%BE%AE%E4%BF%A1%E5%9B%BE%E7%89%87_20230728155252.png
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));

}
}

[*]其他函数式接口
https://images.cnblogs.com/cnblogs_com/blogs/789167/galleries/2329798/o_230729082922_%E5%BE%AE%E4%BF%A1%E5%9B%BE%E7%89%87_20230729162030.png

三、方法引用

[*]方法引用就是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 );

[*]数组引用
public void test4() {
Function<Integer, String[]> func1 = length -> new String;
String[] arr1 = func1.apply(5);
System.out.println(Arrays.toString(arr1));

System.out.println("====================");

//使用方法引用
Function<Integer,String[]> func2 = String[]::new;//数组引用
String[] arr2 = func2.apply(10);
System.out.println(Arrays.toString(arr2));
}

三、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的实例化：一个数据源（如集合、数组），获取一个流
//创建Stream的方式一：通过集合
public void test1(){
List<Employee> employees = EmployeeData.getEmployees();

//default Stream<E> stream()：返回一个顺序流
Stream<Employee> stream = employees.stream();

//default Stream<E> parallelStream()：返回一个并行流
Stream<Employee> parallelStream = employees.parallelStream();
}

//创建Stream方式二：通过数组
public void test2(){
int[] arr = new int[]{1, 2, 3, 4, 5, 6};
//调用Arrays类的static<T> Stream<T> stream(T[] array)：返回一个流
IntStream stream = Arrays.stream(arr);//int数组

Employee e1 = new Employee(1001, "Tom");
Employee e2 = new Employee(1002, "Jerry");
Employee[] arr1 = new Employee[]{e1, e2};
Stream<Employee> stream2 = Arrays.stream(arr1);//Employee类数组
}

//创建Stream方式三：通过Stream的of()函数
public void test3(){
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);//这里的1~6不是int类型数据，而是一个包装类
}

//创建Stream方式四：创建无限流
public void test4(){
//①迭代
//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);
}

[*]顺序流与并行流的区别：顺序流的集合元素时按存入顺序储存的，取出时按顺序取出；并行流的集合元素是并行存储的，取出时是随机的。

<ol start="2">一系列的中间操作：一个中间操作链，对数据源的数据进行处理。多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。
2.1 筛选与切片
https://images.cnblogs.com/cnblogs_com/blogs/789167/galleries/2329798/o_230825090346_2_1.png
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 映射
https://images.cnblogs.com/cnblogs_com/blogs/789167/galleries/2329798/o_230827153941_2_2.png
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); //
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

页: [1]

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

Java8知识梳理