Façon concise de composer des références de méthode Java?

Question

Compte tenu des fonctions de méthode Java 8:

class Foo { Bar getBar() {} } 
class Bar { Baz getBaz() {} } 

Composition des deux accesseurs ressemble:

Function<Foo, Bar> getBarFromFoo = Foo::getBar; 
Function<Bar, Baz> getBazFromBar = Bar::getBaz; 
Function<Foo, Baz> getBazFromFoo = getBarFromFoo.andThen(getBazFromBar); 

Y at-il une façon plus concise? Cela semble fonctionner

((Function<Foo, Bar>) Foo::getBar).andThen(Bar::getBaz) 

Mais c'est plutôt moche. Les parens externes ont un sens pour des raisons de préséance, mais pourquoi la distribution est-elle nécessaire?

(Foo::getBar::getBaz serait bien, mais hélas ...)

Answer 1

Il n'y a aucun moyen dédié de la composition des fonctions en Java autre que andThen().

Vous devez effectuer la conversion car Foo::getBar est ambigu. ** Il pourrait correspondre à toutes les interfaces ayant une signature de méthode similaire.

Malheureusement, ((Function<Foo, Bar>) Foo::getBar).andThen(Bar::getBaz) est le meilleur que vous pouvez faire.

Answer 2

Définissons une interface fonctionnelle:

@FunctionalInterface 
interface MyFunctionalInterface { 
    Bar getBar(Foo f); 
} 

Nous pouvons simplifier la référence de la méthode Foo::getBar un peu,

(Foo foo) -> foo.getBar(); 

qui signifie "prendre un Foo et retourner un Bar". Pour cette description, un grand nombre de méthodes sont appropriées (par exemple, notre interface avec le getBar et un Funtion<Foo, Bar> avec son apply):

MyFunctionalInterface f1 = (Foo foo) -> foo.getBar(); 
Function<Foo, Bar> f2 = (Foo foo) -> foo.getBar(); 

C'est la réponse à la question de savoir pourquoi la distribution est nécessaire.

---

Pour répondre à la question de savoir s'il y a une façon plus concise affirmativement, nous devons définir un contexte. Le contexte nous donne clairement un Function de continuer à travailler avec:

class Functions { 
    public static <I, O> Function<I, O> of(Function<I, O> function) { 
     return function; 
    } 
} 

Functions.of(Foo::getBar).andThen(Bar::getBaz); 

Answer 3

Peut-être juste utiliser une expression lambda?

x -> x.getBar().getBaz() 

Il n'existe pas d'autre moyen de composer des fonctions autres que celles que vous avez déjà suggérées en raison de l'ambiguïté de type. Ce n'est même pas beaucoup plus long que Foo::getBar::getBaz

Answer 4

C'est le meilleur que vous obtiendrez. Si vous pensez que cela fonctionnerait:

Foo::getBar::getBaz 

ce ne sera pas.C'est parce que Foo::getBar est une poly expression - cela dépend du contexte utilisé - il pourrait être un Function, mais pourrait également être un Predicate par exemple; donc ça pourrait potentiellement s'appliquer à beaucoup de choses, donc le casting est juste nécessaire là-bas.

Vous pourriez cacher cela derrière une méthode qui ferait le chaînage et andThen, mais le problème est toujours là.

EDIT

Voir un exemple ici:

public static void cool(Predicate<Integer> predicate) { 

} 

public static void cool(Function<Integer, String> function) { 

} 

et l'expression cool(i -> "Test"); échouera à compiler