Wie debuggt man stream().map(…) mit Lambda-Ausdrücken?

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

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

Bei dieser Migration muss ich zum Beispiel den Guava-Code in Java 8-Änderungen ändern. Also, die Änderungen, die ich vornehme, sind die Art von:

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 Guava war ich sehr komfortabel beim Debuggen des Codes, da ich jeden Transformationsprozess debuggen konnte, aber meine Sorge ist, wie man zum Beispiel debuggt .map(n -> n*2).

Mit dem Debugger kann ich Code sehen wie:

@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 das nicht finden n * 2 Transformation.

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

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

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

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

Dank an Stuart Marks Der Ansatz, Methodenreferenzen zu haben, ermöglichte es mir auch, den Transformationsprozess zu debuggen:

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

Dank an Marlon Bernardes Antwort Ich habe festgestellt, dass mein Eclipse nicht das zeigt, was es sollte, und die Verwendung von peek() hat geholfen, Ergebnisse anzuzeigen.

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

Ein weiterer Ansatz ist die Verwendung peek So überprüfen Sie die Elemente des Streams:

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 glaube, Sie werden verwirrt, weil map ist ein intermediate operation – mit anderen Worten: es ist eine faule Operation, die erst nach a ausgeführt wird terminal operation wurde ausgeführt. Also, wenn Sie anrufen stream.map(n -> n * 2) Der Lambda-Körper wird im Moment nicht ausgeführt. Sie müssen einen Haltepunkt setzen und ihn überprüfen, nachdem eine Terminaloperation aufgerufen wurde (collectin diesem Fall).

Prüfen Stream-Operationen für weitere Erklärungen.

UPDATE 2:

Zitat von Holgers Kommentar:

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

Einfügen eines Zeilenumbruchs direkt danach map(
würde es Ihnen erlauben, nur einen Haltepunkt für den Lambda-Ausdruck zu setzen. Und es ist nicht ungewöhnlich, dass Debugger keine Zwischenwerte von a anzeigen return Aussage. Änderung des Lambda auf n -> { int result=n * 2; return result; }
würde es Ihnen ermöglichen, das Ergebnis zu überprüfen. Fügen Sie wieder Zeilenumbrüche entsprechend ein, wenn Sie Zeile für Zeile schrittweise vorgehen…

IntelliJ hat für diesen Fall ein so nettes Plugin wie a 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 um die Schaltfläche Trace Current Stream Chain, die aktiv wird, wenn der Debugger innerhalb einer Kette von Stream-API-Aufrufen stoppt.

Es hat eine nette Schnittstelle für die Arbeit mit separaten Stream-Operationen und gibt Ihnen die Möglichkeit, einigen Werten zu folgen, die Sie debuggen sollten.

Sie können es manuell aus dem 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 setzen, in der sich ein Lambda befindet, werden Sie tatsächlich einmal getroffen, wenn die Pipeline eingerichtet ist, und dann einmal für jedes Stream-Element. Wenn Sie Ihr Beispiel verwenden, ist das erste Mal, wenn Sie den Haltepunkt erreichen, der map() Aufruf, der die Stream-Pipeline einrichtet:

Sie können den Aufrufstapel und die lokalen Variablen und Parameterwerte für sehen main wie Sie es erwarten würden. Wenn Sie fortfahren, wird der “gleiche” Haltepunkt erneut erreicht, außer dass er sich diesmal innerhalb des Aufrufs an das Lambda befindet:

Beachten Sie, dass sich der Aufrufstapel diesmal tief in der Streams-Maschinerie befindet und die lokalen Variablen die lokalen Variablen des Lambda selbst sind, nicht die umschließenden main Methode. (Ich habe die Werte in der geändert naturals Liste, um dies zu verdeutlichen.)

Wie Marlon Bernardes betonte (+1), können Sie verwenden peek um Werte zu inspizieren, während sie in der Pipeline vorbeiziehen. 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 von speichern peekmuss diese Datenstruktur natürlich Thread-sicher 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 mit einer Methodenreferenz darauf zu verweisen. Zum Beispiel,

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 während des Debuggens vor sich geht. Darüber hinaus erleichtert das Extrahieren von Methoden auf diese Weise den Komponententest. Wenn Ihr Lambda so kompliziert ist, dass Sie es in Einzelschritten durchlaufen müssen, möchten Sie wahrscheinlich sowieso eine Reihe von Komponententests dafür haben.

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

Wenn wir bei einer Zeile anhalten, die ein Lambda enthält, wenn wir drücken F7 (eintreten), dann hebt IntelliJ hervor, was das zu debuggende Snippet sein wird. Wir können wechseln, mit welchem ​​Chunk debuggt werden soll Tab und sobald wir uns entschieden haben, klicken wir F7 wieder.

Hier einige Screenshots zur Veranschaulichung:

1- Drücken F7 (Eintreten) Taste, zeigt die Highlights (oder Auswahlmodus)

2- Verwenden Tab mehrmals, um das zu debuggende Snippet auszuwählen

3- Drücken F7 (eintreten) Schlüssel zum Eintreten

Intellij IDEA 15 scheint es noch einfacher zu machen, es erlaubt, in einem Teil der Linie anzuhalten, wo Lambda ist, siehe das erste Feature: http://blog.jetbrains.com/idea/2015/06/intellij-idea-15-eap-is-open/

Das Debuggen mit IDEs ist immer hilfreich, aber der ideale Weg zum Debuggen aller Elemente in einem Stream ist die Verwendung von peek() vor einer Terminalmethodenoperation, da Java-Steams träge ausgewertet werden. Wenn also keine Terminalmethode aufgerufen wird, wird der jeweilige Stream dies tun 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());