Lambdas und Streams

import java.util.*;
import java.util.function.*;

public class Lambdas {
    public static void main(String[] args) {
        Function<Integer, Integer> quadrat = x -> x * x;
        BiFunction<Integer, Integer, Integer> plus = (a, b) -> a + b;
        Predicate<String> leer = s -> s.isEmpty();
        Supplier<String> lieferant = () -> "Wert";
        Consumer<String> ausgabe = s -> System.out.println("> " + s);
        UnaryOperator<String> gross = String::toUpperCase;           // Methodenreferenz

        System.out.println(quadrat.apply(7) + " " + plus.apply(3, 4) + " " + leer.test("") + " " + lieferant.get());
        ausgabe.accept(gross.apply("hallo"));
        System.out.println(quadrat.andThen(x -> x + 1).apply(5));    // verketten
        System.out.println(leer.negate().test("x"));

        List<String> namen = new ArrayList<>(List.of("Zoe", "Anna", "Tom"));
        namen.sort((a, b) -> a.length() - b.length());
        namen.forEach(n -> System.out.print(n + " "));
        System.out.println();
    }
}

import java.util.*;
import java.util.stream.*;

public class Pipeline {
    record Person(String name, int alter, String stadt) {}

    public static void main(String[] args) {
        List<Person> leute = List.of(
            new Person("Mia", 17, "Köln"), new Person("Tom", 19, "Berlin"),
            new Person("Zoe", 21, "Köln"), new Person("Ben", 15, "Bonn"));

        List<String> volljaehrig = leute.stream()
            .filter(p -> p.alter() >= 18)
            .map(Person::name)
            .sorted()
            .collect(Collectors.toList());
        System.out.println(volljaehrig);

        double schnitt = leute.stream().mapToInt(Person::alter).average().orElse(0);
        System.out.println(schnitt + " " + leute.stream().mapToInt(Person::alter).max().getAsInt());

        System.out.println(leute.stream().anyMatch(p -> p.stadt().equals("Bonn")) + " " +
                           leute.stream().allMatch(p -> p.alter() > 16) + " " +
                           leute.stream().filter(p -> p.alter() > 100).findFirst().isPresent());
        System.out.println(IntStream.rangeClosed(1, 5).boxed().collect(Collectors.toList()));
        System.out.println(Stream.of("a", "b", "c").collect(Collectors.joining(", ", "[", "]")));
    }
}

import java.util.*;
import java.util.stream.*;

public class Gruppen {
    record Person(String name, int alter, String stadt) {}

    public static void main(String[] args) {
        List<Person> leute = List.of(
            new Person("Mia", 17, "Köln"), new Person("Tom", 19, "Berlin"),
            new Person("Zoe", 21, "Köln"), new Person("Ben", 15, "Bonn"));

        Map<String, List<String>> nachStadt = leute.stream()
            .collect(Collectors.groupingBy(Person::stadt, TreeMap::new, Collectors.mapping(Person::name, Collectors.toList())));
        System.out.println(nachStadt);

        Map<String, Long> anzahl = leute.stream().collect(Collectors.groupingBy(Person::stadt, TreeMap::new, Collectors.counting()));
        System.out.println(anzahl);

        Map<Boolean, List<String>> geteilt = leute.stream()
            .collect(Collectors.partitioningBy(p -> p.alter() >= 18, Collectors.mapping(Person::name, Collectors.toList())));
        System.out.println(geteilt);

        Map<String, Integer> alterMap = leute.stream().collect(Collectors.toMap(Person::name, Person::alter));
        System.out.println(new TreeMap<>(alterMap));

        IntSummaryStatistics st = leute.stream().mapToInt(Person::alter).summaryStatistics();
        System.out.println(st.getMin() + " " + st.getMax() + " " + st.getAverage() + " " + st.getSum());

        System.out.println(leute.stream().map(Person::alter).reduce(0, Integer::sum));
        System.out.println(leute.stream().sorted(Comparator.comparingInt(Person::alter).reversed()).map(Person::name).toList());
    }
}

import java.util.stream.*;

public class Faul {
    public static void main(String[] args) {
        var ergebnis = Stream.iterate(1, n -> n * 2)         // 1, 2, 4, 8, ... unendlich
            .peek(n -> System.out.print("[" + n + "]"))
            .filter(n -> n > 10)
            .limit(2)
            .toList();
        System.out.println();
        System.out.println(ergebnis);
        System.out.println(IntStream.range(0, 20).filter(n -> n % 3 == 0).sum());
    }
}