Compartilhamento de tecnologia

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

1. Introdução ao Opcional

Opcional é uma nova classe introduzida em java8. O principal problema que ela resolve é NullPointerException.
Tradução do texto original (tradução do Baidu, minhas deficiências em inglês): um objeto contêiner, que pode ou não conter valores não nulos. isPresent() retornará verdadeiro se o valor estiver presente. Se não houver valor, o objeto é considerado vazio e isPresent() retorna falso.
São fornecidos métodos adicionais que dependem da presença do valor contido, como orElse() (retorna o valor padrão se o valor não estiver presente) e ifPresent() (executa a ação quando o valor está presente).
Esta é uma classe baseada em valores; os programadores devem tratar instâncias iguais como intercambiáveis ​​e não devem usar instâncias para sincronização, caso contrário, poderá ocorrer um comportamento imprevisível. Por exemplo, a sincronização poderá falhar em uma versão futura.

A função principal que entendo aqui é que você pode passar isPresent() método para auxiliar no julgamento do vazio do objeto e, em seguida, passarmap(), orElse() ，ifPresent() A combinação de outros métodos pode reduzir bastante a demora no julgamento do código.

2. Interfaces comumente usadas

先介绍一下常用所有的接口；
注意：
	1. 此列表是列出了本人觉得有意义的接口不是全部。
	2. 当前jdk版本为17,其他版本可能会没有一些方法，例如：`or()` 方法在jdk1.9中增加的
1
2
3
4

2.1 Interfaces comuns são fáceis de usar

下面是常用接口的一些简单的演示
1

2.1.1 Métodos comuns de criação

// 1. 构建一个空的 Optional 对象没有任何问题
Optional<Object> empty = Optional.empty();

 // 2. 构建一个非空的 Optional 对象没有任何问题
 Optional<Object> aa = Optional.of("123");
 // 3. 构建一个空的 Optional 对象直接报错  ================ 会报错 of不允许为空
 Optional<Object> bb = Optional.of(null);

 // 4. 构建一个空的 Optional 对象没有任何问题
 Optional<Object> cc = Optional.ofNullable(null);

 // 5. 构建一个非空的 Optional 对象没有任何问题
 Optional<Object> dd = Optional.ofNullable("123");

1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.1.2 Métodos comuns para obtenção de valores

Optional<Object> cc = Optional.ofNullable(null);
// 1. 如果为空的时候获取值就会直接报错
Object o = cc.get();
// 2. 如果对象为空，则获取 or 中的 get 方法的值，否则则获取cc的 get 方法中的值
Object o1 = cc.or(() -> Optional.ofNullable("123")).get();
// 3. 如果对象为空，则直接获取的是 123, orElse()中的参数是非空的。 如果对象不为空则直接获取到对象的值
Object o2 = cc.orElse("123");
// 4. 如果对象为空，则获取 or 中的 get 方法的值，否则则获取cc的 get 方法中的值
Object o3 = cc.orElseGet(() -> Optional.ofNullable("123"));

1
2
3
4
5
6
7
8
9
10
11

2.1.3 Métodos comuns de julgamento

Optional<Object> cc = Optional.ofNullable(null);
// 1. 存在则返回true
boolean present = cc.isPresent();
// 2. 为null返回true
boolean empty = cc.isEmpty();
1
2
3
4
5

2.1.4 Método de operação após julgamento

Optional<Object> cc = Optional.ofNullable(null);
// 1. 如果对象不为空，则执行方法体的内容，否则没有任何操作
cc.ifPresent(item->{
    System.out.println("不为空则执行我"+item);
});

// 2. 如果对象不为空，则执行方法体的内容，否则没有任何操作
cc.ifPresentOrElse(item->{
    System.out.println("不为空则执行我"+item);
},()->{
    System.out.println("为空则执行我");
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.2 Introdução ao método de mapa

map 方法的使用跟 Stream 中的map方法一样，我的理解这里面的所有的接口方法与 Stream 中重名的用法都是一样的
1

@Data
public static class User{
    private String name;
    private Integer age;
}
@Test
void getMapTest(){

    User user = new User();
    user.setName("123");
    Optional<User> optionalUser = Optional.of(user);
    // 1. 直接获取 user 对象的 name 的值，这里 map 是当用户不为空的时候执行的
    Optional<String> name = optionalUser.map(User::getName);
    System.out.println(name.isEmpty()); // 输出 false

    Optional<User> optionalUser2 = Optional.ofNullable(null);
    // 2. 直接获取 user 对象的 name 的值，这里 map 是当用户不为空的时候执行的
    Optional<String> name2 = optionalUser2.map(User::getName);
    System.out.println(name2.isEmpty()); // 输出 true
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2.2 Outros métodos

Outros métodos:

2.2.1 Método de filtro

filter : Este método é para filtragem,Optional<Path> p = uris. stream().filter(uri -> !isProcessedYet(uri)).findFirst() .map(Paths::get); Basicamente, nunca o usei aqui e parece que não há cenário de uso.

2.2.2 Método FlatMap

flatMap: Entendo que este método é uma conversão de unboxing: por exemplo, coloque Stream<Optional<T>> Converter paraOptional<T>

Stream<Optional<T>> os = ....
Stream<T> s = os.flatMap(Optional::stream)
1
2

3. Exemplos comumente usados

TODO 这里后面再不吧，暂时也没有太合适的例子
1

4. Resumo

Optional Introduzido no Java 8, ele fornece uma maneira mais elegante e segura de lidar com valores potencialmente nulos.Principalmente atravésor ,orElse , ifPresent Esperar que métodos funcionais determinem elegantemente o espaço vazio e executem a operação depois que ele não estiver vazio, isso pode reduzir várias camadas deif O julgamento torna o código elegante, mas as desvantagens são函数式 método reduzirá a legibilidade do código.e também precisaLambda É preciso uma certa compreensão.