Are there new arguments to use getters and setters since Java 8?

Question

As the title says, there has always been quite a discussion about getters and setters in any programming language, so also Java.

The question is the following: Are there any new arguments since Java 8 got released?

An example of an already existing argument is that getters and setters encapsulate state, or that they make it possible to change the implementation without changing the API.

Answer 1

Yes, there are! Since Java 8 method references were introduced, and as their name says, they can only be used with methods.

Consider the following code:

class Person {
    private String firstName;
    private String lastName;

    public Person(final String firstName, final String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    @Override
    public String toString() {
        return firstName + " " + lastName;
    }
}

Assume we want to obtain a map that contains a lists of people grouped by their last name, we can only do that via method references with the following code:

List<Person> personList = new ArrayList<>();
personList.add(new Person("Shannon", "Goldstein"));
personList.add(new Person("Donnie", "Denney"));
personList.add(new Person("Mark", "Thomas"));
personList.add(new Person("Julia", "Thomas"));
Map<String, List<Person>> personMapping = personList.stream()
        .collect(Collectors.groupingBy(Person::getLastName));
System.out.println("personMapping = " + personMapping);

Which prints out, formatted nicely:

personMapping = {
    Thomas=[Mark Thomas, Julia Thomas], 
    Goldstein=[Shannon Goldstein], 
    Denney=[Donnie Denney]
}

This would not have worked if we were using public variables, as you cannot obtain a method reference on them, nor reference them in another way other than writing a full-fledged lambda where it is not neccessary.
(For curious people: person -> person.lastName would need to have been used)

Also, keep in mind that this answer differs from someone claiming that if an object needs to adhere to a certain interface, that then getters and setters must be used. As in this example the Person class adheres to no interface, yet benefits from having getters available.