Expresión Java Lambda con colecciones

En este artículo, Lambda Expression with Collections se analiza con ejemplos de clasificación de diferentes colecciones como ArrayList , TreeSet , TreeMap , etc. Clasificación de colecciones con Comparator (o sin Lambda): Podemos usar la interfaz Comparator para ordenar, solo contiene un método abstracto: – comparar(). Una interfaz que solo contiene un único método abstracto se denomina interfaz funcional.

• Uso del Comparador (I): –
• Prototipo del método compare(): –

Al definir nuestra propia clasificación, JVM siempre llamará al método Comparator to compare().

• devuelve un valor negativo (-1), si y solo si obj1 tiene que venir antes que obj2.
• devuelve un valor positivo (+1), si y solo si obj1 tiene que venir después de obj2.
• devuelve cero (0), si y solo si obj1 y obj2 son iguales.

En List, Set, Map o en cualquier otro lugar cuando queramos definir nuestro propio método de clasificación, JVM siempre llamará al método compare() internamente. Cuando se usa el concepto de interfaz funcional, podemos usar Lambda Expression en su lugar. Clasificación de elementos de List(I) con Lambda

Expresión: – Usar la expresión lambda en lugar del objeto comparador para definir nuestra propia clasificación en las colecciones. 

import java.util.*;
 
public class Demo {
    public static void main(String[] args)
    {
        ArrayList<Integer> al = new ArrayList<Integer>();
        al.add(205);
        al.add(102);
        al.add(98);
        al.add(275);
        al.add(203);
        System.out.println("Elements of the ArrayList " +
                              "before sorting : " + al);
 
        // using lambda expression in place of comparator object
        Collections.sort(al, (o1, o2) -> (o1 > o2) ? -1 :
                                       (o1 < o2) ? 1 : 0);
 
        System.out.println("Elements of the ArrayList after" +
                                           " sorting : " + al);
    }
}

Clasificación de TreeSet usando la expresión Lambda:

import java.util.*;
 
public class Demo {
    public static void main(String[] args)
    {
        TreeSet<Integer> h =
                       new TreeSet<Integer>((o1, o2) -> (o1 > o2) ?
                                          -1 : (o1 < o2) ? 1 : 0);
        h.add(850);
        h.add(235);
        h.add(1080);
        h.add(15);
        h.add(5);
        System.out.println("Elements of the TreeSet after" +
                                        " sorting are: " + h);
    }
}

Clasificación de elementos de TreeMap mediante Lambda Expression: la clasificación se realizará en función de las claves y no de su valor. 

import java.util.*;
 
public class Demo {
    public static void main(String[] args)
    {
        TreeMap<Integer, String> m =
                   new TreeMap<Integer, String>((o1, o2) -> (o1 > o2) ?
                                               -1 : (o1 < o2) ? 1 : 0);
        m.put(1, "Apple");
        m.put(4, "Mango");
        m.put(5, "Orange");
        m.put(2, "Banana");
        m.put(3, "Grapes");
        System.out.println("Elements of the TreeMap " +
                             "after sorting are : " + m);
    }
}

También es posible especificar un comparador inverso a través de una expresión lambda directamente en la llamada al constructor TreeSet(), como se muestra aquí:

// Use a lambda expression to create a reverse comaprator
import java.util.*;
 
class GFG{
public static void main(String args[]){
  
  // Pass a reverse comparator to TreeSet() via a lambda expression
  TreeSet<String> ts=new TreeSet<String>((aStr,bStr) -> bStr.compareTo(aStr));
   
  // Add elements to the Treeset
  ts.add("A");
  ts.add("B");
  ts.add("C");
  ts.add("D");
  ts.add("E");
  ts.add("F");
  ts.add("G");
  
  //Display the elements .
  for(String element : ts)
    System.out.println(element + "");
   
  System.out.println();
}
}

G
F
E
D
C
B
A