Java 8 新特性#

1
public interface InterfaceNew {
2
    static void sm() {
3
        System.out.println("interface提供的方式实现");
4
    }
5
    static void sm2() {
6
        System.out.println("interface提供的方式实现");
7
    }
8

9
    default void def() {
10
        System.out.println("interface default方法");
11
    }
12
    default void def2() {
13
        System.out.println("interface default2方法");
14
    }
15
    //须要实现类重写
16
    void f();
17
}
18

19
public interface InterfaceNew1 {
20
    default void def() {
21
        System.out.println("InterfaceNew1 default方法");
22
    }
23
}

1
// 之前
2
new Thread(new Runnable() {
3
            @Override
4
            public void run() {
5
                System.out.println("The runable now is using!");
6
            }
7
}).start();
8

9
// Lambda
10
new Thread(() -> System.out.println("It's a lambda function!")).start();

1
// 之前
2
List<Integer> strings = Arrays.asList(1, 2, 3);
3

4
Collections.sort(strings, new Comparator<Integer>() {
5
@Override
6
public int compare(Integer o1, Integer o2) {
7
    return o1 - o2;}
8
});
9

10
// Lambda
11
Collections.sort(strings, (Integer o1, Integer o2) -> o1 - o2);

1
LambdaUpdateWrapper<TUser> updateWrapper = Wrappers.lambdaUpdate(TUser.class)
2
        .eq(TUser::getUsername, username)
3
        .set(TUser::getRealName, userBasicInfo.getRealName())
4
        .set(TUser::getIdType, userBasicInfo.getIdType())
5
        .set(TUser::getIdCard, userBasicInfo.getIdCard());

1
// 创建一个 Optional
2
Optional<String> optional1 = Optional.of("hello");
3
Optional<String> optional2 = Optional.ofNullable(null);
4
Optional<String> optional3 = Optional.empty();
5

6
// 判断一个 Optional 是否为空
7
Optional<String> optional = Optional.of("hello");
8
if (optional.isPresent()) {
9
    System.out.println("Optional is not empty");
10
} else {
11
    System.out.println("Optional is empty");
12
}
13

14
// get()：如果该 Optional 不为空则返回该对象，否则抛出 NullPointerException 异常。
15
Optional<String> optional = Optional.of("hello");
16
String value = optional.get(); // 输出hello
17

18
// orElse()：如果该 Optional 不为空则返回该对象，否则返回指定的默认值。
19
Optional<String> optional = Optional.ofNullable(null);
20
String value = optional.orElse("fallback value"); // 输出fallback value
21

22
// orElseGet()：如果该 Optional 不为空则返回该对象，否则调用指定的 Supplier 获取默认值。
23
Optional<String> optional = Optional.ofNullable(null);
24
String value = optional.orElseGet(() -> "fallback value"); // 输出fallback value
25

26
// map()：如果有值，则对其执行调用映射函数得到返回值。如果返回值不为 null，则创建包含映射返回值的 Optional 作为 map 方法返回值，否则返回空 Optional。
27
Optional<String> optional = Optional.of("hello");
28
Optional<String> value = optional.map(str -> str.toUpperCase()); // 输出HELLO
29

30
// filter()：如果值存在，并且这个值匹配给定的条件，返回一个 Optional 用以描述这个值，否则返回一个空的 Optional。
31
Optional<String> optional = Optional.of("hello");
32
Optional<String> value = optional.filter(str -> str.startsWith("he")); // 输出hello
33

34
// orElseThrow()：如果该 Optional 不为空则返回对象，否则抛出指定的异常。
35
Optional<String> optional = Optional.ofNullable(null);
36
String value = optional.orElseThrow(() -> new RuntimeException("fallback value")); // 抛出RuntimeException