Em nosso projeto, estamos migrando para o java 8 e estamos testando os novos recursos.

No meu projeto, estou usando predicados e funções do Guava para filtrar e transformar algumas coleções usandoCollections2.transform eCollections2.filter.

Nesta migração, preciso alterar, por exemplo, o código da goiaba para as mudanças do java 8. Então, as mudanças que estou fazendo são do tipo:

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);

Para...

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

Usando a goiaba, eu estava muito confortável em depurar o código, pois podia depurar cada processo de transformação, mas minha preocupação é como depurar, por exemplo.map(n -> n*2).

Usando o depurador, vejo alguns códigos como:

@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];
}

Mas não é tão simples quanto o Guava depurar o código, na verdade eu não consegui encontrar on * 2 transformação.

Existe uma maneira de ver essa transformação ou uma maneira fácil de depurar esse código?

EDIT: Adicionei resposta de diferentes comentários e postou respostas

Graças aHolger Com o comentário que respondeu à minha pergunta, a abordagem de ter um bloco lambda me permitiu ver o processo de transformação e depurar o que aconteceu dentro do corpo lambda:

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

Graças aStuart Marks a abordagem de ter referências de método também me permitiu depurar o processo de transformação:

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

Graças aMarlon Bernardes resposta Notei que meu Eclipse não mostra o que deveria e o uso de peek () ajudou a exibir resultados.