Interfacce Funzionali e Lambda Expressions

package corso.java;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Program {

    public static boolean ordinamentoCrescente(Integer a, Integer b) {
        return a > b;
    }

    public static boolean ordinamentoDecrescente(Integer a, Integer b) {
        return a > b;
    }

    interface MetodoUtente { // interfaccia funzionale
        boolean decidiSeScambiare(Integer a, Integer b);
    }

    public static class OrdinaCrescente implements MetodoUtente {

        @Override
        public boolean decidiSeScambiare(Integer a, Integer b) {
            return a > b;
        }

    }

    public static class OrdinaDecrescente implements MetodoUtente {

        @Override
        public boolean decidiSeScambiare(Integer a, Integer b) {
            return a < b;
        }

    }

    public static class OrdinaComeMiPareEPiace implements MetodoUtente {

        @Override
        public boolean decidiSeScambiare(Integer a, Integer b) {
            return a % 2 == 0 ? a > b : b > a;
        }

    }

    public static void sort(Integer[] a, MetodoUtente metodo) {
        for (int i = 0; i < a.length - 1; ++i) {
            for (int j = i + 1; j < a.length; ++j) {
                if (metodo.decidiSeScambiare(a[i], a[j])) {
                    int temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                }
            }
        }
    }

    public static void sortAsc(Integer[] a) {
        for (int i = 0; i < a.length - 1; ++i) {
            for (int j = i + 1; j < a.length; ++j) {
                if (a[i] > a[j]) { // if (decidiSeScambiare(a[i], a[j])
                    int temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                }
            }
        }
    }

    public static void sortDesc(Integer[] a) {
        for (int i = 0; i < a.length - 1; ++i) {
            for (int j = i + 1; j < a.length; ++j) {
                if (a[i] < a[j]) {
                    int temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                }
            }
        }
    }

    static void print(Integer[] a) {
        for (int i : a)
            System.out.println(i);
    }

    public static void main(String[] args) {
        Integer[] vettore = { 432, 867, 2134, 8657, 465, 2345, 978, 1234 };
        System.out.println("Array da ordinare:");
        print(vettore);
        sortAsc(vettore);
        System.out.println("Array ordinato:");
        print(vettore);
        sortDesc(vettore);
        System.out.println("Array ordinato in senso decrescente:");
        print(vettore);
        sort(vettore, new OrdinaComeMiPareEPiace());
        System.out.println("Array ordinato con sort + decidiSeScambiare:");
        print(vettore);
        System.out.println("Array ordinato con sort + interfaccia anonima:");
        sort(vettore, new MetodoUtente() { // implementazione anonima di interfaccia

            @Override
            public boolean decidiSeScambiare(Integer a, Integer b) {
                System.out.println("decido se scambiare " + a + " e " + b);
                return a > b / 2;
            }
        });
        print(vettore);
        System.out.println("Array ordinato con sort + espressione lambda semplice:");
        sort(vettore, (x, y) -> x > y / 2);
        print(vettore);
        int divisore = (args[0] != null) ? Integer.parseInt(args[0]) : 2;
        System.out.println("Array ordinato con sort + espressione lambda complessa:");
        sort(vettore, (x, y) -> {
            System.out.println("decido se scambiare " + x + " e " + y);
            return x > y / divisore;
        });
        print(vettore);
        System.out.println("Lavoriamo con le collections:");
        List<Integer> li = new ArrayList<>(Arrays.asList(vettore));
        List<Integer> r = pari(li);
        System.out.println("Lista filtrata con funzione:");
        for (Integer i : r)
            System.out.println(i);
        System.out.println("Filtro e mapping con lambda e stream:");
        Stream<Integer> si = li.stream().filter(item -> item % 2 != 0).map(elemento -> elemento * 2).skip(2).limit(2);
        li.add(2000);
        li.add(5432);
        for (Integer i : si.collect(Collectors.toList())) {
            System.out.println(i);
        }
        for (MyClass i : li.stream().map(item -> new MyClass(item)).collect(Collectors.toList()))
            System.out.println(i.valore);
    }

    static class MyClass {
        public int valore;

        public MyClass(int i) {
            this.valore = i;
        }
    }

    public static List<Integer> pari(List<Integer> origine) {
        List<Integer> risultato = new ArrayList<>();
        for (Integer i : origine)
            if (i % 2 == 0)
                risultato.add(i);
        return risultato;
    }
}