¿Existe algún beneficio de rendimiento al usar la sintaxis de referencia del método en lugar de la sintaxis lambda en Java 8?

¿Las referencias a métodos omiten la sobrecarga del contenedor lambda? ¿Podrían ellos en el futuro?

De acuerdo con el Tutorial de Java sobre referencias de métodos :

A veces ... una expresión lambda no hace más que llamar a un método existente. En esos casos, a menudo es más claro referirse al método existente por su nombre. Las referencias de métodos le permiten hacer esto; son expresiones lambda compactas y fáciles de leer para métodos que ya tienen un nombre.

Prefiero la sintaxis lambda a la sintaxis de referencia del método por varias razones:

Las lambdas son más claras

A pesar de las afirmaciones de Oracle, encuentro que la sintaxis lambda es más fácil de leer que la referencia breve al método de objeto porque la sintaxis de referencia del método es ambigua:

Bar::foo

¿Está llamando a un método estático de un argumento en la clase de x y pasándole x?

x -> Bar.foo(x)

¿O estás llamando a un método de instancia de argumento cero en x?

x -> x.foo()

La sintaxis de referencia del método podría sustituir a cualquiera de los dos. Oculta lo que su código está haciendo realmente.

Las lambdas son más seguras

Si hace referencia a Bar :: foo como un método de clase y luego Bar agrega un método de instancia con el mismo nombre (o viceversa), su código ya no se compilará.

Puedes usar lambdas constantemente

Puede ajustar cualquier función en un lambda, por lo que puede usar la misma sintaxis de manera consistente en todas partes. La sintaxis de referencia del método no funcionará en los métodos que toman o devuelven matrices primitivas, lanzan excepciones verificadas o tienen el mismo nombre de método utilizado como una instancia y un método estático (porque la sintaxis de referencia del método es ambigua sobre qué método se llamaría) . No funcionan cuando ha sobrecargado los métodos con el mismo número de argumentos, pero no debe hacerlo de todos modos (consulte el artículo 41 de Josh Bloch), por lo que no podemos compararlo con las referencias de métodos.

Conclusión

Si no hay una penalización de rendimiento por hacerlo, estoy tentado a desactivar la advertencia en mi IDE y usar la sintaxis lambda de manera consistente sin rociar la referencia de método ocasional en mi código.

PD

Ni aquí ni allá, pero en mis sueños, las referencias a métodos de objetos se parecen más a esto y aplican invoke-dynamic contra el método directamente en el objeto sin un contenedor lambda:

_.foo()

En muchos escenarios, creo que lambda y referencia de método son equivalentes. Pero la lambda ajustará el objetivo de invocación por el tipo de interfaz declarante.

Por ejemplo

public class InvokeTest {

    private static void invoke(final Runnable r) {
        r.run();
    }

    private static void target() {
        new Exception().printStackTrace();
    }

    @Test
    public void lambda() throws Exception {
        invoke(() -> target());
    }

    @Test
    public void methodReference() throws Exception {
        invoke(InvokeTest::target);
    }
}

Verá la salida de la consola del stacktrace.

En lambda(), el método que llama target()es lambda$lambda$0(InvokeTest.java:20), que tiene información de línea rastreable. Obviamente, esa es la lambda que escribes, el compilador genera un método anónimo para ti. Y luego, la persona que llama del método lambda es algo así como InvokeTest$$Lambda$2/1617791695.run(Unknown Source), es la invokedynamicllamada en JVM, significa que la llamada está vinculada al método generado .

En methodReference(), la llamada al método target()es directamente InvokeTest$$Lambda$1/758529971.run(Unknown Source), significa que la llamada está directamente vinculada al InvokeTest::targetmétodo .

Conclusión

Sobre todo, compárelo con referencia de método, el uso de la expresión lambda solo causará una llamada más al método de generación desde lambda.

Se trata de la metafactory

Primero, la mayoría de las referencias de métodos no necesitan ser desvanecidas por la metafábrica lambda, simplemente se usan como método de referencia. En la sección "Azúcar corporal Lambda" del artículo de la Traducción de las expresiones Lambda ("TLE"):

En igualdad de condiciones, los métodos privados son preferibles a los no privados, los métodos estáticos preferibles a los métodos de instancia, es mejor si los cuerpos lambda se insertan en la clase más interna en la que aparece la expresión lambda, las firmas deben coincidir con la firma del cuerpo de la lambda, extra los argumentos deben anteponerse al frente de la lista de argumentos para los valores capturados, y no desaprenderían en absoluto las referencias de métodos. Sin embargo, hay casos excepcionales en los que es posible que tengamos que desviarnos de esta estrategia de referencia.

Esto se resalta aún más abajo en "The Lambda Metafactory" de TLE:

metaFactory(MethodHandles.Lookup caller, // provided by VM
            String invokedName,          // provided by VM
            MethodType invokedType,      // provided by VM
            MethodHandle descriptor,     // lambda descriptor
            MethodHandle impl)           // lambda body

El implargumento identifica el método lambda, ya sea un cuerpo lambda desugared o el método nombrado en una referencia de método.

Las referencias de un Integer::summétodo de instancia estático ( ) o sin límite ( Integer::intValue) son las 'más simples' o las más 'convenientes', en el sentido de que pueden ser manejadas de manera óptima por una variante metafábrica de 'vía rápida' sin el desvanecimiento . Esta ventaja se señala de manera útil en las "variantes metafactorias" de TLE:

Al eliminar argumentos donde no son necesarios, los archivos de clase se vuelven más pequeños. Y la opción de ruta rápida baja la barra para que la VM intrinsifique la operación de conversión lambda, lo que le permite ser tratada como una operación de "boxeo" y facilita las optimizaciones de unbox.

Naturalmente, una referencia de método de captura de instancias ( obj::myMethod) necesita proporcionar la instancia acotada como un argumento para el identificador del método para invocación, lo que puede significar la necesidad de desugar el uso de métodos 'puente'.

Conclusión

No estoy exactamente seguro de cuál es el 'envoltorio' lambda al que estás insinuando, pero a pesar de que el resultado final de usar tus lambdas o referencias de método definidas por el usuario es el mismo, la forma en que se alcanza parece ser bastante diferente, y puede ser diferente en el futuro si ese no es el caso ahora. Por lo tanto, supongo que es más probable que las referencias a métodos puedan ser manejadas de manera más óptima por la metafábrica.

Hay una consecuencia bastante grave cuando se usan expresiones lambda que pueden afectar el rendimiento.

Cuando declara una expresión lambda, está creando un cierre sobre el ámbito local.

¿Qué significa esto y cómo afecta el rendimiento?

Bueno, me alegra que lo hayas preguntado. Significa que cada una de esas pequeñas expresiones lambda es una pequeña clase interna anónima y eso significa que lleva consigo una referencia a todas las variables que están en el mismo alcance de la expresión lambda.

Esto significa también thisreferencia de la instancia del objeto y todos sus campos. Dependiendo del momento de la invocación real de la lambda, esto puede equivaler a una pérdida de recursos bastante significativa ya que el recolector de basura no puede soltar estas referencias mientras el objeto que se mantiene en una lambda todavía esté vivo ...