Java8-Methode verwendete Referenz als Objekt Funktion, die Funktionen zu kombinieren

Gibt es eine Möglichkeit in Java8 die Methode Referenz als Function - Objekt, mit dessen Methoden, so etwas wie:

Stream.of("ciao", "hola", "hello")
    .map(String::length.andThen(n -> n * 2))

Diese Frage ist nicht im Zusammenhang mit der Stream, es dient nur als Beispiel, ich möchte eine Antwort über die Methode Referenz

Bieten die Eingabe und die gewünschte Ausgabe, danach wird Ihnen sagen, wie zur Umsetzung mit Java-8-streams.
Es ist nicht im Zusammenhang mit Stream-API, seine im Zusammenhang mit Verfahren Referenz
die kanonische Lösung ist .map(s -> s.length() * 2) wie es keinen Grund gibt, um es auszudrücken, wie die zwei Funktionen miteinander zu kombinieren, Sie sofort. Wenn Sie eine bereits vorhandene Function Instanz oder wollen, halten Sie mindestens eine von Ihnen später wieder zu verwenden, das problem nicht existieren, dann müssen Sie ein Objekt aus, das Sie aufrufen können entweder andThen oder compose auf. In allen anderen Fällen, gibt es keinen Grund, es zu tun, die kompliziert sind.

InformationsquelleAutor rascio | 2015-08-25

31

Schreiben Sie eine statische Methode, dies zu tun:
```
import java.util.function.*;

class Test {
    public static void main(String[] args) {
        Function<String, Integer> function = combine(String::length, n -> n * 2);
        System.out.println(function.apply("foo"));
    }

    public static <T1, T2, T3> Function<T1, T3> combine(
        Function<T1, T2> first,
        Function<T2, T3> second) {
        return first.andThen(second);
    }
}
```
Könnte man dann steckte es in eine utility-Klasse und importieren Sie Sie statisch.

Alternativ erstellen Sie eine einfachere statische Methode, die nur liefert die Funktion ist gegeben, für das wohl der compiler wissen, was Sie tun:
```
import java.util.function.*;

class Test {
    public static void main(String[] args) {
        Function<String, Integer> function = asFunction(String::length).andThen(n -> n * 2);
        System.out.println(function.apply("foo"));
    }

    public static <T1, T2> Function<T1, T2> asFunction(Function<T1, T2> function) {
        return function;     
    }
}
```
- +1 für die zweite, wenn dies wirklich nur über die Vermeidung der cast (ich würde einfach vorschlagen fn(Stream::length))
- Es gibt keine Notwendigkeit, erstellen Sie eine statische Methode. Siehe die Antwort von JB Nizet unten.
- Wahr (obwohl, dann müssen Sie eine separate variable unnötig, oder eine hässliche Besetzung). Lassen es hier so, dass alle Optionen verfügbar sind.
- Eine Frage, die irrelevant für diese Diskussion - wie kann die Methode Referenz String::length werden an eine Methode übergeben, die akzeptiert eine Function? Funktionen akzeptieren parameter und einen Wert zurückgeben, wo, wie die length Methode nicht alles akzeptieren, während Sie gibt einen Wert zurück, wodurch es zu einer Supplier. Kann sein das ich völlig falsch verstanden, wie die Methode Referenzen arbeiten
- UPDATE - die Antwort gefunden auf meine Frage aus diesem ALSO Antwort, welche Angebote Brian Goetz mit den Worten "wenn die desugared Methode ist eine Instanzmethode, der Empfänger ist als das erste argument"
InformationsquelleAutor Jon Skeet

Können Sie speichern Sie ihn einfach in eine variable:

Function<String, Integer> toLength = String::length;
Stream.of("ciao", "hola", "hello")
      .map(toLength.andThen(n -> n * 2));

Verwenden oder verwenden Sie einen Gips, aber es ist weniger gut lesbar IMO:

Stream.of("ciao", "hola", "hello")
      .map(((Function<String, Integer>) String::length).andThen(n -> n * 2));

InformationsquelleAutor JB Nizet

10

Sollten Sie in der Lage sein zu erreichen, was Sie wollen inline-durch die Verwendung von casts:
```
Stream.of("ciao", "hola", "hello")
      .map(((Function<String, Integer>) String::length).andThen(n -> n * 2))
```
Gibt es nur 'geben Tipps' für den compiler, so dass Sie nicht wirklich 'Stimmen' das Objekt und nicht den overhead einer tatsächlichen Besetzung.

Alternativ können Sie verwenden eine lokale variable, die für die Lesbarkeit:
```
Function<String, Integer> fun = String::length

Stream.of("ciao", "hola", "hello")
      .map(fun.andThen(n -> n * 2));
```
Einen Dritten Weg, der möglicherweise mehr prägnant ist mit eine utility-Methode:
```
public static <T, X, U> Function<T, U> chain(Function<T, X> fun1, Function<X, U> fun2)
{
    return fun1.andThen(fun2);
}

Stream.of("ciao", "hola", "hello")
      .map(chain(String::length, n -> n * 2));
```
Bitte beachten Sie, dass dies nicht getestet, also weiß ich nicht, ob Typrückschluss funktioniert korrekt in diesem Fall.
- Also, es ist nicht Zucker syntax zu haben, ihn ohne cast und Klammer...thx
- Siehe mein edit für ein weiteres Beispiel.
InformationsquelleAutor Clashsoft
7

Können Sie auch
```
Function.identity().andThen(String::length).andThen(n -> n * 2)
```
Das problem ist, dass String::length ist nicht unbedingt ein Function; es können entsprechen viele funktionale Schnittstellen. Es muss in einem Kontext verwendet werden, bietet Ziel-Typ, und der Kontext sein könnte, Zuweisung, Methodenaufruf, Gießen.

Wenn Function könnte eine statische Methode, die nur im Interesse der Ziel-Eingabe, könnten wir tun,
```
    Function.by(String::length).andThen(n->n*2)

static <T, R> Function<T, R> by(Function<T, R> f){ return f; }
```
Ich zum Beispiel verwende diese Technik in eine funktionale Schnittstelle
```
static <T> AsyncIterator<T> by(AsyncIterator<T> asyncIterator)
```
Syntax-Zucker zum erstellen einer AsyncIterator aus einem lambda-Ausdruck oder eine Methoden Referenz.

Diese Methode gibt einfach das argument asyncIterator, das scheint ein wenig seltsam. Erklärung:

Seit AsyncIterator ist eine funktionale Schnittstelle, die eine Instanz kann erstellt werden, indem ein lambda-Ausdruck oder eine Methoden Referenz, in 3 Kontexten:
```
 //Assignment Context
 AsyncIterator<ByteBuffer> asyncIter = source::read;
 asyncIter.forEach(...);

 //Casting Context
 ((AsyncIterator<ByteBuffer>)source::read)
     .forEach(...);

 //Invocation Context
 AsyncIterator.by(source::read)
     .forEach(...);
```
Die option 3 sieht besser aus als die beiden anderen, und das ist der Zweck dieser Methode.

InformationsquelleAutor ZhongYu

Können Sie einen cast

Stream.of("ciao", "hola", "hello")
        .map(((Function<String, Integer>) String::length)
                .andThen(n -> n * 2))
        .forEach(System.out::println);

Drucke

8
8
10

InformationsquelleAutor Peter Lawrey

4

Könnten Sie schreiben:
```
Stream.of("ciao", "hola", "hello").map(String::length).map(n -> n * 2);
```
- Ich weiß, aber manchmal möchte ich zum verketten von Funktionen...
- Es geht nicht um die Stream API...
InformationsquelleAutor Tunaki

Wir können reduce - Funktion zur Kombination von mehreren Funktionen in einem.

public static void main(String[] args) {
    List<Function<String, String>> normalizers = Arrays.asList(
    str -> {
        System.out.println(str);
        return str;
    }, 
    String::toLowerCase,
    str -> {
        System.out.println(str);
        return str;
    },
    String::trim,
    str -> {
        System.out.println(str);
        return str;
    });

    String input = " Hello World ";
    normalizers.stream()
               .reduce(Function.identity(), (a, b) -> a.andThen(b))
               .apply(input);
}

Ausgabe:

 Hello World 
 hello world 
hello world

InformationsquelleAutor Kanagavelu Sugumar

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.