Java 8 Features

import java.util.function.*;

public class FunctionalDemo {
    public static void main(String[] args) {
        Predicate<Integer> isEven = n -> n % 2 == 0;
        Function<String, Integer> length = s -> s.length();
        Supplier<String> greeting = () -> "Hello, Java 8";
        Consumer<String> printer = s -> System.out.println("Consumed: " + s);
        BinaryOperator<Integer> add = (a, b) -> a + b;

        System.out.println("isEven(10)      = " + isEven.test(10));
        System.out.println("length(\"Kafka\") = " + length.apply("Kafka"));
        System.out.println("greeting.get()  = " + greeting.get());
        printer.accept("Spring Boot");
        System.out.println("add(4, 5)       = " + add.apply(4, 5));
    }
}

isEven(10)      = true
length("Kafka") = 5
greeting.get()  = Hello, Java 8
Consumed: Spring Boot
add(4, 5)       = 9

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

public class StreamDemo {
    static class Employee {
        private final String name, dept;
        private final double salary;
        Employee(String name, String dept, double salary) {
            this.name = name;
            this.dept = dept;
            this.salary = salary;
        }
        String getName() { return name; }
        String getDept() { return dept; }
        double getSalary() { return salary; }
    }

    public static void main(String[] args) {
        List<Employee> staff = Arrays.asList(
                new Employee("Asha", "Backend", 120000),
                new Employee("Ravi", "Frontend", 95000),
                new Employee("Meera", "Backend", 135000),
                new Employee("Kiran", "Data", 110000));

        List<String> highEarners = staff.stream()
                .filter(e -> e.getSalary() > 100000)
                .map(Employee::getName)
                .sorted()
                .collect(Collectors.toList());
        System.out.println("Salary > 1,00,000: " + highEarners);

        Map<String, Long> perDept = staff.stream()
                .collect(Collectors.groupingBy(Employee::getDept,
                        TreeMap::new, Collectors.counting()));
        System.out.println("Count per dept:    " + perDept);

        double avg = staff.stream()
                .mapToDouble(Employee::getSalary)
                .average().orElse(0);
        System.out.printf("Average salary:    %.2f%n", avg);

        int sumOfSquares = IntStream.rangeClosed(1, 5).map(n -> n * n).sum();
        System.out.println("Sum of squares 1..5: " + sumOfSquares);
    }
}

Salary > 1,00,000: [Asha, Kiran, Meera]
Count per dept:    {Backend=2, Data=1, Frontend=1}
Average salary:    115000.00
Sum of squares 1..5: 55

public class DefaultMethodDemo {
    interface Vehicle {
        String name();
        // default method: inherited by every implementation
        default String describe() { return name() + " is a vehicle"; }
        // static method: called on the interface name
        static Vehicle of(String name) { return () -> name; }
    }

    static class Bike implements Vehicle {
        public String name() { return "Bike"; }
        @Override public String describe() { return "Bike has two wheels"; }
    }

    public static void main(String[] args) {
        System.out.println(Vehicle.of("Car").describe()); // inherited
        System.out.println(new Bike().describe());        // overridden
    }
}

Car is a vehicle
Bike has two wheels

import java.util.*;
import java.util.concurrent.CompletableFuture;

public class MoreFeaturesDemo {
    public static void main(String[] args) {
        // String.join and StringJoiner
        System.out.println(String.join(" | ", "Java", "Spring", "Kafka"));
        StringJoiner sj = new StringJoiner(", ", "[", "]");
        sj.add("lambda").add("stream");
        System.out.println(sj);

        // New collection methods: forEach, removeIf, Map.merge, getOrDefault
        List<Integer> nums = new ArrayList<>(Arrays.asList(5, 12, 7, 20, 3));
        nums.removeIf(n -> n < 6);
        System.out.println("removeIf(<6): " + nums);
        Map<String, Integer> count = new TreeMap<>();
        for (String w : "to be or not to be".split(" ")) {
            count.merge(w, 1, Integer::sum);
        }
        System.out.println("merge counts: " + count);
        System.out.println("getOrDefault: " + count.getOrDefault("java", 0));

        // Base64
        String encoded =
                Base64.getEncoder().encodeToString("JavaByTechie".getBytes());
        String decoded = new String(Base64.getDecoder().decode(encoded));
        System.out.println("Base64: " + encoded + " -> " + decoded);

        // CompletableFuture
        String result = CompletableFuture.supplyAsync(() -> 21)
                .thenApply(n -> n * 2)
                .thenApply(n -> "Answer = " + n)
                .join();
        System.out.println(result);
    }
}

Java | Spring | Kafka
[lambda, stream]
removeIf(<6): [12, 7, 20]
merge counts: {be=2, not=1, or=1, to=2}
getOrDefault: 0
Base64: SmF2YUJ5VGVjaGll -> JavaByTechie
Answer = 42