Swift

let intString: String? = "42"
// Int(String)Est Int?rends le
let integer: Int? = intString.flatMap { Int($0) }
print(String(describing: integer))
// Optional(42)

Java 8

Java 8 utilise également les méthodes map et flatMap. L'utilisation est la même.

Java

Optional<String> intString = Optional.of("42");
Optional<String> percentage = intString.map( str -> str + "%" );
System.out.println(percentage);
// Optional[42%]

Java

Optional<String> intString = Optional.of("42");
Optional<Integer> integer = intString.flatMap(this::intFromString);
System.out.println(integer);
// Optional[42]

Reliure facultative

Swift

Je pense que c'est une méthode de déballage sûre. En combinant avec des mots-clés tels que «if» et «guard», il est possible de brancher le processus selon qu'il y a du contenu ou non.

Swift

let wrappedValue: String? = "value"
if let value: String = wrappedValue {
    print(value)
} else {
    print("no value")
}
// "value"

Swift

let wrappedValue: String? = "value"
guard let value: String = wrappedValue else {
    print("no value")
    return
}
print(value)
// "value"

Java 8

Dans Java 8, vous pouvez le dérouler en toute sécurité via une méthode appelée ʻifPresent`. Il prend un objet de type «Consumer <? Super T>» comme argument et décrit le traitement lorsqu'il contient un contenu.

Java

Optional<String> wrappedValue = Optional.of("value");
wrappedValue.ifPresent( str -> {
    System.out.println(str);
});
// "value"

Cependant, il n'y a pas de ** méthode qui puisse décrire le traitement lorsqu'il n'y a pas de contenu **. Par conséquent, si vous voulez décrire les deux processus, vous devez utiliser ʻis Presentpour vérifier l'existence du contenu. Cependant, il est redondant par rapport à Swift car vous devez décrire explicitement le déroulement forcéget` s'il y a du contenu **.

Java

Optional<String> wrappedValue = Optional.of("value");
if (wrappedValue.isPresent()) {
    //Redondant mais doit être explicitement déballé forcé
    String value = wrappedValue.get();
    System.out.println(value);
} else {
    System.out.println("no value");
}
// "value"

Java

Optional<String> wrappedValue = Optional.of("value");
//Décrire dans la clause de la carte
if (!wrappedValue.isPresent()) {
    System.out.println("no value");
    return;
}
//Redondant mais doit être explicitement déballé forcé
String value = wrappedValue.get();
System.out.println(value);
// "value"

Java

Optional<String> wrappedValue = Optional.of("value");
wrappedValue.ifPresent( str -> {
    System.out.println(str);
})// .orElse( () -> { //Je ne peux pas faire ça
//     System.out.println("no value");
// })
;

De plus, puisque la portée du processus passé à ʻifPresent` est dans l'expression lambda, la méthode appelante ne peut pas être retournée dans ce processus. Par conséquent, si vous souhaitez effectuer un retour anticipé, vous n'avez pas d'autre choix que d'utiliser «is Present».

Java

public boolean foo(Optional<String> wrappedValue) {
    //Revenir tôt s'il y a une valeur
    if (wrappedValue.isPresent) {
        String str = wrappedValue.get();
        //Faire quelque chose
        return true;
    }
    //Que faire s'il n'y a pas de valeur
    return result;
}

Java

public boolean foo(Optional<String> wrappedValue) {
    //Revenir tôt s'il y a une valeur
    wrappedValue.ifPresent( str -> {
        //Faire quelque chose
//         return true; //Cela n'est pas possible car la portée se trouve dans cette expression lambda
    });
    //Que faire s'il n'y a pas de valeur
    return result;
}

Chaînage facultatif

Swift

Accédez aux propriétés et aux méthodes uniquement lorsqu'il y a du contenu. Utilisez l'opérateur postfix «?».

Swift

let wrappedValue: String? = "value"
let uppercased: String? = wrappedValue?.uppercased()
print(String(describing: uppercased))
// Optional("VALUE")

Swift

class Hoge {
    func hoge() { print("hoge") }
}

let wrappedValue: Hoge? = Hoge()
wrappedValue?.hoge()
// "hoge"

Java 8

Dans Java 8, vous pouvez utiliser la méthode map introduite précédemment. Si la cible est une méthode, elle peut être écrite de manière concise à l'aide d'une référence de méthode. Cependant, si la cible renvoie un type ʻOptional, vous devez utiliser flatMap`.

Java

Optional<String> wrappedValue = Optional.of("value");
Optional<String> uppercased = wrappedValue.map(String::toUpperCase);
System.out.println(uppercased);
// Optional[VALUE]

Java

class User {
    final String id;
    Optional<String> mail = Optional.empty();
    User(String id) { this.id = id; }
}

Optional<User> wrappedUser = Optional.of(new User("user1"));
Optional<String> mail = wrappedUser.flatMap( user -> user.mail );
System.out.println(mail);
// Optional.empty

C'est exactement la même notation que lors de l'utilisation de Convert, y compris comment l'utiliser correctement. Java 8 ne fournit aucune notation ou méthode spéciale uniquement pour accéder au champ ou à la méthode de la valeur encapsulée. Pour accéder à une méthode qui ne renvoie pas de valeur, utilisez ʻifPresent` introduit précédemment.

Java

class Hoge {
    void hoge() { System.out.println("hoge"); }
}

Optional<Hoge> wrappedValue = Optional.of(new Hoge());
wrappedValue.ifPresent(Hoge::hoge);
// "hoge"

Résumé

Dans cet article, nous avons comparé les types Java 8 et ʻOptional basés sur la gestion des types ʻOptional dans Swift. Voici un tableau de comparaison de chaque notation. Surtout en ce qui concerne la reliure optionnelle et le chaînage optionnel, la différence entre les deux est très apparente. La liaison optionnelle Java 8 est un peu plus redondante que Swift car elle ne peut pas être déroulée en même temps que le branchement. De plus, Java 8 ne fournit pas de moyen dédié pour accéder aux valeurs encapsulées, telles que l'opérateur ? De Swift.

Si vous avez des erreurs, veuillez nous en informer dans les commentaires.

Bonus-Java 9 en option

Ici, nous allons introduire les méthodes ʻOptional, ʻor et ʻifPresentOrElse`, ajoutées dans Java 9. Je ne peux pas parler de Java 8. C'est un bonus complet.

or

Exécute un objet de type Fournisseur <? Etend Facultatif <? Etend T >> donné lorsqu'il n'y a pas de contenu pour obtenir la valeur par défaut de type ʻOptional. C'est exactement le cas avec l'opérateur de jointure Nil de Swift apportant le type ʻOptional au bon opérande. De plus, en raison de l '** évaluation de court-circuit **, l'objet Supplier donné ne sera pas exécuté tant qu'il a un contenu.

Swift

let wrappedValue: String? = nil
let defaultValue = "default"

let otherWrappedValue: String? = nil
let value = wrappedValue ?? otherWrappedValue ?? defaultValue
print(value)
// "default"

Java

// available Java 9 or later
Optional<String> wrappedValue = Optional.empty();
String defaultValue = "default";

Optional<String> otherWrappedValue = Optional.empty();
//Le type facultatif peut être spécifié comme valeur par défaut dans Java 9 ou version ultérieure
String value = wrappedValue.or( () -> otherWrappedValue ).orElse(defaultValue);
System.out.println(value);
// "default"

ifPresentOrElse

Vous pouvez dériver le processus selon qu'il contient ou non un contenu. S'il y a du contenu, un objet de type Consumer <? Super T> est exécuté, sinon un objet de type Runnable est exécuté. Étant donné que vous pouvez également décrire le traitement lorsqu'il est «nul», il est beaucoup plus proche de la liaison optionnelle de Swift par rapport à Java 8.

Swift

let wrappedValue: String? = "value"
if let value = wrappedValue {
    print(value)
} else {
    print("no value")
}
// "value"

Java

// available Java 9 or later
Optional<String> wrappedValue = Optional.<String>empty();
wrappedValue.ifPresentOrElse( str -> {
    System.out.println(str);
}, () -> {
    System.out.println("no value");
});
// "no value"