interfacce funzionali package java.util.function

[newutente]

Perché c'è molto "dietro" le lambda expression e method reference! E il compilatore effettua un bel po' di cose di nascosto.

Tieni presente che Java non è un linguaggio "funzionale". E non lo è ancora adesso, in senso stretto, nemmeno con Java 8. Nei linguaggi funzionali la "funzione" è un tipo di prima classe, che può essere passato, ritornato, assegnato alla stregua di altri tipi di dati.
In Java no, non è così, almeno per il momento. Per introdurre lambda expression/method reference nel linguaggio hanno dovuto fare delle scelte, importanti e sicuramente non banali, più che altro per allinearsi a quello che è il type-system attuale di Java, fatto solo di primitivi e classi/interfacce(/enum/annotazioni, e anche array) e basta. Per farlo hanno tirato fuori innanzitutto il concetto di "interfaccia funzionale".
Quando tu passi ad un metodo l'espressione TestCitta::getCitta, non stai passando (per ora, almeno in Java 8) un riferimento a getCitta! Sotto-sotto viene creato un oggetto che implementa la interfaccia indicata nel parametro, che deve avere il singolo metodo astratto che corrisponde, come forma, al tuo getCitta.

Grazie per la spiegazione.

Se vuoi andare molto a fondo in queste cose, allora es.:
- Maurice Naftalin's Lambda FAQ
- Java 8 Lambdas - A Peek Under the Hood
- Java 8: The First Taste of Lambdas

E questi comunque sono aspetti parecchio "avanzati" ....

sono aspetti un tantino avanzati e per il momento vorrei tralasciarli però grazie per i link.

In informatica (ma anche in logica matematica se non sbaglio) un "predicato" è una funzione che dato un valore X restituisce un booleano vero/falso. E l'uso più ovvio e naturale è per realizzare dei filtri al fine di accettare/rifiutare i valori.


Detto così, si ok è corretto.

Cerca anche di vedere la questione dell'inferenza dei tipi:

- il parametro è Predicate<Citta>
- Predicate ha un metodo astratto boolean test(T t) (questo è il metodo "funzionale")
- quindi la firma da implementare è boolean test(Citta)
- passi un "riferimento" (come descritto prima) ad un metodo public static boolean getCitta(Citta)

Come vedi (parti in rosso) la forma corrisponde, quindi per il compilatore è ok.
Il concetto vale per Predicate e per tutte le altre intefacce "funzionali".

Ah ecco, quindi è un discorso valido per tutte le interfacce funzionali. Per certi versi potrei seguire quindi questo "schema" per chiarirmi le idee non solo su Predicate.

Tornando all'esercizio devo stampare la lista delle città di mare. Questo è il codice:

public static void main(String args[]) {
...
        System.out.println("Lista città di mare:\n"+ getCittaFiltrate(listaCitta, TestCitta::mare) + "\n");
}    

public static List<Citta> getCittaFiltrate(List<Citta> listaCitta, Predicate<Citta> p) {
        final Iterator<Citta> i = listaCitta.iterator();
        while(i.hasNext()) {            
            Citta citta = i.next();
            if(!p.test(citta)) {
                i.remove();
            }
        }
        return listaCitta;
}
    
public static boolean mare(Citta citta) {
        return "true".equals(citta.isDiMare());
}

Il problema è che stampa sempre una lista vuota perchè anche nel momento in cui va a selezionare una città di mare (es. Bari e Venezia) non riconosce "true" ma "false" e quindi viene lanciato remove() che rimuove l'elemento selezionato dall'iteratore.
Non vorrei che sia un altro errore stupido che non riesco a correggere.