Hva er lambdas og functional interfaces?

Question

Accepted Answer

**Lambdas** (Java 8+) er konsise anonyme funksjoner, og et **functional interface** er et grensesnitt med nøyaktig **én abstrakt metode** — måltypen som en lambda implementerer. Sammen brakte de funksjonell programmering til Java og gir kraft til Stream API. ## Hvorfor det betyr noe ```java @FunctionalInterface // optional annotation — enforces ONE abstract method interface Calculator { int calculate(int a, int b); // the single abstract method } ``` Et grensesnitt med én abstrakt metode er "funksjonelt" — en lambda kan implementere det fordi det ikke er noen tvetydighet om hvilken metode lambdaen representerer. ## Lambda-syntaks — implementer det konsist ```java // ❌ verbose anonymous class (pre-Java 8) Calculator add = new Calculator() { public int calculate(int a, int b) { return a + b; } }; // ✅ lambda — same thing, far less boilerplate Calculator add = (a, b) -> a + b; Calculator multiply = (a, b) -> a * b; add.calculate(2, 3); // 5 ``` Lambdaen `(a, b) -> a + b` gir implementeringen av den enkelte metoden — ingen klasse, ingen metodesignatur boilerplate. ## Innebygde functional interfaces (java.util.function) ```java Function length = s -> s.length(); // takes T, returns R Predicate isPositive = n -> n > 0; // takes T, returns boolean Consumer printer = s -> System.out.println(s); // takes T, returns void Supplier greeting = () -> "Hello"; // takes nothing, returns T BiFunction sum = (a, b) -> a + b; // two args ``` Java gir ferdiglagde functional interfaces for vanlige former, brukt gjennom standardbiblioteket (spesielt streams). ## Metodereferanser — enda kortere ```java // when a lambda just calls an existing method, use a method reference list.forEach(System.out::println); // instead of x -> System.out.println(x) list.stream().map(String::toUpperCase); // instead of s -> s.toUpperCase() list.stream().map(Integer::parseInt); // static method ref ``` ## Hvor lambdas skinner ```java // passing behavior as arguments — the core enabler of the Stream API people.stream() .filter(p -> p.getAge() > 18) // Predicate lambda .map(Person::getName) // method reference .forEach(System.out::println); // Consumer list.sort((a, b) -> a.compareTo(b)); // Comparator lambda button.addActionListener(e -> handleClick()); // event handler ``` ## Hvorfor det betyr noe Lambdas og functional interfaces brakte funksjonell programmering til Java og endret fundamentalt hvordan moderne Java skrives. De eliminerer den verbose boilerplate-en med anonyme klasser for å sende **oppførsel som data**, noe som gjør event handlers, komparatorer, callbacks konsise, og — viktigst — hele **Stream API**-en (som avhenger av lambdas for sine filter/map/reduce-operasjoner). Å forstå at en lambda målretter et functional interface (én abstrakt metode), de innebygde grensesnittene (Function, Predicate, Consumer, Supplier), og metodereferanser er essensielt for å skrive idiomatisk moderne Java og bruke streams, collections og concurrent APIs effektivt. De representerer en stor evolusjon av språket og er kjerne til nåværende Java-flythet.