Lambda Expressions

[misterx]

Hi,
kann mir jemand erklären was ein Lambda Ausdruck ist?

Für was brauch ich dem im Haushalt?

Gruß
X

 

[njans]

Eine Lambda expression ist ein Ausdruck der Form : (parameter) -> {behaviour}
Die sind Teil von Java 8 und werden dort für functional Interfaces und einige andere nette Dinge verwendet.

 

[DrZoidberg]

Sieh dir mal dieses Beispiel an

Random rand = new Random();
IntStream nums = rand.ints(10, 0, 100);
nums.filter(x -> x%2 == 0).map(x -> x*2).forEach(System.out::println);

Hier wird erstmal ein Stream erzeugt und mit 10 Zufallszahlen zwischen 0 und 100 gefüllt.
Ein Stream ist so ählich wie eine Liste, kann allerdings unendlich lang sein und besitzt Methoden für funktionale Programmierung.
Die Zahlen werden dann gefiltert, so dass nur noch gerade Zahlen im Stream vorhanden sind. Danach werden dann alle verbliebenen Zahlen per map verdoppelt und zum Schluss ausgegeben.
Mit :: gibt man eine Methodenreferenz an. Man kann sagen :: wandelt eine Methode in ein Objekt um, das dann einer anderen Methode übergeben werden kann.

x -> x%2 == 0 und
x -> x*2
sind Lambda Ausdrücke.

Das Ganze ist im Grunde nur eine Kurzschreibweise für diesen Code

nums.filter(
    new IntPredicate() {
        public boolean test(int x) {
            return x%2 == 0;
        }
    }).map(
    new IntUnaryOperator() {
        public int applyAsInt(int x) {
            return x*2;
        }
    }).forEach(
    new IntConsumer() {
        public void accept(int x) {
            System.out.println(x);
        }
    });

IntPredicate, IntUnaryOperator und IntConsumer sind alles funktionale Interfaces, das heisst sie unterstützen eine automatische Umwandlung von Lamda Ausdrücken und Methoden Referenzen in Objekte dieses Typs.

Auch sehr interessant ist die automatische Parallelisierung von Stream Operationen.
z.B.

public class Test {
    private static int fib(int n) {
        if(n < 2) return n;
        else return fib(n-1) + fib(n-2);
    }

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(38,39,40,41,42,43,44,45);

        long start = System.nanoTime();
        list.stream().parallel().map(Test::fib).forEach(System.out::println);
        long end = System.nanoTime();
        double time = (end-start)/1e9;
        System.out.println("time = " + time);
    }
}

Da die fibonacci Methode in diesem Beispiel sehr ineffizient geschrieben ist, läuft der Code langsam, aber durch Aufrufen der parallel Methode wird die Berechnung automatisch auf alle CPU Kerne verteilt.

 

[Flown]

Eine Kleinigkeit zum anmerken:

list.stream().parallel().map(Test::fib).forEach(System.out:rintln);

Den parallelen Stream kann man einfacher haben. Garantiert ist die Reihenfolge nur, wenn man forEachOrdered aufruft.

list.parallelStream().map(Test::fib).forEachOrdered(System.out::println);