Partage de technologie

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

1. Introduction à l'option facultative

Facultatif est une nouvelle classe introduite dans Java8. Le principal problème qu'elle résout est NullPointerException.
Traduction du texte original (traduction Baidu, mes lacunes en anglais) : un objet conteneur, qui peut ou non contenir des valeurs non nulles. isPresent() retournera true si la valeur est présente. S'il n'y a pas de valeur, l'objet est considéré comme vide et isPresent() renvoie false.
Des méthodes supplémentaires sont fournies qui dépendent de la présence de la valeur contenue, telles que orElse() (renvoie la valeur par défaut si la valeur n'est pas présente) et ifPresent() (exécute l'action lorsque la valeur est présente).
Il s'agit d'une classe basée sur des valeurs ; les programmeurs doivent traiter les instances égales comme interchangeables et ne doivent pas utiliser d'instances pour la synchronisation, sinon un comportement imprévisible pourrait se produire. Par exemple, la synchronisation peut échouer dans une version ultérieure.

La fonction principale que je comprends ici est que vous pouvez transmettre isPresent() méthode pour aider à juger du vide de l'objet, puis passermap(), orElse() ，ifPresent() La combinaison d’autres méthodes peut réduire considérablement la longueur du jugement dans le code.

2. Interfaces couramment utilisées

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

2.1 Les interfaces communes sont faciles à utiliser

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

2.1.1 Méthodes courantes de création

// 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éthodes courantes pour obtenir des valeurs

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éthodes courantes de jugement

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éthode de fonctionnement après jugement

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 Introduction à la méthode cartographique

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 Autres méthodes

Autres méthodes:

2.2.1 Méthode de filtrage

filter : Cette méthode est destinée au filtrage,Optional<Path> p = uris. stream().filter(uri -> !isProcessedYet(uri)).findFirst() .map(Paths::get); Je ne l'ai pratiquement jamais utilisé ici, et j'ai l'impression qu'il n'y a aucun scénario d'utilisation.

2.2.2 Méthode FlatMap

flatMap: Je comprends que cette méthode est une conversion de déballage : par exemple, mettez Stream<Optional<T>> Convertir enOptional<T>

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

3. Exemples couramment utilisés

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

4. Résumé

Optional Introduit dans Java 8, il offre un moyen plus élégant et plus sûr de gérer des valeurs potentiellement nulles.Principalement à traversor ,orElse , ifPresent En attendant que les méthodes fonctionnelles déterminent avec élégance l'espace vide et exécutent l'opération une fois qu'il n'est pas vide, cela peut réduire plusieurs couches deif Le jugement rend le code élégant, mais les inconvénients sont函数式 La méthode réduira la lisibilité du code.et il faut aussiLambda Cela demande une certaine compréhension.