Lambda Quick Start

Buenos días, dejamos un código explicativo sobre Lambda, nueva característica de Java 8.

view source

print?

001.package lambda;

002. 

003.import java.awt.event.ActionEvent;

004.import java.awt.event.ActionListener;

005.import java.util.ArrayList;

006.import java.util.Collections;

007.import java.util.Comparator;

008.import java.util.List;

009.import javax.swing.JButton;

010. 

011./**

012. * Clase que utilizaremos en la parte de métodos de comparación con Lambda

013. *

014. * @author jaimecl

015. *

016. */

017.public class Persona {

018. 

019.    private String surName;

020. 

021.    public Persona(String surName) {

022.        super();

023.        this.surName = surName;

024.    }

025. 

026.    public String getSurName() {

027.        return surName;

028.    }

029. 

030.    public void setSurName(String surName) {

031.        this.surName = surName;

032.    }

033. 

034.    /* Método de impresión de valores */

035.    public void printName() {

036.        System.out.println("surName=" + surName + "]");

037.    }

038. 

039.    /* Método que creará una lista corta de Personas, a modo de datos de ejemplo */

040.    private static List<persona> createShortList() {

041.        ArrayList<persona> lista = new ArrayList<persona>();

042.        lista.add(new Persona("Carmona"));

043.        lista.add(new Persona("Pérez"));

044.        return lista;

045. 

046.    }

047. 

048.    /**

049.     * Método principal

050.     *

051.     * @param args

052.     */

053.    public static void main(String args) {

054. 

055.        /*

056.         * Empezamos con clases anónimas: utilizadas en un sólo punto del código

057.         * No hay necesidad de tener que definir una clase única que sea

058.         * referenciada sólo una vez

059.         */

060.        JButton testButton = new JButton("Test Button");

061.        testButton.addActionListener(new ActionListener() {

062.            public void actionPerformed(ActionEvent ae) {

063.                System.out.println("Click Detected by Anon Class");

064.            }

065.        });

066. 

067.        /*

068.         * Java8 define como interfaz funcional aquella clase que define un sólo

069.         * método. Las expresiones Lambda pueden ser aplicadas sobre dichas

070.         * interfaces La sintaxis es la siguiente argumento -> cuerpo. (int x,

071.         * int y) -> x + y

072.         *

073.         * () -> 42

074.         *

075.         * (String s) -> { System.out.println(s); }

076.         */

077. 

078.        /* A continuación, vemos cómo definir Lambda Runnable */

079. 

080.        /* Manera antigua, con una clase anónima */

081.        new Runnable() {

082.            @Override

083.            public void run() {

084.                System.out.println("JavaHispaneros, ¡manera anónima!");

085.            }

086.        }.run();

087. 

088.        // Con Lambda, la interfaz runnable tiene un sólo método, por lo tanto,

089.        // podemos redefinirlo de la siguiente manera.

090.        Runnable r2 = () -> System.out

091.                .println("JavaHispaneros, ¡esto es Lambda!");

092. 

093.        /* A continuación, vemos un ejemplo de ordenación de listas */

094.        List<persona> personList = Persona.createShortList();

095. 

096.        /*

097.         * Ordenación con clases anónimas. Dentro del método sort, que espera

098.         * una interfaz de tipo Comparator, hacemos una redefinición

099.         */

100. 

101.        Collections.sort(personList, new Comparator<persona>() {

102.            public int compare(Persona p1, Persona p2) {

103.                return p1.getSurName().compareTo(p2.getSurName());

104.            }

105.        });

106. 

107.        // Ordenación ascendente, en este caso, haciendo uso de expresiones

108.        // lambda

109. 

110.        /*

111.         * El método sort de Collections espera un único método, con dos

112.         * parámetros. Por lo tanto, utilizamos la sintaxis lambda para definir

113.         * el método de comparación

114.         */

115.        Collections.sort(personList, (Persona p1, Persona p2) -> p1

116.                .getSurName().compareTo(p2.getSurName()));

117. 

118.        // Mismo caso, ejerciendo la ordenación descendente.

119.        Collections.sort(personList,

120.                (p1, p2) -> p2.getSurName().compareTo(p1.getSurName()));

121. 

122.        /* Otro caso para listeners */

123.        JButton botonMetodoAnonimo = new JButton("Botón con método anónimo");

124.        botonMetodoAnonimo.addActionListener(new ActionListener() {

125.            @Override

126.            public void actionPerformed(ActionEvent ae) {

127.                System.out.println("Click detectado por clase anónima");

128.            }

129.        });

130. 

131.        /*

132.         * De nuevo, vemos que addActionListener acepta una clase que implemente

133.         * la interfaz listener, que define un método único, por lo tanto,

134.         * acepta expresiones lambda Recordamos la sintaxis: nombre de variable

135.         * en parámetro -> acción a realizar Choca ver que en la parte de

136.         * parámetros no existe el tipo de parámetro que es

137.         */

138. 

139.        JButton botonMetodoLambda = new JButton("Botón con método lambda");

140.        botonMetodoLambda.addActionListener(e -> System.out

141.                .println("Click Detected by Lambda Listner"));

142. 

143.    }

144.}

145. 

146. 

147.</persona></persona></persona></persona></persona>