Lambdauttrykk og funksjonelle grensesnitt i Java 8

Java 8 introduserer såkalte lambda-uttrykk som kan være svært nyttige i å forenkle kode og utføre funksjonell programmering i Java. For å kunne skjønne lambda-uttrykkrykk bør vi først nevne litt om funksjonelle grensesnitt.

Funksjonelle grensesnitt

Definisjonen av funksjonelle grensesnitt er veldig enkel: Det er nemlig grensesnitt som har kun én metode definert. La oss definere et eksempel på dette:

public interface Multiplier {
    public double multiply(double x, double y);
}

Grensesnittet over er et funksjonelt grensesnitt, for det har bare én metode, nemlig multiply.

Vi kan ta i bruk dette grensesnittet på den tradisjonelle måten ved å opprette en egen klasse som implementerer Multiplier, og deretter opprette en instans av denne klassen, som vi kaller multiply fra. Men dette blir utrolig tungvint for å bruke en så enkel metode som multiply. For å slippe dette lar Java oss definere et objekt som implementerer grensesnittet direkte, ved at man definerer metoden(e) til grensesnittet i initaliseringen av objektet (se venstre kolonne under). Merk at dette fungerer også for grensesnitt med flere metoder.

Denne direkte implementasjonen sparer oss mye kode, men det er fortsatt ganske tungvint. Lambda-uttrykk lar oss gjøre dette mye enklere. Høyre kolonne viser hvordan man kan gjøre nøyaktig det samme, på én linje.

Multiplier multiplier = new Multiplier() {
    @Override
    public double multiply(double x, double y) {
        return x * y;
    }
};

Multiplier multiplier = (x, y) -> x * y;

Lambda-uttrykk

Den direkte implementasjonen over er på seks linjer, men det er kun linje fire som er interessant: Hva er det multiply skal returnere? Resten av linjene er unødvendige, for vi vet dem fra før av – det samme står i definisjonen av grensesnittet. Vi vet at en implementasjon av Multiplier må ha en metode som heter multiply, den må være public, den må ta to doubles som argumenter, og returnere en double. Lambda-operatoren (->) lar oss forenkle dette. Til venstre for pila står argumentene, og til høyre for pila står hva som skal returneres. Merk at dette fungerer kun for funksjonelle grensesnitt, for ellers vil ikke lambda-operatoren vite hvilken metode som skal kalles.

Innebygde funksjonelle grensesnitt i Java 8

For å kunne utnytte kraften i lambda til det fulle, er de oftest brukte funksjonelle grensesnittene implementert i Java, så man slipper å definere dem selv. Vi skal snakke litt om grensesnittene Predicate og Consumer.

Predicate og Consumer

Predicate-grensesnittet har metoden test, som tar inn et objekt av hvilken som helst type som argument, og returnerer en boolean.

Consumer-grensesnittet har metoden accept, som tar inn et objekt av hvilken som helst type som argument, og returnerer ingenting (void).

Bruken av disse skal vi demonstrere senere.

Stream

Streams gjør det veldig enkelt for oss å utføre operasjoner på lister på en kort og elegant måte, i kombinasjon med lambda og ofte Predicate og Consumer. I stedet for å forklare hva streams er, skal vi heller vise eksempler på bruken av det. Vi definerer en Person-klasse for å ha noe å leke med:

public class Person {
    private String name = "Ola Nordmann";
    private int age = 10;
    private char gender = 'M';

    public Person(String name, int age, char gender) {
        setName(name);
        setAge(age);
        setGender(gender);
    }

    public String getName() { return name; }

    public void setName(String name) { this.name = name; }

    public int getAge() { return age; }

    public void setAge(int age) { this.age = age; }

    public char getGender() { return gender; }

    public void setGender(char gender) { this.gender = gender; }

    public String toString() { return name + " " + age + " " + gender; }
}

Vi oppretter også en PersonMain-klasse som skal inneholde en liste over Person-objekter, så vi kan demonstrere bruken av streams:

public class Main {

    List<Person> persons;

    public void init() {
        persons = new ArrayList<Person>();
		
		persons.add(new Person("Ola", 10, 'M'));
        persons.add(new Person("Kari", 12, 'F'));
        persons.add(new Person("Per", 22, 'M'));
        persons.add(new Person("Pål", 17, 'M'));
        persons.add(new Person("Espen", 19, 'M'));
    }

    public void run() {
    }

    public static void main(String[] args) {
        Main main = new Main();
		main.init();
        main.run();
    }

Eksemplene under vil være forskjellige implementasjoner av run()-metoden til PersonMain.java.