Steam流式计算的一道题，求大神帮忙解答。

Question

/**
 * 题目要求：一分钟内完成此题，只能用一行代码实现
 * 现在有五个用用户！筛选：
 * 1、ID必须为偶数
 * 2、年龄必须大于23岁
 * 3、用户名转化为大写
 * 4、用户名字母倒着排序
 * 5、只输出一个用户
 */
public class Test1 {
    public static void main(String[] args) {
        User u1 = new User(1, "aa", 21);
        User u2 = new User(2, "bb", 22);
        User u3 = new User(3, "cc", 23);
        User u4 = new User(4, "dd", 24);
        User u5 = new User(6, "ee", 25);
        //集合就是管存储
        List<User> list = Arrays.asList(u1, u2, u3, u4, u5);
 
        list.stream()
                .filter(u->{return u.getId()%2==0;})
                .filter(u->{return u.getAge()>23;})
                .map(u->{return u.getName().toUpperCase();})
                .sorted((uu1,uu2)->{return uu2.compareTo(uu1);})
                .limit(1)
                .forEach(System.out::println);
 
    }
}

上面是Staam计算的链式编程过程，我进行了分解，到了sorted这边是在没有思路了

public class Test {
    public static void main(String[] args) {
        User u1 = new User(1, "aa", 21);
        User u2 = new User(2, "bb", 22);
        User u3 = new User(3, "cc", 23);
        User u4 = new User(4, "dd", 24);
        User u5 = new User(6, "ee", 25);
 
        //集合就是管存储
        List<User> list = Arrays.asList(u1, u2, u3, u4, u5);
 
        //Stream流计算
        //1、第一步先把集合变为流,变成Stream类型
        Stream<User> stream = list.stream();
 
 
        //2、filter（）方法：把ID为偶数的对象挑出来
        Predicate<User> predicate1 = new Predicate<User>() {
            public boolean test(User u) {
                if (u.getId() % 2 == 0) {
                    return true;
                }else {
                    return false;
                }
            }
        };
        Stream<User> stream1 = stream.filter(predicate1);//filter方法只输入判断为true的对象
 
 
        //3、filter（）方法：把年龄大于23岁挑出来
        Predicate<User> predicate2 = new Predicate<User>() {
            public boolean test(User u) {
                if (u.getAge()>23) {
                    return true;
                }else {
                    return false;
                }
            }
        };
        Stream<User> stream2 = stream1.filter(predicate2);//filter方法只输入判断为true的对象
 
 
        //4、map（）方法：获取用户名
        //toUpperCase()方法：把字符串改为大写
        Function function1 = new Function<User,String>() {//写好泛型
            public String apply(User user) {
                String name=user.getName().toUpperCase();//把用户名改为大写
                return name;
            }
        };
        Stream stream3 = stream2.map(function1);
 
 
 
          就是这边，cmpareTo()方法被重写了，没有思路去分解出来
        //5、sorted()方法：把用户名倒着排序
        Comparable<Stream> comparable = new Comparable<Stream>() {
            @Override
            public int compareTo(Stream o) {
                return 0;
            }
        };
    }
}

Answer 1

 Collections.sort(list, new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                return  o1.getName() > o2.getName() ? 1 : (o1.getName() == o2.getName() ? 0 : -1);
            }
        });

用这种把。