Buenos días, dejamos un código explicativo sobre Lambda, nueva característica de Java 8.
package lambda;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import javax.swing.JButton;
/**
* Clase que utilizaremos en la parte de métodos de comparación con Lambda
*
* @author jaimecl
*
*/
public class Persona {
private String surName;
public Persona(String surName) {
super();
this.surName = surName;
}
public String getSurName() {
return surName;
}
public void setSurName(String surName) {
this.surName = surName;
}
/* Método de impresión de valores */
public void printName() {
System.out.println("surName=" + surName + "]");
}
/* Método que creará una lista corta de Personas, a modo de datos de ejemplo */
private static List createShortList() {
ArrayList lista = new ArrayList();
lista.add(new Persona("Carmona"));
lista.add(new Persona("Pérez"));
return lista;
}
/**
* Método principal
*
* @param args
*/
public static void main(String args) {
/*
* Empezamos con clases anónimas: utilizadas en un sólo punto del código
* No hay necesidad de tener que definir una clase única que sea
* referenciada sólo una vez
*/
JButton testButton = new JButton("Test Button");
testButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ae) {
System.out.println("Click Detected by Anon Class");
}
});
/*
* Java8 define como interfaz funcional aquella clase que define un sólo
* método. Las expresiones Lambda pueden ser aplicadas sobre dichas
* interfaces La sintaxis es la siguiente argumento -> cuerpo. (int x,
* int y) -> x + y
*
* () -> 42
*
* (String s) -> { System.out.println(s); }
*/
/* A continuación, vemos cómo definir Lambda Runnable */
/* Manera antigua, con una clase anónima */
new Runnable() {
@Override
public void run() {
System.out.println("JavaHispaneros, ¡manera anónima!");
}
}.run();
// Con Lambda, la interfaz runnable tiene un sólo método, por lo tanto,
// podemos redefinirlo de la siguiente manera.
Runnable r2 = () -> System.out
.println("JavaHispaneros, ¡esto es Lambda!");
/* A continuación, vemos un ejemplo de ordenación de listas */
List personList = Persona.createShortList();
/*
* Ordenación con clases anónimas. Dentro del método sort, que espera
* una interfaz de tipo Comparator, hacemos una redefinición
*/
Collections.sort(personList, new Comparator() {
public int compare(Persona p1, Persona p2) {
return p1.getSurName().compareTo(p2.getSurName());
}
});
// Ordenación ascendente, en este caso, haciendo uso de expresiones
// lambda
/*
* El método sort de Collections espera un único método, con dos
* parámetros. Por lo tanto, utilizamos la sintaxis lambda para definir
* el método de comparación
*/
Collections.sort(personList, (Persona p1, Persona p2) -> p1
.getSurName().compareTo(p2.getSurName()));
// Mismo caso, ejerciendo la ordenación descendente.
Collections.sort(personList,
(p1, p2) -> p2.getSurName().compareTo(p1.getSurName()));
/* Otro caso para listeners */
JButton botonMetodoAnonimo = new JButton("Botón con método anónimo");
botonMetodoAnonimo.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent ae) {
System.out.println("Click detectado por clase anónima");
}
});
/*
* De nuevo, vemos que addActionListener acepta una clase que implemente
* la interfaz listener, que define un método único, por lo tanto,
* acepta expresiones lambda Recordamos la sintaxis: nombre de variable
* en parámetro -> acción a realizar Choca ver que en la parte de
* parámetros no existe el tipo de parámetro que es
*/
JButton botonMetodoLambda = new JButton("Botón con método lambda");
botonMetodoLambda.addActionListener(e -> System.out
.println("Click Detected by Lambda Listner"));
}
}