blog - Java 8 Stream API - reduce operator

Person.java

package rs.dodalovic.streams.reduce;

class Person {
    private String name;
    private Gender gender;
    private Integer age;

    public Person(String name, Gender gender, Integer age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }

    static enum Gender {
        MALE, FEMALE;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Gender getGender() {
        return gender;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", gender=" + gender +
                '}';
    }
}

ReduceDemo.java

package rs.dodalovic.streams.reduce;

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

public class ReduceDemo {
    public static void main(String[] args) {

        final List<Person> persons = Arrays.asList(
                new Person("Jeanny", Person.Gender.FEMALE, 22),
                new Person("Jim", Person.Gender.MALE, 25),
                new Person("Alicia", Person.Gender.FEMALE, 32),
                new Person("Jennifer", Person.Gender.FEMALE, 38),
                new Person("Anastasia", Person.Gender.FEMALE, 19),
                new Person("John", Person.Gender.MALE, 22),
                new Person("Jimmy", Person.Gender.MALE, 38),
                new Person("Michael", Person.Gender.MALE, 15)
        );
        printFemaleWithLongestName(persons);
        printLongestFemaleNameOnly(persons);
        printYoungestMaleAge(persons);
        printYoungestMaleAgeUsingMin(persons);
    }

    private static void printFemaleWithLongestName(List<Person> persons) {
        final Optional<Person> personWithLongestName = persons.stream()
                .filter(onlyGender(Person.Gender.FEMALE))
                .reduce((person, person2) -> person.getName().length() > person2.getName().length() ? person : person2);
        personWithLongestName.ifPresent(person -> System.out.printf("Person with longest female name %s%n",
                personWithLongestName));
    }

    private static void printLongestFemaleNameOnly(List<Person> persons) {
        persons.stream()
                .filter(onlyGender(Person.Gender.FEMALE))
                .map(Person::getName)
                .reduce((person1Name, person2Name) -> person1Name.length() > person2Name.length() ? person1Name :
                        person2Name)
                .ifPresent(longestName -> System.out.printf("Longest female name: %s%n", longestName));
    }

    private static void printYoungestMaleAge(List<Person> persons) {
        final Integer youngestMaleAge = persons.stream()
                .filter(onlyGender(Person.Gender.MALE))
                .map(Person::getAge)
                .reduce(Integer.MAX_VALUE, (age1, age2) -> age1 < age2 ? age1 : age2);
        System.out.printf("Youngest male age: %d%n", youngestMaleAge);
    }

    private static void printYoungestMaleAgeUsingMin(List<Person> persons) {
        final OptionalInt youngest = persons.stream()
                .filter(onlyGender(Person.Gender.MALE))
                .mapToInt(Person::getAge)
                .min();
        youngest.ifPresent(value -> System.out.printf("Youngest male age: %d", value));
    }

    private static Predicate<Person> onlyGender(Person.Gender gender) {
        return person -> person.getGender() == gender;
    }
}