A. List people = ...; people.stream().sorted((p1, p2) -> p1.getAge() - p2.getAge()).collect(Collectors.toList()); Here's why this option is correct: List people = ...;: This assumes you have a List named people containing Person objects with an getAge method to access their age. .stream(): This converts the List to a Stream for processing elements. .sorted((p1, p2) -> p1.getAge() - p2.getAge()): This applies a sorting operation to the stream using the sorted method. The argument to sorted is a Comparator which defines the sorting logic. The provided lambda expression compares two Person objects (p1 and p2) based on their age. It subtracts the age of the second person (p2.getAge()) from the age of the first person (p1.getAge()). A negative result indicates p1 is younger, a positive result indicates p2 is younger, and 0 means they have the same age. This effectively sorts the stream in descending order of age. The other options have the following issues: B. sort(Comparator.comparing(Person::getAge)): This approach uses the sort method on the original List (not recommended for streams). However, Comparator.comparing(Person::getAge) is the correct way to define a comparator for sorting by age C. sorted(Person::getAge): This is similar to option (b) but uses the sorted method on the stream. However, Person::getAge alone doesn't specify ascending or descending order. You need a comparison logic like in option (a). D. people.sort((p1, p2) -> p2.getAge() - p1.getAge());: This approach sorts the original List directly using a lambda expression for comparison. While it works, using streams with sorted and a comparator is often considered more functional and potentially more readable for stream processing.