Understanding Java 8 Functional Interfaces and Stream Operations

Java 8 introduced lambda expressions and functional programming concepts, allowing behavior to be passed as immutable values and processed through functions, which makes code more expressive and concise.

A functional interface is an interface with a single abstract method, marked with @FunctionalInterface . It can also contain default and static methods. Common built‑in functional interfaces include Predicate , Consumer , Function , Supplier , UnaryOperator , and BinaryOperator .

Example code illustrating these interfaces:

public class Test {
    public static void main(String[] args) {
        Predicate
predicate = x -> x > 185;
        Student student = new Student("9龙", 23, 175);
        System.out.println("9龙的身高高于185吗？：" + predicate.test(student.getStature()));

        Consumer
consumer = System.out::println;
        consumer.accept("命运由我不由天");

        Function
function = Student::getName;
        String name = function.apply(student);
        System.out.println(name);

        Supplier
supplier = () -> Integer.valueOf(BigDecimal.TEN.toString());
        System.out.println(supplier.get());

        UnaryOperator
unaryOperator = uglily -> !uglily;
        Boolean apply2 = unaryOperator.apply(true);
        System.out.println(apply2);

        BinaryOperator
operator = (x, y) -> x * y;
        Integer integer = operator.apply(2, 3);
        System.out.println(integer);

        test(() -> "我是一个演示的函数式接口");
    }

    public static void test(Worker worker) {
        String work = worker.work();
        System.out.println(work);
    }

    public interface Worker {
        String work();
    }
}

The Stream API processes collections lazily (operations return another Stream) and evaluates eagerly when a terminal operation is invoked. Common stream operations demonstrated include:

collect(Collectors.toList()) – converts a Stream to a List.

filter – selects elements matching a Predicate .

map – transforms each element using a Function .

flatMap – flattens multiple Streams into one.

max / min – finds the maximum or minimum element using a Comparator , returning an Optional .

count – counts elements, often after a filter .

reduce – aggregates elements into a single value.

Example of filter and map :

List
list = students.stream()
    .filter(stu -> stu.getStature() < 180)
    .collect(Collectors.toList());
System.out.println(list);

List
names = students.stream()
    .map(Student::getName)
    .collect(Collectors.toList());
System.out.println(names);

Advanced collectors such as partitioningBy , groupingBy , and joining enable complex data aggregation:

Map
> partitioned = students.stream()
    .collect(Collectors.partitioningBy(s -> s.getSpecialities().contains(SpecialityEnum.SING)));

Map
> grouped = students.stream()
    .collect(Collectors.groupingBy(s -> s.getSpecialities().get(0)));

String joined = students.stream()
    .map(Student::getName)
    .collect(Collectors.joining(",", "[", "]"));
System.out.println(joined);

The article concludes that Java 8 streams and lambda expressions provide a clear, concise way to manipulate collections, encouraging developers to refactor existing codebases to leverage functional programming features for better readability and maintainability.