Java8新特性

Posted 2021-01-25 木易yang～

以下内容均来自菜鸟教程：http://www.runoob.com

• Lambda 表达式

 1 package com.buwei;
 2 
 3 /**
 4  * Lambda表达式，也成为闭包
 5  * Lambda允许把函数作为一个方法的参数（函数作为参数传递进方法中）
 6  * 语法格式：
 7  *      (parameters) -> expression
 8  *      (parameters) -> {statements}
 9  * 重要特性：
10  *      可选类型声明：不需要声明参数类型，编译器会用手一识别参数值
11  *      可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号
12  *      可选的大括号：如果主体包含了一个语句，就不需要使用大括号
13  *      可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，
14  *                     大括号需要指明表达式返回了一个数值
15  * 注意点：
16  *      Lambda表达式主要用来定义行内执行的方法类型接口
17  *      Lambda表达式免去了使用匿名方法的麻烦，并且基于Java简单但是强大的函数化的编程能力
18  * 变量作用域：
19  *      Lambda表达式只能引用标记了final的外部局部变量
20  *      就是说不能再Lambda内部修改定义在域外的局部变量，否则会编译错误
21  * 可以直接在Lambda表达式中访问外层的局部变量
22  * Lambda表达式的局部变量可以不用声明为final，但是必须不可被后面的代码修改
23  * Lambda表达式中不允许声明一个局部变量同名的参数或者局部变量
24  * @author YangQuan
25  * @date 2018/12/8 19:16
26  */
27 public class LambdaDemo {
28     static final String salutation = "HELLO";
29     public static void main(String[] args) {
30         LambdaDemo lambdaDemo = new LambdaDemo();
31         // 需要声明类型
32         MathOperation addition = (int a, int b) -> a + b;
33         // 不用声明类型
34         MathOperation subtraction = (a, b) -> a - b;
35         // 大括号中的返回语句
36         MathOperation multiplication = (int a, int b) -> {
37             return a * b;
38         };
39         // 没有大括号及返回语句
40         MathOperation division = (int a, int b) -> a / b;
41         System.out.println("10 + 5 = " + lambdaDemo.operate(10, 5, addition));
42         System.out.println("10 - 5 = " + lambdaDemo.operate(10, 5, subtraction));
43         System.out.println("10 * 5 = " + lambdaDemo.operate(10, 5, multiplication));
44         System.out.println("10 / 5 = " + lambdaDemo.operate(10, 5, division));
45 
46         // 不用括号
47         GreetingService greetingService1 = message -> System.out.println("hello " + message);
48         // 用括号
49         GreetingService greetingService2 = (message) -> System.out.println("hello "+message);
50 
51         greetingService1.sayMessage("Google");
52         greetingService2.sayMessage("baidu");
53 
54         // 引用外部的局部变量
55         GreetingService greetingService3 = message -> System.out.println(salutation + message);
56         greetingService3.sayMessage("cnblogs");
57     }
58 
59     /**
60      * 定义一个接口，在main方法中实现
61      */
62     public interface MathOperation {
63         /**
64          * 抽象方法
65          * @param a 参数1
66          * @param b 参数2
67          * @return  返回值
68          */
69         int operation(int a, int b);
70     }
71 
72     /**
73      * 定义一个接口，在main方法中实现
74      */
75     public interface GreetingService {
76         /**
77          * 抽象方法
78          * @param message 字符串
79          */
80         void sayMessage(String message);
81     }
82 
83     /**
84      * 定义私有方法，执行上面两个接口中的执行方法
85      * @param a 参数1
86      * @param b 参数2
87      * @param mathOperation 抽象接口的实现类
88      * @return 返回值
89      */
90     private int operate(int a, int b, MathOperation mathOperation) {
91         return mathOperation.operation(a, b);
92     }
93 }

• 方法引用

 1 package com.buwei;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 /**
 7  * 方法引用：通过方法的名字来指向一个方法
 8  *      使语言的构造更紧凑简洁，减少冗余代码
 9  *      方法引用使用一对冒号 ：：
10  * 四种引用方法：
11  *      构造器引用：Class::new
12  *      静态方法引用：Class::static_method
13  *      特定类的任意对象的方法引用：Class::method
14  *      特定对象的方法引用：instance::method
15  * @author YangQuan
16  * @date 2018/12/8 20:05
17  */
18 public class MethodReferencesDemo {
19 
20     public static void main(String[] args) {
21         List<String> names = new ArrayList<String>();
22 
23         names.add("Google");
24         names.add("Runoob");
25         names.add("Taobao");
26         names.add("Baidu");
27         names.add("Sina");
28 
29         names.forEach(System.out::println);
30 
31     }
32 }

• 函数式接口

 1 package com.buwei;
 2 
 3 /**
 4  * 函数式接口：就是有且仅有一个抽象方法，但是可以有多个费抽象方法
 5  * 函数式接口可以被隐式的转换为Lambda表达式
 6  * Lambda表达式和方法引用(实际上也可认为是Lambda表达式)上
 7  * 下面写在一起只是为了更好的展现案例
 8  * @author YangQuan
 9  * @date 2018/12/8 20:16
10  */
11 public class FunctionalInterfaceDemo {
12     /**
13      * 定义一个函数式接口
14      * @FunctionalInterface 注解主要是为了检测编译级错误
15      * 函数式接口中允许定义静态方法：Java8中的新特性
16      */
17     @FunctionalInterface
18     interface GreetingService {
19         /**
20          * 随便创建的一个抽象方法
21          * @param message 随便创建的一个参数
22          */
23         void sayMessage(String message);
24 
25         /**
26          * 随便定义一个静态方法做例子
27          */
28         static void printHello(){
29             System.out.println("hello");
30         }
31     }
32 
33     public static void main(String[] args) {
34         GreetingService greetingService = message -> System.out.println("hello" + message);
35         greetingService.sayMessage("java");
36     }
37 
38 }

• 默认方法

 1 package com.buwei;
 2 
 3 
 4 /**
 5  * 默认方法：就是接口可以有实现方法，二期不需要实现类去实现其方法
 6  *          只需要在方法名前加上default关键字即可
 7  * 语法：
 8  *      public interface DefaultMethod{
 9  *           default void print(){
10  *              sout(" 这是一个默认方法")
11  *          }
12  *      }
13  *  优点：当需要修改接口是，需要修改全部实现该接口的类，
14  *          解决办法是在接口中添加新的方法及实现
15  *  静态默认方法：接口可以声明（并且可以提供实现）静态方法
16  * @author YangQuan
17  * @date 2018/12/8 20:29
18  */
19 public interface DefaultMethodDemo {
20 
21     default void testDefault(){
22         System.out.println("这是一个接口中的默认方法");
23     }
24 
25     static void testStatic(){
26         System.out.println("这是一个接口中的静态方法");
27     }
28 }

• Optional 类

 1 package com.buwei;
 2 
 3 import java.util.Optional;
 4 
 5 /**
 6  * Optional类是一个可以为null的容器对象
 7  *      如果值存在则isPresent()方法会返回true
 8  *      调用get()方法会返回该对象
 9  * Optional是个容器，他可以保存类型T的值
10  *      或者仅仅保存null值。Optional提供很多有哦用的方法
11  *      这样我们就不用显式进行空值检测
12  * Optional类的引入很好的解决空指针异常
13  * @author YangQuan
14  * @date 2018/12/8 20:44
15  */
16 public class OptionalDemo {
17 
18     public static void main(String[] args) {
19         OptionalDemo optionalDemo = new OptionalDemo();
20         Integer a = null;
21         Integer b = 0;
22 
23         // optional.ofNullable - 允许传递为null参数
24         Optional<Integer> a1 = Optional.ofNullable(a);
25 
26         // optional.of - 如果传递的参数是null,抛出异常NullPointerException
27         Optional<Integer> b1 = Optional.of(b);
28         System.out.println(optionalDemo.sun(a1, b1));
29 
30     }
31 
32     private Integer sun(Optional<Integer> a, Optional<Integer> b){
33         // Optional.isPresent() - 判断值是否存在
34         System.out.println("第一个参数值是否存在："+a.isPresent());
35         System.out.println("第二个参数值是否存在："+b.isPresent());
36 
37         // Optional.orElse() - 如果值存在，返回它，否则返回默认值
38         Integer a2 = a.orElse(0);
39         System.out.println(a2);
40 
41         // Optional.get() - 获取值，值需要存在
42         Integer b2 = b.get();
43         return a2 + b2;
44     }
45 }

• 新的日期时间 API

 1 package com.buwei;
 2 
 3 import java.time.LocalDate;
 4 import java.time.LocalDateTime;
 5 import java.time.LocalTime;
 6 import java.time.Month;
 7 
 8 /**
 9  * Date-Time API来加强对日期与时间的处理
10  *      Java.util.Date：
11  *          非线程安全的
12  *          与java.sql.Date混乱
13  *              util包下的同时包含日期和时间
14  *              sql包下的仅包含日期
15  *          时区处理麻烦：没有时区支持
16  * Java8在Java.time包下提供了很多新的API，以下为两个比较重要的API：
17  *      Local(本地) - 简化了时间的处理，没有时区的问题
18  *      Zoned(时区) - 通过制定的时区处理日期时间
19  * @author YangQuan
20  * @date 2018/12/8 20:59
21  */
22 public class NewDate {
23 
24     public static void main(String[] args) {
25         NewDate newDate = new NewDate();
26         newDate.testLocalDateTime();
27 
28     }
29 
30     public void  testLocalDateTime(){
31         // 获取当前时间日期
32         LocalDateTime currentTime = LocalDateTime.now();
33         System.out.println("当前时间：" + currentTime);
34 
35         LocalDate date1 = currentTime.toLocalDate();
36         System.out.println("date1:" + date1);
37 
38         Month month = currentTime.getMonth();
39         int day = currentTime.getDayOfMonth();
40         int second = currentTime.getSecond();
41 
42         System.out.println(month + "月：" + day + ",日：" + second + ",秒");
43 
44         LocalDateTime date2 = currentTime.withDayOfMonth(10).withYear(2012);
45         System.out.println("date2" + date2);
46 
47         // 12 december 2014
48         LocalDate date3 = LocalDate.of(2014, Month.DECEMBER, 12);
49         System.out.println("date3: " + date3);
50 
51         // 22 小时 15 分钟
52         LocalTime date4 = LocalTime.of(22, 15);
53         System.out.println("date4: " + date4);
54 
55         // 解析字符串
56         LocalTime date5 = LocalTime.parse("20:15:30");
57         System.out.println("date5: " + date5);
58     }
59 }

• 只贴出了自己有些理解的部分，后续再补充。。。。