Tips de Listas & Lambdas en JAVA

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) );
    }
}