Korzystanie Scala z Java: przechodzącą funkcji jako parametry

Question

Rozważmy następujący kod Scala:

package scala_java 
object MyScala { 
    def setFunc(func: Int => String) { 
    func(10) 
    } 
} 

Teraz w Javie, chciałbym użyć MyScala jak:

package scala_java; 
public class MyJava { 
    public static void main(String [] args) { 
     MyScala.setFunc(myFunc); // This line gives an error 
    } 
    public static String myFunc(int someInt) { 
     return String.valueOf(someInt); 
    } 
} 

Jednakże powyższe nie nie działa (zgodnie z oczekiwaniami, ponieważ Java nie zezwala na programowanie funkcjonalne). Jaki jest najłatwiejszy sposób obejścia funkcji w Javie? Chciałbym ogólne rozwiązanie, które działa z funkcjami mającymi dowolną liczbę parametrów.

EDYCJA: Czy Java 8 ma lepszą składnię niż klasyczne rozwiązania omówione poniżej?

Answer 1

Musisz ręcznie utworzyć egzemplarz Function1 w Javie. Coś jak:

final Function1<Integer, String> f = new Function1<Integer, String>() { 
    public int $tag() { 
     return Function1$class.$tag(this); 
    } 

    public <A> Function1<A, String> compose(Function1<A, Integer> f) { 
     return Function1$class.compose(this, f); 
    } 

    public String apply(Integer someInt) { 
     return myFunc(someInt); 
    } 
}; 
MyScala.setFunc(f); 

Jest to wzięte z Daniel Spiewak’s “Interop Between Java and Scala” article.

Answer 2

Najprostszym sposobem dla mnie jest zdefiniował java interfejs jak:

public interface JFunction<A,B> { 
    public B compute(A a); 
} 

Następnie zmodyfikować kod Scala, przeciążenia setFunc przyjąć także JFunction obiektów, takich jak:

object MyScala { 
    // API for scala 
    def setFunc(func: Int => String) { 
    func(10) 
    } 
    // API for java 
    def setFunc(jFunc: JFunction[Int,String]) { 
    setFunc((i:Int) => jFunc.compute(i)) 
    } 
} 

Ty naturalnie użyje pierwszej definicji ze scala, ale nadal będzie mógł użyć drugiej z java:

public class MyJava { 
    public static void main(String [] args) { 
    MyScala.setFunc(myFunc); // This line gives an error 
    } 

    public static final JFunction<Integer,String> myFunc = 
    new JFunction<Integer,String>() { 
     public String compute(Integer a) { 
     return String.valueOf(a); 
     } 
    }; 

} 

Answer 3

W pakiecie scala.runtime znajdują się klasy abstrakcyjne o nazwie AbstractFunction1 itd. Dla innych arii. Aby z nich korzystać z Java wystarczy zastąpić apply, tak:

Function1<Integer, String> f = new AbstractFunction1<Integer, String>() { 
    public String apply(Integer someInt) { 
     return myFunc(someInt); 
    } 
}; 

Jeśli jesteś na Java 8 i chcesz używać Java 8 składni lambda za to, sprawdź https://github.com/scala/scala-java8-compat.

Answer 4

Oto moja próba rozwiązania, trochę biblioteka: https://github.com/eirslett/sc8

owinąć lambda w F (...) Java 8, a następnie jest konwertowany do funkcji Scala.