Lambdas og Streams

Dag 1

Disse øvelser introducerer lambdas i Java trin for trin – fra det helt grundlæggende til praktiske brug med Streams-API og funktionelle interfaces.

1. Basic Lambda Syntax

Exercise 1: Write Your First Lambda

Omskriv følgende kode til at bruge en lambda ved at erstatte den anonyme klasse:

import java.util.function.Supplier;

Supplier<String> greeter = new Supplier<>() {
    @Override
    public String get() {
        return "Hello, world!";
    }
};

System.out.println(greeter.get());

Mål: Erstat den anonyme klasse med en lambda.
Hint: Brug den eksisterende Supplier<String>-interface og kald get() for at hente teksten.

Exercise 2: Lambda with Parameters

Skriv en lambda, der tager en streng som input og printer den med store bogstaver. Brug dette funktionelle interface:

@FunctionalInterface
interface Printer {
    void print(String message);
}

public class Main {
    public static void main(String[] args) {
        Printer printer = ...; // Write the lambda here
        printer.print("hello");
    }
}

Mål: Udskift ... med en lambda, der konverterer og printer input i uppercase.

2. Functional Interfaces

Exercise 3: Using `Consumer`

Brug det funktionelle interface Consumer<T> til at lave en lambda, der printer hvert element i en liste:

import java.util.function.Consumer;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

        Consumer<String> printer = ...; // Write the lambda here

        names.forEach(printer);
    }
}

Mål: Udskift ... med en lambda, der printer hvert navn.

Exercise 4: Using `Function`

Brug Function<T, R> til at lave en lambda, der fordobler et heltal:

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<Integer, Integer> doubler = ...; // Write the lambda here

        System.out.println(doubler.apply(5)); // Should print 10
    }
}

Mål: Udskift ... med en lambda, der fordobler input.

Exercise 5: Using `Predicate`

Brug Predicate<T> til at filtrere en liste af tal:

import java.util.function.Predicate;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

        Predicate<Integer> isEven = ...; // Write the lambda here

        numbers.stream()
               .filter(isEven)
               .forEach(System.out::println); // Should print 2, 4, 6
    }
}

Mål: Udskift ... med en lambda, der tjekker om et tal er lige.

3. Lambdas in Practice

Exercise 6: Sorting with Lambdas

Sorter en liste af strenge efter længde med en lambda:

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "kiwi", "cherry");

        // Skriv lambdaen i sort-metoden
        words.sort(java.util.Comparator.comparingInt(String::length));

        System.out.println(words); // Should print [kiwi, apple, banana, cherry]
    }
}

Mål: Brug en lambda/Comparator der sorterer efter længde.
Hint: Comparator.comparingInt(String::length) er en kort standardløsning.

Hints for sorting with lambdas

Exercise 7: Map and Transform

Brug map med en lambda til at omdanne en liste af heltal til deres kvadrater:

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        List<Integer> squares = numbers.stream()
                                       .map(n -> n * n) // lambdaen her
                                       .collect(Collectors.toList());

        System.out.println(squares); // Should print [1, 4, 9, 16, 25]
    }
}

Mål: Anvend en lambda der beregner kvadratet af hvert tal (n -> n * n).

Hint: map

Exercise 8: Combine `filter` and `map`

Filtrér alle lige tal fra en liste og fordobl dem med lambdas:

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

        List<Integer> result = numbers.stream()
                                      .filter(n -> n % 2 == 0) // filtrér lige
                                      .map(n -> n * 2)         // fordobl
                                      .collect(Collectors.toList());

        System.out.println(result); // Should print [4, 8, 12]
    }
}

Hint: filter

Mål: Forstå syntaksen for filter og map; her er de færdige lamdaer som model.

4. Advanced Exercises

Exercise 9: Custom Functional Interface

Lav et eget funktionelt interface til at beregne arealet af et rektangel:

@FunctionalInterface
interface AreaCalculator {
    int calculate(int length, int width);
}

public class Main {
    public static void main(String[] args) {
        AreaCalculator calculator = ...; // Write the lambda here

        System.out.println(calculator.calculate(5, 3)); // Should print 15
    }
}

Mål: Udskift ... med en lambda der beregner length * width.

Exercise 10: Chain Functions

Kæd to funktioner med andThen: først fordoble et tal, derefter lægge 5 til:

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<Integer, Integer> doubler = n -> n * 2; // fordobler
        Function<Integer, Integer> addFive = n -> n + 5; // lægger 5 til

        Function<Integer, Integer> combined = doubler.andThen(addFive);

        System.out.println(combined.apply(10)); // Should print 25
    }
}

Mål: Forstå chaining: definér lambdas og kombiner dem med andThen.