Unos pequeños TIPS de Listas & Lambdas en JAVA. Es común en el día a día manejar listas y muchas veces es necesario ordenarlas, obtener elementos duplicados, etc.
Por ello aquí pondremos algunos ejemplos y TIPS de Listas & Lambdas en JAVA.
Aquí dejo incluso para mí :)) un conjunto de scripts que son muy útiles a la hora de trabajar con ellas.
public class Main {
public static void main(String[] args) {
// defino una lista
List listNames = new ArrayList<>();
listNames.add("juan");
listNames.add("andres");
listNames.add("marcelo");
listNames.add("martin");
System.out.println("Lista original:");
showList(listNames);
System.out.println("Lista ordenada:");
Collections.sort(listNames);
showList(listNames);
}
private static void showList(List listNames) {
int size = listNames.size();
for(int i=0; i<size; i++){
System.out.println(listNames.get(i));
}
}
}
Ya que algunos tips de programación de JAVA no sobra repasar un poco concpetos básicos sobre la Programación Funcional.
Ventajas | Inconvenientes |
---|---|
Los programas no tienen estados | Los datos (por ejemplo, las variables) no se pueden modificar |
Muy adecuados para la paralelización | No se permite el acceso eficiente a grandes cantidades de datos |
El código se puede testar fácilmente | No se recomienda para conexiones a bases de datos y servidores |
Código fácilmente verificable, incluso las funciones sin estado se pueden verificar | No es adecuado para muchas recursiones de la misma pila |
Fácil de combinar con la programación imperativa y orientada a objetos | La programación recurrente puede dar lugar a errores graves |
Código más preciso y más corto | No apto para todas las tareas |
Veamos entonces las primeras diferencias que nos proporcionan el uso de lambdas.
En primer lugar mostraremos como listar los elementos de una lista como lo haríamos siempre, y luego utilizando lambdas.
public class Main {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("B");
arrayList.add("A");
arrayList.add("D");
arrayList.add("C");
//Mostrando todos los elementos de un Array mediante a la solución clásica
System.out.println("Mostrando todos los elementos de un Array mediante a la solución clásica:");
System.out.print("Opción 1:\t");
// Opción 1:
for(int i=0; i< arrayList.size(); i++){
System.out.print(arrayList.get(i));
}
// Opción 2:
System.out.print("\nOpción 2:\t");
for (String item : arrayList) {
System.out.print(item);
}
}
}

Ahora veamos como quedaría esta misma salida pero con el uso de lambdas.
ArrayList<String> arrayList2 = new ArrayList<String>();
arrayList2.add("B");
arrayList2.add("A");
arrayList2.add("D");
arrayList2.add("C");
System.out.println("Mostrando todos los elementos de un array con Lambda:");
System.out.print("\t");
// Mostrando todos los elementos de un Array con Lambda
arrayList2.forEach(n -> System.out.print(n + " "));

Mostrando los elementos de un Array ordenados sin Lambda (a la antigua usanza)
System.out.println("Mostrando todos los elementos de un Array ordenado mediante a la solución clásica:");
System.out.print("\tOpción 1:\t");
// Mostrando todos los elementos de un Array
// Opción 1:
String temp = "";
for (int i = 0; i < arrayList3.size(); i++) {
for (int j = i + 1; j < arrayList.size(); j++) {
if (arrayList3.get(i).compareTo(arrayList3.get(j)) > 0) {
temp = arrayList.get(i);
arrayList3.set(i, arrayList.get(j));
arrayList3.set(j, temp);
}
}
System.out.print(arrayList3.get(i));
}
// Opción 2:
System.out.print("\n\tOpción 2:\t");
Collections.sort(arrayList3);
for (int i = 0; i < arrayList3.size(); i++) {
System.out.print(arrayList3.get(i));
}
// Opción 3:
System.out.print("\n\tOpción 3:\t");
Collections.sort(arrayList3);
for (String item : arrayList3) {
System.out.print(item);
}
}
En este caso mostraremos lo mismo pero utilizando lambdas.
System.out.println("Mostrando todos los elementos de un Array ordenado mediante a la solución clásica:");
System.out.print("\tOpción 1:\t");
// Mostrando todos los elementos de un Array
// Opción 1:
String temp = "";
for (int i = 0; i < arrayList3.size(); i++) {
for (int j = i + 1; j < arrayList.size(); j++) {
if (arrayList3.get(i).compareTo(arrayList3.get(j)) > 0) {
temp = arrayList.get(i);
arrayList3.set(i, arrayList.get(j));
arrayList3.set(j, temp);
}
}
System.out.print(arrayList3.get(i));
}
// Opción 2:
System.out.print("\n\tOpción 2:\t");
Collections.sort(arrayList3);
for (int i = 0; i < arrayList3.size(); i++) {
System.out.print(arrayList3.get(i));
}
// Opción 3:
System.out.print("\n\tOpción 3:\t");
Collections.sort(arrayList3);
for (String item : arrayList3) {
System.out.print(item);
}
}
En este ejemplo vamos a agregar una interfaz en la clase, con un solo método. Vamos al código :
public class Main {
public interface Calc {
int suma(int a, int b);
}
public static void main(String[] args) {
Calc calc = (a,b) -> {return a+b;};
System.out.println("total : " + calc.suma(1,3) );
}
}