Je ne peux pas écrire en une seule ligne ...
C'est un gars qui réussit à écrire magnifiquement
Préparation.java
/** --------------------Préparation-------------------- */
/**Interface qui lève des exceptions*/
private static interface Throwable<T, S> {
S apply(T t) throws NullPointerException, NumberFormatException, Exception;
}
/**Une méthode pour changer la fonction à exécuter selon l'exception*/
private static <T, S> Function<T, S> switchFunction(Throwable<T, S> tf, BiFunction<Exception, T, S> npe,
BiFunction<Exception, T, S> nfe, Function<Exception, S> other) {
return v -> {
try {
return tf.apply(v);
} catch (NullPointerException e) {
return npe.apply(e, v);
} catch (NumberFormatException e) {
return nfe.apply(e, v);
} catch (Exception e) {
return other.apply(e);
}
};
}
J'ai créé une fonction qui peut lever une exception Si vous obtenez une exception lorsque vous essayez d'exécuter une certaine fonction, créez cette fonction.
Je vais mettre en œuvre les quatre
interne.java
/** --------------------Mise en place de traitements spécifiques-------------------- */
/**Traitement principal*/
private static final Throwable<String, Integer> tf = v -> {
if (v.equals("5")) {
return Integer.parseInt(v);
} else if (v.equals("999")) {
throw new NullPointerException();
} else if (v.equals("ddd")){
throw new NumberFormatException();
} else {
throw new IOException();
}
};
/**Traitement au moment de gluante*/
private static final BiFunction<Exception, String, Integer> npe = (e, v) -> {
e.printStackTrace();
return 0;
};
/**Traitement lorsque la conversion numérique n'est pas possible*/
private static final BiFunction<Exception, String, Integer> nfe = (e, v) -> {
e.printStackTrace();
return v.length();
};
/**Traitement des autres exceptions*/
private static final Function<Exception, Integer> other = e -> {
e.printStackTrace();
return 1;
};
Cette fois, il semble que ce soit tous les modèles, alors j'ai forcé de lancer une exception Faisons le
Courir.java
/** --------------------Courir-------------------- */
public static void main(String[] args) {
Arrays.asList("5", "ddd", "999", "0").stream().map(switchFunction(tf, npe, nfe, other))
.forEach(System.out::println);
}
5
java.lang.NumberFormatException
at test1.Test1.lambda$0(Test1.java:35)
at test1.Test1.lambda$4(Test1.java:18)
at java.util.stream.ReferencePipeline$3$1.accept(Unknown Source)
at java.util.Spliterators$ArraySpliterator.forEachRemaining(Unknown Source)
at java.util.stream.AbstractPipeline.copyInto(Unknown Source)
at java.util.stream.AbstractPipeline.wrapAndCopyInto(Unknown Source)
at java.util.stream.ForEachOps$ForEachOp.evaluateSequential(Unknown Source)
at java.util.stream.ForEachOps$ForEachOp$OfRef.evaluateSequential(Unknown Source)
at java.util.stream.AbstractPipeline.evaluate(Unknown Source)
at java.util.stream.ReferencePipeline.forEach(Unknown Source)
at test1.Test1.main(Test1.java:55)
3
java.lang.NullPointerException
at test1.Test1.lambda$0(Test1.java:33)
at test1.Test1.lambda$4(Test1.java:18)
at java.util.stream.ReferencePipeline$3$1.accept(Unknown Source)
at java.util.Spliterators$ArraySpliterator.forEachRemaining(Unknown Source)
at java.util.stream.AbstractPipeline.copyInto(Unknown Source)
at java.util.stream.AbstractPipeline.wrapAndCopyInto(Unknown Source)
at java.util.stream.ForEachOps$ForEachOp.evaluateSequential(Unknown Source)
at java.util.stream.ForEachOps$ForEachOp$OfRef.evaluateSequential(Unknown Source)
at java.util.stream.AbstractPipeline.evaluate(Unknown Source)
at java.util.stream.ReferencePipeline.forEach(Unknown Source)
at test1.Test1.main(Test1.java:55)
0
java.io.IOException
at test1.Test1.lambda$0(Test1.java:37)
at test1.Test1.lambda$4(Test1.java:18)
at java.util.stream.ReferencePipeline$3$1.accept(Unknown Source)
at java.util.Spliterators$ArraySpliterator.forEachRemaining(Unknown Source)
at java.util.stream.AbstractPipeline.copyInto(Unknown Source)
at java.util.stream.AbstractPipeline.wrapAndCopyInto(Unknown Source)
at java.util.stream.ForEachOps$ForEachOp.evaluateSequential(Unknown Source)
at java.util.stream.ForEachOps$ForEachOp$OfRef.evaluateSequential(Unknown Source)
at java.util.stream.AbstractPipeline.evaluate(Unknown Source)
at java.util.stream.ReferencePipeline.forEach(Unknown Source)
at test1.Test1.main(Test1.java:55)
1
Comme prévu
Eh bien, comme vous pouvez le voir, les types d'arguments de fonction et de valeurs de retour qui peuvent être implémentés sont Même si je le prends avec des génériques, c'est inutile s'ils ne correspondent pas tous.
Il semble qu'il y aura des cas où ce sera un problème s'il s'agit d'une mise en œuvre réaliste. Je veux dire, il semble que ce sera lourd si vous empilez des fonctions comme celle-ci ... Est-ce que ça va?
Parce que la partie exécution et le traitement interne sont parfaitement séparés N'est-ce pas vraiment lisible? Mais ouais, la préparation est trop longue
S'il y a plusieurs cas où une exception est inévitablement levée dans une opération intermédiaire pour une série de flux Il semble qu'il vaut mieux mettre en œuvre ce type d'implémentation.
Ça y est.java
public class Test7 {
private static <T>void switchMethod(T t) {
try {
s1(t);
} catch (NumberFormatException e) {
s2(t);
}
}
private static <T>void s1(T t) throws NumberFormatException{
System.out.println(Integer.parseInt((String) t));
}
private static <T>void s2(T t) {
System.out.println(t + "Suchimuri");
}
public static void main(String[] args) {
List<String> list = new ArrayList<>(Arrays.asList("a", null, "2"));
list.stream().forEachOrdered(Test7::switchMethod);
}
}
un Suuchimuri
nul
2
Après tout, le nombre de méthodes augmentera au stade de la préparation.
Si le comportement lors de la levée d'une exception est le même, il est préférable de l'utiliser, mais ...
Hmmm, difficile ...