Java-8-Funktionen - erstellen und dann

Finde ich meine Java-Kenntnisse out-of-date mit Java 8, und es gibt viele neue features für die Sprache, die ich versuche zu lernen. Einer von Ihnen ist Funktionen, insbesondere die compose und andThen Methoden.

Ich geschrieben habe ein triviales experiment zum test der Reversibilität der compose und andThen:

/** Wraps a value 
 */
public class Wrap<T> {
    private final T value;
    private Wrap(T value) {
        this.value = value;
    }
    public static <T> Wrap<T> of(T value) {
        return new Wrap<>(value);
    }
}

static void functions() {

    Function<Integer,String> itos = i->"'"+i+"'";
    Function<String,Wrap<String>> stow = s->Wrap.of(s);

    Function<Integer,Wrap<String>> itow = itos.andThen(stow);
    Function<Integer,Wrap<String>> itow2 = stow.compose(itos);

    System.out.println(itow.apply(3));
    System.out.println(itow2.apply(3));
}

In den obigen code, wie erwartet, die 2 Funktionen itow und itow2 zu sein scheinen gleichwertig. Aber sind Sie tatsächlich gleichwertig? Tun die das gleiche Ergebnis eher durch Zufall in diesem Fall?

Der Gedanke kommt, dass beide compose und andThen Methoden existieren für einen Grund, und, dass die Funktionen oder BiFunctions vielleicht nicht immer reversibel sein, auf diese Weise. Können Sie denken, von den Fällen, in denen die Umkehrung nicht gelten würden?

Weiter dachte, ich lief in die Verwirrung mit BiFunction, und natürlich haben Sie nicht compose () - aus offensichtlichen Gründen. Sieht aus wie Funktionen eigentlich nicht brauchen, compose () - überhaupt, dann() ist viel intuitiver IMO.

InformationsquelleAutor NickJ | 2017-05-08

15

Während a.andThen(b) entspricht b.compose(a) gibt es einen praktischen Unterschied bei der Verwendung von Website, wenn nur eine dieser beiden Funktionen wird ein bereits vorhandener Funktionen.

Nehme an, Sie haben die bereits bestehende Funktion
```
Function<Integer,String> iToHex = i->"'"+Integer.toHexString(i)+"'";
```
und dann wollen Sie an die Kette einer Zeichenketten-transformation, z.B.
```
Function<Integer,String> itoUpperHex = iToHex.andThen(String::toUpperCase);
```
andThen offensichtlich ist viel bequemer, im Vergleich zu
```
Function<Integer,String> itoUpperHex
                       = ((Function<String,String>)String::toUpperCase).compose(iToHex);
```
Auf der anderen Seite, wenn Sie Ihre bereits vorhandenen Funktion ist
```
UnaryOperator<String> quote=s -> "'"+s+"'";
```
und Sie möchten, erstellen Sie die angegebenen hex-Funktion,
```
Function<Integer,String> iToHex = quote.compose(Integer::toHexString);
```
viel bequemer als
```
Function<Integer,String> iToHex
                       = ((Function<Integer,String>)Integer::toHexString).andThen(quote);
```
Also die Entscheidung für eine Methode hängt davon ab, welche Funktion bereits vorhanden ist. Wenn die beiden bereits vorhandenen Funktionen, es spielt keine Rolle, welche Methode Sie verwenden (es sei denn, Sie vermuten, dass eine dieser Funktionen möglicherweise überschrieben haben, diese Methoden durchzuführen, eine effizientere Zusammensetzung). Wenn Sie keine bestehende Funktion als Startpunkt, es gibt keinen Grund, eine der folgenden Methoden verwenden, wie Sie können, schreiben die komponierte Ausdruck als ein einzelnes lambda-Ausdruck.

InformationsquelleAutor Holger
6

Sind Sie gleichwertig.

Oder in anderen Worten: x.andThen(y) ist das gleiche wie y.compose(x).
- Ja aber warum das eingeführt 2 Methoden?
InformationsquelleAutor mtj
4

Den source-code für Function ist frei verfügbar:
```
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
    Objects.requireNonNull(before);
    return (V v) -> apply(before.apply(v));
}

default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
    Objects.requireNonNull(after);
    return (T t) -> after.apply(apply(t));
}
```
Aus diesem Grund ist es ziemlich klar, dass a.andThen(b) entspricht b.compose(a).

Es ist vielleicht sogar noch deutlicher, wenn wir das stillschweigend this explicit:
```
return (V v) -> this .apply(before.apply(v)); //compose
return (T t) -> after.apply(this  .apply(t)); //andThen
```
Können Sie Fragen, wenn Sie gleichbedeutend sind, warum nicht beides existieren?

Gut, Sie sind nur da als Bequemlichkeit an Erster Stelle. Sie verwalten könnte, ohne entweder von Ihnen:
```
 a.andThen(b)
```
... ist natürlich äquivalent zu:
```
 (x) -> b.apply(a.apply(x));
```
So, da Sie es als eine Bequemlichkeit, die jeweils bequem in den verschiedenen Umständen. Sie können wählen, welche ist besonders ausdrucksstark in einer bestimmten situation.

InformationsquelleAutor slim
3

Aus den Javadocs, es gibt einen klaren Unterschied zwischen compose und andThen:
- verfassen...
Gibt eine komponierte-Funktion, wendet zuerst die vor-Funktion an seinem Eingang, und dann gilt diese Funktion, um das Ergebnis.
- dann...
Gibt eine komponierte Funktion, die erste gilt diese Funktion an seinem Eingang, und dann gilt die nach der Funktion auf das Ergebnis.

Als solche, die Reversibilität wird, hängt von der Implementierung der Funktion.

In deinem Fall itow und itow2 sind nur zwei alternative Ausdrucksmöglichkeiten des gleichen: "run itos, dann stow in dieser Reihenfolge".
- Wie wird die Reversibilität abhängig von der Implementierung der Funktion? Sicher, ob die 2 Funktionen können verkettet werden, auf diese Weise hängt nur von der Ergebnis-Typ der ein-und Eingabe-Typ der nächsten?
- Ich meinte auch nur, dass im Allgemeinen, D. H. einige Transformationen möglicherweise nicht reversibel, auch unabhängig von der Eingabe - /Ausgabe-Typen. Dies ist nicht der Fall hier natürlich.
- warum dann deine zwei Methoden anlegen? warum nicht einfach austauschen wie x.dann(y) y.dann(x) ?
InformationsquelleAutor Mena

Ich würde sagen, dass Sie gleichwertig sind, sehen die Umsetzung:

x.compose(y) = x.apply(y.apply(...))

und

y.andThen(x) = x.apply(y.apply(...))

Vom Function.java (ich Hinzugefügt this. für die Klarheit):

default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
    Objects.requireNonNull(before);
    return (V v) -> this.apply(before.apply(v));
}

default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
    Objects.requireNonNull(after);
    return (T t) -> after.apply(this.apply(t));
}

InformationsquelleAutor Hugues M.

folgende Beispiel zeigt, dass andThen() & compose() sind widersprüchlich Methoden. Ihr produziert Gegenteil zu einander.(siehe die Ausgabe für mehr Klarheit)

f1.andThen(f2).apply(10); => zuerst ausführen f1.apply(10) Methode. basierend auf der Ausgabe der ersten Methode f2.apply(result_of_f1_method) Methode execute.

f1.compose(f2).apply(10); => hier nur gegenüber andThen() Methode.
erste f2.apply() und dann f1.apply(output_of_f2_method) ausführen.

public class FunctionDemo {
    public static void main(String[] args) {

        Function<Integer, Integer> f1 = num -> (num - 4);
        Function<Integer, Integer> f2 = num -> (num * 2);

        //Using andThen() method
        int a=f1.andThen(f2).apply(10);
        System.out.println(a);//Output - 12

        //Using compose function
        int b=f1.compose(f2).apply(10);
        System.out.println(b);//Output - 16
    }
}

InformationsquelleAutor shubham bellale

Beide sind ähnlich, außer der Folge, wie er führt die Funktionen, siehe Beispiel unten-

import java.util.function.Function;

public class FunctionThenComposeTest {

    public static void main(String[] xavis_args) {

        Function<Integer, Integer> f1 = i -> {
            System.out.println("Inside F1");
            return i * i;
        };

        Function<Integer, Integer> f2 = i -> {
            System.out.println("Inside F2");
            return i * i;
        };

        System.out.println("And Then method");
        System.out.println(f1.andThen(f2).apply(2));//Execute f1 function first, take the result of f1 and then apply it to f2 function(The result of f1 function will be the input to f2 function)
        System.out.println("Compose method");        
        System.out.println(f1.compose(f2).apply(2));//First execute f2 function and then take the result of f2 and execute f1 (The result of f2 will be the input to f1 function)
    }
}

AUSGABE

And Then method

Inside F1

Inside F2

16

Compose method

Inside F2

Inside F1

16

InformationsquelleAutor Xavi

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.