Hva et funksjonelt grensesnitt er

Et funksjonelt grensesnitt er et grensesnitt med nøyaktig én abstrakt metode. Da kan et objekt av typen lages med et lambdauttrykk eller en metodereferanse i stedet for en hel klasse. Spørsmålet «er dette et funksjonelt grensesnitt? begrunn svaret» har dukket opp i 2015, 2016, 2016k, 2017 og 2018, og svaret skal alltid telle abstrakte metoder.

default- og static-metoder teller ikke med, for de har allerede en implementasjon.
Metoder som overstyrer noe fra Object (equals, hashCode, toString) teller heller ikke.
@FunctionalInterface er valgfritt, men får kompilatoren til å klage hvis du senere legger til en abstrakt metode nummer to.

@FunctionalInterface
public interface Krav {
    boolean oppfyller(Eksamen eksamen);     // eneste abstrakte metode

    default Krav og(Krav annet) {           // teller ikke med
        return eksamen -> this.oppfyller(eksamen) && annet.oppfyller(eksamen);
    }
}

Tre måter å lage samme objekt på

// 1. anonym klasse
Krav bestaatt = new Krav() {
    @Override
    public boolean oppfyller(Eksamen e) {
        return e.getKarakter() != 'F';
    }
};

// 2. lambdauttrykk
Krav bestaatt2 = e -> e.getKarakter() != 'F';

// 3. metodereferanse (naar metoden allerede finnes)
Krav bestaatt3 = Eksamen::erBestaatt;

Lambdasyntaksen har tre former: x -> uttrykk (returnerer uttrykket), (x, y) -> uttrykk og x -> { setninger; return ...; }. Parametertypene kan utelates fordi kompilatoren utleder dem fra grensesnittet. Metodereferanser finnes i fire varianter: Klasse::statiskMetode, objekt::instansmetode, Klasse::instansmetode (der første parameter blir mottakeren) og Klasse::new.

Standardgrensesnittene du må kunne

Predicate<T> — boolean test(T t). Brukes til filtrering. Har and, or, negate.
Function<T,R> — R apply(T t). Omformår en verdi til en annen.
Supplier<T> — T get(). Leverer en verdi uten argumenter; brukes bl.a. til å erstatte tilfeldighet i konstruktører.
Consumer<T> — void accept(T t). Gjør noe med en verdi uten å returnere.
Comparator<T> — int compare(T a, T b). Også funksjonelt, derfor kan sorteringsregler skrives som lambda.

Å ta imot et funksjonelt grensesnitt som parameter

Den klassiske eksamensoppgaven: skriv en metode som tar en samling og et predikat, og returnerer de elementene som tilfredsstiller predikatet — og vis hvordan den kalles.

public static Collection<Person> finnPersoner(Collection<Person> personer, Predicate<Person> krav) {
    Collection<Person> treff = new ArrayList<>();
    for (Person person : personer) {
        if (krav.test(person)) {
            treff.add(person);
        }
    }
    return treff;
}

// kall: alle myndige kvinner
Collection<Person> utvalg = finnPersoner(alle, p -> p.getAlder() >= 18 && p.getKjonn() == 'K');

Supplier som gjør en klasse testbar

En klasse som kaster terning med Math.random() er umulig å teste, fordi resultatet varierer. Løsningen er en ekstra konstruktør som tar en Supplier<Integer>: i produksjon sender du inn en tilfeldighetskilde, i testen sender du inn () -> 6 og vet nøyaktig hva som skjer.

public class Terning {
    private final Supplier<Integer> kilde;
    private int verdi;

    public Terning() {
        this(() -> 1 + (int) (Math.random() * 6));
    }

    public Terning(Supplier<Integer> kilde) {
        this.kilde = kilde;
    }

    public void kast() {
        this.verdi = kilde.get();
    }
}

Stream-teknikken

En Stream er en sekvens av verdier man kan kjede operasjoner på. Kjeden består av mellomoperasjoner (returnerer en ny strøm: filter, map, sorted, distinct, limit) og avsluttes med én terminaloperasjon (collect, count, sum, anyMatch, allMatch, findFirst, forEach). Ingenting skjer før terminaloperasjonen kjører.

// loekke
int sum = 0;
for (Ordre ordre : ordrer) {
    if (ordre.erBetalt()) {
        sum += ordre.getBeloep();
    }
}

// samme med stream
int sum = ordrer.stream()
                .filter(Ordre::erBetalt)
                .mapToInt(Ordre::getBeloep)
                .sum();

Merk mapToInt: map gir en Stream<Integer> som ikke har sum(), mens mapToInt gir en IntStream som har det. Skal du samle til en liste, avslutt med .collect(Collectors.toList()). Skal du bare vite om noe finnes, bruk anyMatch — den stopper ved første treff, mens filter(...).count() > 0 går gjennom alt.

Gjennomregnet eksempel

La ordrer inneholde beløpene 250 (betalt), 400 (ikke betalt), 150 (betalt) og 600 (betalt). Strømmen filtrerer bort 400, mapToInt gir \(250, 150, 600\), og sum() gir \(250 + 150 + 600 = 1000\). Med .average() i stedet ville du fått en OptionalDouble med verdien \(1000/3 \approx 333{,}33\) — Optional fordi strømmen kan være tom.

Studieguide: Funksjonelle grensesnitt og streams