Comment gérer les exceptions froidement avec Java 8 Stream ou en option

Problème: il est difficile de gérer les exceptions avec des expressions lambda

Utilisez-vous l'API Streams de Java8? C'est très pratique. L'API Streams, ou expression lambda, est très puissante.

La formule lambda est très puissante mais l'exemple est médiocre.java

Function<String, String> slice = x -> x.substring(3, 6);
System.out.println(slice.apply("abcdefghij")); // -> "def"

Comme beaucoup l'ont souligné, [^ 1] est incompatible avec la gestion des exceptions, et il n'est pas possible d'intercepter des exceptions en dehors de lambda. (Non, je pense que c'est naturel parce que c'est un morceau de traitement avec du lambda.)

Dans l'exemple ci-dessus, si la chaîne de caractères est de 3 caractères ou moins, une erreur se produira, insérons donc le traitement des exceptions afin qu'il soit renvoyé tel quel lorsqu'une erreur se produit.

Try Catch n'est pas cool et la nidification est profonde et je veux que vous vous arrêtiez.java

Function<String, String> sliceAndCatch = x -> {
	try {
		return x.substring(3, 6);
	} catch (Exception e) {
		return x;
	}
};

System.out.println(sliceAndCatch.apply("abcdefghij")); // -> "def"
System.out.println(sliceAndCatch.apply("xy")); // -> "xy"

Wow, le nid est profond.

De plus, dans le cas d'une méthode qui lève une exception vérifiée, vous devez essayer catch dans le lambda, vous ne pouvez donc pas appeler hoge :: fuga qui lève une exception avec stream.map (hoge :: fuga), ce qui vous rend frustré. .. S'il s'agit d'une exception non vérifiée, elle peut être récupérée au moment de l'appel (essayez {stream.map (hoge :: fuga)} catch {～}), mais elle n'est pas propre. Il existe également une bibliothèque qui encapsule Stream et Optional, mais c'est plutôt gênant.

Solution: j'espère que vous pouvez écrire en une seule ligne → Vous pouvez écrire de cette façon

Je veux écrire l'exemple ci-dessus avec une doublure. Si vous passez deux lambdas et écrivez le traitement normal pour le premier lambda et le traitement d'exception pour le deuxième lambda, cela aura l'air intelligent. Alors, tout d'abord, préparez une interface fonctionnelle qui lève des exceptions

Fonction où une exception est levée.java

interface ThrowableFunction<T, R> {
	R apply(T t) throws Exception;
}

Et définir Essayez comme ça

L'image entière apparaît.java

public <T, R> Function<T, R> Try(ThrowableFunction<T, R> onTry, BiFunction<Exception, T, R> onCatch) {
	return x -> {
		try {
			return onTry.apply(x);
		} catch (Exception e) {
			return onCatch.apply(e, x);
		}
	};
}

Cela seul permet un codage cool!

Cool.java

Function<String, String> coolSlice = Try(x -> x.substring(3, 6), (error, x) -> x);

System.out.println(coolSlice.apply("abcdefghij")); // -> "def"
System.out.println(coolSlice.apply("xy")); // -> "xy"

Si le consommateur fait de même,

Pour le consommateur.java

interface ThrowableConsumer<T> {
	void accept(T t) throws Exception;
}

public <T> Consumer<T> Try(ThrowableConsumer<T> onTry, BiConsumer<Exception, T> onCatch) {
	return x -> {
		try {
			onTry.accept(x);
		} catch (Exception t) {
			onCatch.accept(t, x);
		}
	};
}

C'est aussi cool!

je l'ai fait.java

Consumer<String> coolCatch = Try(x -> {System.out.println(Integer.valueOf(x));}, (error, x) -> error.printStackTrace());

coolCatch.accept("33"); //-> 33
coolCatch.accept("Hoge"); //-> java.lang.NumberFormatException: For input string: "Hoge"・ ・ ・

mérite et démérite

La bonne chose à propos de cette méthode

• Court
• Vous pouvez utiliser correctement les exceptions (par rapport à l'encapsulation des exceptions vérifiées et à la levée d'exceptions non vérifiées pour les attraper)
• Plus polyvalent que Stream enveloppé ou en option. C'est juste une fonction qui revient

Mauvais endroit

• Longue préparation → C'est plus léger que les autres trompettes, alors écrivons-le et faisons une importation statique
• Vous devez préparer Try pour toutes les interfaces fonctionnelles
• Ce n'est pas un type sécurisé, et je récupère également les exceptions d'exécution que je ne veux pas prendre → Y a-t-il un meilleur moyen?

Application: Le mécanisme est simple mais utile

Bien sûr, vous pouvez également le passer comme référence de méthode, vous pouvez donc l'appeler comme ceci

Exemple ordinaire.java

stream.flatMap(Try(this::calc, (x,y)->Stream.empty()));

S'il accepte la fonction <T, R> même s'il ne s'agit pas d'un flux, il peut être facultatif.

Optional.java

Optional<String> name = getName();
name.flatMap(Try( dao::getFindByName ,(x,y)->Optional.empty()));

Aussi lors du passage de lambda à l'interface

Interface Homebrew.java

interface JisakuInterface{
	String Method(String Argument);
}

JisakuInterface m = str->"hoge";
JisakuInterface f = Try(str -> str+str,(x,y)->"b")::apply;

Si vous vous référez à la méthode, vous pouvez facilement la passer avec lambda. génial.

Après ça, quand j'ai fait oleoremonado

Monamodoki.java

// LogicalDeletable.of(null)Pour générer une suppression logique avec.
LogicalDeletable<LegacyData> record = getRecord(); 
//Ceux qui ont commis une erreur de conversion sont traités comme une suppression logique
record.map(Try(Legacy::legacyTransform)) , (error,record) -> null));

Vous pouvez donc prendre des exceptions.

Je ne peux pas penser à un exemple (4ème fois), mais comme le contenu lancé est passé à onCatch en tant qu'argument, toutes les fonctions qui peuvent être effectuées avec TryCatch normal devraient être possibles (sauf pour try-with-resource).

C'est pourquoi tout le monde devrait prendre froidement l'exception.

[^ 1]: Qiita seule http://qiita.com/daylife/items/b977f4f29b1f8ced3a02, http://qiita.com/KIchiro/items/4fafd74c46d08275eb56, http://qiita.com/yoshi389111/items/c6b7d373a00f8