Ich kann nicht in einer Zeile schreiben ...
Es ist ein Typ, der es schafft, schön zu schreiben
Vorbereitung.java
/** --------------------Vorbereitung-------------------- */
/**Schnittstelle, die Ausnahmen auslöst*/
private static interface Throwable<T, S> {
S apply(T t) throws NullPointerException, NumberFormatException, Exception;
}
/**Eine Methode zum Umschalten der auszuführenden Funktion gemäß der Ausnahme*/
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);
}
};
}
Ich habe eine Funktion erstellt, die eine Ausnahme auslösen kann Wenn Sie beim Versuch, eine bestimmte Funktion auszuführen, eine Ausnahme erhalten, machen Sie diese Funktion.
Ich werde die vier umsetzen
intern.java
/** --------------------Implementierung einer spezifischen Verarbeitung-------------------- */
/**Hauptverarbeitung*/
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();
}
};
/**Verarbeitung zum Zeitpunkt der schleimigen*/
private static final BiFunction<Exception, String, Integer> npe = (e, v) -> {
e.printStackTrace();
return 0;
};
/**Verarbeitung, wenn keine numerische Konvertierung möglich ist*/
private static final BiFunction<Exception, String, Integer> nfe = (e, v) -> {
e.printStackTrace();
return v.length();
};
/**Behandlung anderer Ausnahmen*/
private static final Function<Exception, Integer> other = e -> {
e.printStackTrace();
return 1;
};
Dieses Mal scheint es alles Muster zu sein, also habe ich gezwungen, eine Ausnahme zu werfen Machen wir das
Lauf.java
/** --------------------Lauf-------------------- */
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
Wie erwartet
Wie Sie sehen können, können folgende Arten von Funktionsargumenten und Rückgabewerten implementiert werden Obwohl ich es mit Generika nehme, ist es nutzlos, wenn sie nicht alle übereinstimmen.
Es scheint Fälle zu geben, in denen es ein Problem sein wird, wenn es sich um eine realistische Implementierung handelt. Ich meine, es scheint schwer zu sein, wenn Sie Funktionen wie diese stapeln ... Ist das in Ordnung?
Weil der Ausführungsteil und die interne Verarbeitung sauber voneinander getrennt sind Ist es nicht wirklich lesbar? Aber ja, die Vorbereitung ist zu lang
Wenn es mehrere Fälle gibt, in denen eine Ausnahme zwangsläufig in einer Zwischenoperation für eine Reihe von Streams ausgelöst wird Es scheint besser zu sein, diese Art der Implementierung zu implementieren.
Das ist es.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);
}
}
ein Suuchimuri
Null
2
Immerhin wird die Anzahl der Methoden in der Vorbereitungsphase zunehmen.
Wenn das Verhalten beim Auslösen einer Ausnahme dasselbe ist, ist es besser, es zu verwenden, aber ...
Hmmm, schwierig ...