Explicación de expresiones lambda

Tengo preguntas sobre expresiones lambda y RxJava. Estas preguntas se refieren principalmente a una comprensión incompleta de las expresiones lambda o RxJava. Trataré de explicar las expresiones lambda lo más simple posible. RxJava lo describiré por separado.

Expresiones Lambda y RxJava

¿Qué son las expresiones lambda? Las expresiones lambda son "simplemente" una nueva forma de hacer lo mismo que siempre podríamos hacer, pero en una nueva forma más limpia y menos detallada de usar clases internas anónimas.

Una clase interna anónima en Java es una clase sin nombre, debe usarse si necesita anular la clase o los métodos de interfaz. Se puede crear una clase interna anónima desde una clase o interfaz.

Por ejemplo:

abstract class Animal { abstract void speak(); } Animal a = new Animal() { void speak() { System.out.println("Woff"); } }; 

En Android, usualmente usamos una clase interna anónima como oyente, por ejemplo, para botones de este tipo:

 Button btn = findViewById(R.id.button); btn.setOnClickListener( new View.OnClickListener() { @Override public void onClick(final View view) { // Do some fancy stuff with the view parameter. } } ); 

Volvamos a las expresiones lambda. Esta es la siguiente parte, que es parte del código anterior, que se considera una clase interna anónima.

 new View.OnClickListener() { @Override public void onClick(final View view) { // Do some fancy stuff with the view parameter. } } 

Las expresiones lambda solo se pueden usar si necesita anular como máximo un método. Afortunadamente para nosotros, View.OnClickListener contiene solo uno. Echa un vistazo al código a continuación. ¿Qué parte crees que tenemos que eliminar?

 new View.OnClickListener() { @Override public void onClick(final View view) { // Do some fancy stuff with the view parameter. } } 

Después de eliminar casi todo el código, necesitamos agregar ->, como en el siguiente código. La vista de parámetros de entrada se puede usar dentro de la función de la misma manera que antes.

 (view) -> { // Do some fancy stuff with the view parameter. } 

En algunos casos, es posible que deba agregar un tipo a un parámetro, si el compilador no puede adivinarlo, puede hacerlo agregándolo antes del parámetro:

 (View view) -> { // Do some fancy stuff with the view parameter. } 

También puede usar código de varias líneas:

 (view) -> { Intent intent = new Intent(context, AuthActivity.class); intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK); view.getContext().startActivity(intent); } 

Si tiene una interfaz con un método que toma dos parámetros ...

 interface MyInterface { abstract void onMethod(int a, int b); } 

... la expresión lambda se verá así:

 (a, b) -> { // Do some fancy stuff with the a and b parameter. } 

Si el método tiene un tipo de retorno ...

 interface MySecondInterface { abstract int onSecondMethod(int a, int b); } 

... la expresión lambda se verá así:

 (a, b) -> { return a + b; } 

Pero eso no es todo, hay algunos casos especiales que hacen que el código sea aún más pequeño. Si el cuerpo de su método contiene solo una línea de código, puede eliminar las llaves {} . Si elimina llaves, también debe quitar el punto y coma, dejando lo siguiente:

 (a, b) -> return a + b 

Hay una cosa más que podemos hacer. Si solo tenemos una línea de código, el compilador puede comprender si la parte devuelta es necesaria o no, por lo que podemos dejarla así:

 (a, b) -> a + b 

Si tuviéramos código de varias líneas, se reduciría a lo siguiente:

 (a, b) -> { a+=1; return a + b; } 

Entonces, ¿qué hemos hecho? Tomamos esto:

 new MySecondInterface() { @Override public int onSecondMethod(final int a, final int b) { return a + b; } }; 

y lo convirtió en esto:

 (a, b) -> a + b 

Solo queda una cosa, referencias de métodos. Supongamos que tenemos una interfaz, como antes, y un método que acepta esta interfaz como parámetro:

 public interface Callback { public void onEvent(int event); } public void myMethod(Callback callback){ } 

Sin una expresión lambda, se vería así:

 myMethod(new Callback() { @Override public void onEvent(final int state) { System.out.println(state); } }); 

Al agregar una expresión lambda, como lo hicimos antes, obtenemos lo siguiente:

 myMethod(state -> System.out.println(state)); 

Pero eso no es todo. Si el código utilizado es de una sola línea y la función llamada toma un parámetro, podemos pasar la referencia del método de esta forma:

 myMethod(System.out::println); 

¡El parámetro se pasará automáticamente, sin necesidad de otro código! Increíble verdad? ¡Espero que hayas aprendido algo nuevo!