Wie debugge ich stream (). Map (…) mit Lambda-Ausdrücken?

In unserem Projekt migrieren wir auf Java 8 und testen die neuen Funktionen.

In meinem Projekt verwende ich Guava-Prädikate und -Funktionen, um einige Sammlungen mit Collections2.transformund zu filtern und zu transformieren Collections2.filter.

Bei dieser Migration muss ich zum Beispiel Guavencode in Java 8 ändern. Die Änderungen, die ich vornehme, sind folgende:

List<Integer> naturals = Lists.newArrayList(1,2,3,4,5,6,7,8,9,10,11,12,13);

Function <Integer, Integer> duplicate = new Function<Integer, Integer>(){
    @Override
    public Integer apply(Integer n)
    {
        return n * 2;
    }
};

Collection result = Collections2.transform(naturals, duplicate);

Zu...

List<Integer> result2 = naturals.stream()
    .map(n -> n * 2)
    .collect(Collectors.toList());

Mit Guave war ich sehr komfortabel beim Debuggen des Codes, da ich jeden Transformationsprozess debuggen konnte, aber mein Anliegen ist beispielsweise das Debuggen .map(n -> n*2).

Mit dem Debugger kann ich folgenden Code sehen:

@Hidden
@DontInline
/** Interpretively invoke this form on the given arguments. */
Object interpretWithArguments(Object... argumentValues) throws Throwable {
    if (TRACE_INTERPRETER)
        return interpretWithArgumentsTracing(argumentValues);
    checkInvocationCounter();
    assert(arityCheck(argumentValues));
    Object[] values = Arrays.copyOf(argumentValues, names.length);
    for (int i = argumentValues.length; i < values.length; i++) {
        values[i] = interpretName(names[i], values);
    }
    return (result < 0) ? null : values[result];
}

Aber es ist nicht so einfach wie Guava, den Code zu debuggen, eigentlich konnte ich die n * 2Transformation nicht finden .

Gibt es eine Möglichkeit, diese Transformation zu sehen oder diesen Code einfach zu debuggen?

BEARBEITEN: Ich habe Antworten aus verschiedenen Kommentaren hinzugefügt und Antworten gepostet

Dank eines HolgerKommentars, der meine Frage beantwortete, ermöglichte mir der Ansatz, einen Lambda-Block zu haben, den Transformationsprozess zu sehen und zu debuggen, was im Lambda-Körper passiert ist:

.map(
    n -> {
        Integer nr = n * 2;
        return nr;
    }
)

Dank Stuart Marksdes Ansatzes, Methodenreferenzen zu haben, konnte ich auch den Transformationsprozess debuggen:

static int timesTwo(int n) {
    Integer result = n * 2;
    return result;
}
...
List<Integer> result2 = naturals.stream()
    .map(Java8Test::timesTwo)
    .collect(Collectors.toList());
...

Dank der Marlon BernardesAntwort bemerkte ich, dass meine Eclipse nicht anzeigt, was sie sollte, und die Verwendung von peek () half, Ergebnisse anzuzeigen.

Normalerweise habe ich kein Problem damit, Lambda-Ausdrücke zu debuggen, während ich Eclipse oder IntelliJ IDEA verwende. Setzen Sie einfach einen Haltepunkt und achten Sie darauf, nicht den gesamten Lambda-Ausdruck zu überprüfen (überprüfen Sie nur den Lambda-Körper).

Ein anderer Ansatz besteht darin peek, die Elemente des Streams zu untersuchen:

List<Integer> naturals = Arrays.asList(1,2,3,4,5,6,7,8,9,10,11,12,13);
naturals.stream()
    .map(n -> n * 2)
    .peek(System.out::println)
    .collect(Collectors.toList());

AKTUALISIEREN:

Ich denke, Sie werden verwirrt, weil mapes sich um eine intermediate operation- mit anderen Worten: es handelt sich um eine faule Operation handelt, die erst ausgeführt wird, nachdem a terminal operationausgeführt wurde. Wenn Sie also stream.map(n -> n * 2)den Lambda-Körper anrufen , wird er im Moment nicht ausgeführt. Sie müssen einen Haltepunkt festlegen und ihn überprüfen, nachdem eine Terminaloperation aufgerufen wurde ( collectin diesem Fall).

Überprüfen Sie Stream Operations auf weitere Erklärungen.

UPDATE 2:

Zitat von Holgers Kommentar:

Was es hier schwierig macht, ist, dass der Aufruf von map und der Lambda-Ausdruck in einer Zeile stehen, sodass ein Zeilenumbruchpunkt bei zwei völlig unabhängigen Aktionen stoppt.

Wenn Sie direkt danach einen Zeilenumbruch einfügen map( , können Sie einen Unterbrechungspunkt nur für den Lambda-Ausdruck festlegen. Und es ist nicht ungewöhnlich, dass Debugger keine Zwischenwerte einer returnAnweisung anzeigen. Wenn Sie das Lambda ändern, n -> { int result=n * 2; return result; } können Sie das Ergebnis überprüfen. Fügen Sie erneut Zeilenumbrüche ein, wenn Sie Zeile für Zeile fortschreiten.

IntelliJ hat für diesen Fall ein so schönes Plugin wie ein Java Stream Debugger- Plugin. Sie sollten es überprüfen: https://plugins.jetbrains.com/plugin/9696-java-stream-debugger?platform=hootsuite

Es erweitert das IDEA Debugger-Toolfenster durch Hinzufügen der Schaltfläche Aktuelle Stream-Kette verfolgen, die aktiv wird, wenn der Debugger innerhalb einer Kette von Stream-API-Aufrufen stoppt.

Es hat eine schöne Oberfläche für die Arbeit mit separaten Streams und bietet Ihnen die Möglichkeit, einige Werte zu befolgen, die Sie debuggen sollten.

Sie können es manuell über das Debug-Fenster starten, indem Sie hier klicken:

Das Debuggen von Lambdas funktioniert auch gut mit NetBeans. Ich verwende NetBeans 8 und JDK 8u5.

Wenn Sie einen Haltepunkt in einer Zeile festlegen, in der sich ein Lambda befindet, werden Sie beim Einrichten der Pipeline tatsächlich einmal und dann für jedes Stream-Element einmal getroffen. In Ihrem Beispiel ist das erste Mal, dass Sie den Haltepunkt erreichen, der map()Aufruf, der die Stream-Pipeline einrichtet:

Sie können den Aufrufstapel sowie die lokalen Variablen und Parameterwerte mainwie erwartet anzeigen. Wenn Sie weitergehen, wird der "gleiche" Haltepunkt erneut erreicht, außer diesmal innerhalb des Aufrufs an das Lambda:

Beachten Sie, dass sich der Aufrufstapel diesmal tief in der Streams-Maschinerie befindet und die lokalen Variablen die Einheimischen des Lambda selbst sind, nicht die einschließende mainMethode. (Ich habe die Werte in der naturalsListe geändert , um dies zu verdeutlichen.)

Wie Marlon Bernardes betonte (+1), können Sie damit peekWerte überprüfen, die in der Pipeline vergehen. Seien Sie jedoch vorsichtig, wenn Sie dies aus einem parallelen Stream verwenden. Die Werte können in einer unvorhersehbaren Reihenfolge über verschiedene Threads hinweg gedruckt werden. Wenn Sie Werte in einer Debugging-Datenstruktur aus speichern peek, muss diese Datenstruktur natürlich threadsicher sein.

Wenn Sie Lambdas häufig debuggen (insbesondere Lambdas mit mehrzeiligen Anweisungen), ist es möglicherweise vorzuziehen, das Lambda in eine benannte Methode zu extrahieren und dann mithilfe einer Methodenreferenz darauf zu verweisen. Beispielsweise,

static int timesTwo(int n) {
    return n * 2;
}

public static void main(String[] args) {
    List<Integer> naturals = Arrays.asList(3247,92837,123);
    List<Integer> result =
        naturals.stream()
            .map(DebugLambda::timesTwo)
            .collect(toList());
}

Dies macht es möglicherweise einfacher zu sehen, was beim Debuggen vor sich geht. Darüber hinaus erleichtert das Extrahieren von Methoden auf diese Weise den Unit-Test. Wenn Ihr Lambda so kompliziert ist, dass Sie es in einem Schritt durchlaufen müssen, möchten Sie wahrscheinlich trotzdem eine Reihe von Unit-Tests dafür durchführen.

Intellij IDEA 15 scheint es noch einfacher zu machen, es ermöglicht das Anhalten in einem Teil der Linie, in der sich Lambda befindet, siehe die erste Funktion: http://blog.jetbrains.com/idea/2015/06/intellij-idea-15 -eap-is-open /

Um weitere aktualisierte Details bereitzustellen (Oktober 2019), hat IntelliJ eine hübsche Integration hinzugefügt, um diese Art von Code zu debuggen, die äußerst nützlich ist.

Wenn wir an einer Zeile anhalten, die ein Lambda enthält, wenn wir drücken F7(eintreten), hebt IntelliJ das zu debuggende Snippet hervor. Wir können wechseln, mit welchem ​​Block Tabwir debuggen möchten, und sobald wir uns dafür entschieden haben, klicken wir F7erneut.

Hier einige Screenshots zur Veranschaulichung:

1- Drücken Sie die F7Taste (Schritt in), um die Markierungen (oder den Auswahlmodus) anzuzeigen.

2- Verwenden Tab Sie das zu debuggende Snippet mehrmals aus

3- Drücken Sie die F7Taste (Schritt hinein), um hineinzugehen

Das Debuggen mit IDEs ist immer hilfreich, aber die ideale Methode zum Debuggen durch die einzelnen Elemente in einem Stream besteht darin, peek () vor einer Terminalmethodenoperation zu verwenden, da Java-Steams träge ausgewertet werden. Wenn also keine Terminalmethode aufgerufen wird, wird der jeweilige Stream verwendet nicht ausgewertet werden.

List<Integer> numFromZeroToTen = Arrays.asList(1,2,3,4,5,6,7,8,9,10);

    numFromZeroToTen.stream()
        .map(n -> n * 2)
        .peek(n -> System.out.println(n))
        .collect(Collectors.toList());