Implementieren rekursive lambda-Funktion, die mit Java 8

Normalerweise verwende ich (einmal-für-alle-funktionelle-Schnittstellen definiert) generische helper-Klasse die wraps die variable der funktionalen Schnittstelle geben.
Dieser Ansatz löst das problem mit der lokalen Initialisierung der Variablen und erlaubt den code zu schauen mehr klar.

In dieser Frage wird der code wie folgt Aussehen:

//Recursive.java
//@param <I> - Functional Interface Type
public class Recursive<I> {
    public I func;
}

//Test.java
public double factorial(int n) {

    Recursive<IntToDoubleFunction> recursive = new Recursive<>();
    recursive.func = x -> (x == 0) ? 1 : x * recursive.func.applyAsDouble(x - 1);

    return recursive.func.applyAsDouble(n);
}

InformationsquelleAutor Andrey Morozov

Lokale und anonyme Klassen, sowie lambdas, erfassen der lokalen Variablen von Wert, wenn Sie erstellt werden. Daher ist es für Sie unmöglich, sich selbst durch die Erfassung einer lokalen Variablen, weil Sie den Wert für verweist auf sich selbst existiert noch nicht an der Zeit, die Sie erstellt werden.

Code in lokale und anonyme Klassen können immer noch finden sich mit this. Allerdings this in einen lambda-Ausdruck bezieht sich nicht auf den lambda; es bezieht sich auf die this von außen Umfang.

Können Sie erfassen eine veränderbare Datenstruktur, wie ein array, statt:

IntToDoubleFunction[] foo = { null };
foo[0] = x -> { return  ( x == 0)?1:x* foo[0].applyAsDouble(x-1);};

aber kaum als eine elegante Lösung.

InformationsquelleAutor newacct

Einer Lösung ist, um zu definieren, diese Funktion als INSTANZ-Attribut.

import java.util.function.*;
public class Test{

    IntToDoubleFunction fact = x -> { return  ( x == 0)?1:x* fact.applyAsDouble(x-1);};

    public static void main(String[] args) {
      Test test = new Test();
      test.doIt();
    }

    public void doIt(){
       System.out.println("fact(3)=" + fact.applyAsDouble(3));
    }
}

InformationsquelleAutor user2678835

Definieren Sie eine rekursive lambda als eine Instanz-oder Klassenvariable:

static DoubleUnaryOperator factorial = x -> x == 0 ? 1
                                          : x * factorial.applyAsDouble(x - 1);

Beispiel:

class Test {
    static DoubleUnaryOperator factorial = x -> x == 0 ? 1
                                             : x * factorial.applyAsDouble(x - 1));
    public static void main(String[] args) {
        System.out.println(factorial.applyAsDouble(5));
    }
}

Drucke 120.0.

InformationsquelleAutor assylias

Folgende funktioniert, aber es tut geheimnisvoll erscheinen.

import java.util.function.Function;

class recursion{

Function<Integer,Integer>  factorial_lambda;  //The positions of the lambda declaration and initialization must be as is.

public static void main(String[] args) {  new recursion();}

public recursion() {
 factorial_lambda=(i)->{
        if(i==1)
            return 1;
        else
            return i*(factorial_lambda.apply(i-1));
    };
    System.out.println(factorial_lambda.apply(5));
 }
}

//Output 120

InformationsquelleAutor Jerrolds

Hörte ich auf der JAX in diesem Jahr, dass "lambads unterstützen keine Rekursion". Was ist gemeint mit dieser Aussage ist, dass "this" innerhalb der lambda beziehen sich immer auf die umgebende Klasse.

Aber ich schaffte es zu definieren - zumindest so verstehe ich den Begriff "Rekursion" - eine rekursive lambda-und es geht so:

interface FacInterface {
  int fac(int i);
}
public class Recursion {
  static FacInterface f;
  public static void main(String[] args)
  {
    int j = (args.length == 1) ? new Integer(args[0]) : 10;
    f = (i) -> { if ( i == 1) return 1;
      else return i*f.fac( i-1 ); };
    System.out.println( j+ "! = " + f.fac(j));
  }
}

Speichern diese in einer Datei "Recursion.java" und die beiden Befehle "javac Recursion.java" und "java Rekursion" es funktionierte für mich.

Der clou ist, dass die Schnittstelle, die lambda hat zu implementieren, wie eine Feld-variable in der umgebenden Klasse. Die lambda kann beziehen sich auf dieses Feld und das Feld nicht implizit final.

InformationsquelleAutor beck

Angesichts der Tatsache, dass "dieser" in den lambda-Ausdruck bezieht sich auf die enthaltende Klasse, die folgenden kompiliert ohne Fehler (mit zusätzlichen Abhängigkeiten, natürlich):

public class MyClass {
    Function<Map, CustomStruct> sourceToStruct = source -> {
        CustomStruct result;
        Object value;

        for (String key : source.keySet()) {
            value = source.get(key);

            if (value instanceof Map) {
                value = this.sourceToStruct.apply((Map) value);
            }

            result.setValue(key, value);
        }

        return result;
    };
}

InformationsquelleAutor Rebel Geek

Stieß auf diese Frage bei einem Vortrag über Lambda-Ausdrücke, die verwendet Fibonacci als einen möglichen Anwendungsfall.

Können Sie eine rekursive lambda-Ausdruck wie diesem:

import java.util.function.Function;

public class Fib {

   static Function<Integer, Integer> fib;

   public static void main(String[] args) {
       fib = (n) -> { return n > 1 ? fib.apply(n-1) + fib.apply(n-2) : n; };

       for(int i = 0; i < 10; i++){
           System.out.println("fib(" + i + ") = " + fib.apply(i));
       }
   }
}

Was müssen Sie beachten?

• Lambda-Ausdrücke werden ausgewertet, auf die Ausführung -> Sie können rekursiv sein

• Mittels eines lambda-variable innerhalb einer anderen lambda-erfordert die
  variable initialisiert werden -> vor der Definition eine rekursive lambda-Sie
  definieren Sie es mit einem foo-Wert

• mit einem lokalen lambda-Variablen innerhalb eines lambda-erfordert die variable
  endgültig, so kann es nicht neu definiert werden -> verwenden Sie eine Klasse/Objekt
  variable für die lambda - wie es bei der Initialisierung mit einem Standardwert

InformationsquelleAutor 000000000000000000000

Antwort ist : Sie haben eine diese vor dem Namen der variable aufrufen applyAsDouble Funktion :-

IntToDoubleFunction fact = x -> x == 0 ? 1 : x * this.fact.applyAsDouble(x-1);

wenn Sie die Tatsache Finale auch, es wird funktionieren

final IntToDoubleFunction fact = x -> x == 0 ? 1 : x * this.fact.applyAsDouble(x-1);

Können wir mithilfe der funktionellen Schnittstelle UnaryOperator hier. Ein unärer operator, der immer wieder seine input-argument.

1) fügen Sie Einfach diese. vor dem Namen der Funktion, wie in:

UnaryOperator<Long> fact = x -> x == 0 ? 1  : x * this.fact.apply(x - 1 );

Diese wird hep zu vermeiden "kann Nicht auf ein Feld, bevor es definiert ist".

2) Wenn Sie lieber eine statische Feld, ersetzen Sie diesen durch den Namen der Klasse:

static final UnaryOperator<Long> fact = x -> x== 0? 1: x * MyFactorial.fact.apply(x - 1 );

InformationsquelleAutor Arundev

Hier ist eine Lösung, die sich nicht auf eine Nebenwirkung. Um den Zweck zu interessanten, zu sagen, dass Sie möchten, um Abstrakt über die Rekursion (sonst ist das Instanz-Feld-Lösung durchaus gültig ist).
Der trick ist die Verwendung einer anonymen Klasse, um den "this" - Referenz:

public static IntToLongFunction reduce(int zeroCase, LongBinaryOperator reduce) {
  return new Object() {
    IntToLongFunction f = x -> x == 0
                               ? zeroCase
                               : reduce.applyAsLong(x, this.f.applyAsLong(x - 1));
  }.f;
}

public static void main(String[] args) {
  IntToLongFunction fact = reduce(1, (a, b) -> a * b);
  IntToLongFunction sum = reduce(0, (a, b) -> a + b);
  System.out.println(fact.applyAsLong(5)); //120
  System.out.println(sum.applyAsLong(5)); //15
}

InformationsquelleAutor JbGi

Erstellen Sie eine rekursive Funktion, die mithilfe dieser Klasse:

public class Recursive<I> {
    private Recursive() {

    }
    private I i;
    public static <I> I of(Function<RecursiveSupplier<I>, I> f) {
        Recursive<I> rec = new Recursive<>();
        RecursiveSupplier<I> sup = new RecursiveSupplier<>();
        rec.i = f.apply(sup);
        sup.i = rec.i;
        return rec.i;
    }
    public static class RecursiveSupplier<I> {
        private I i;
        public I call() {
            return i;
        }
    }
}

Und dann können Sie keine funktionalen Oberfläche in nur 1 Zeile über, eine lambda und der definition der funktionalen Schnittstelle wie folgt:

Function<Integer, Integer> factorial = Recursive.of(recursive ->
        x -> x == 0 ? 1 : x * recursive.call().apply(x - 1));
System.out.println(factorial.apply(5));

Ich fand es sehr intuitiv und einfach zu bedienen.

InformationsquelleAutor Jose Da Silva