显示有限流中所有最长的单词

Question

我必须使用Streams API从给定文件中查找所有最长的单词。我只做了几步，但寻找一些“一行”，实际上我处理整个文件两次，第一次是找到单词的最大长度，第二次是比较所有单词和最大长度，假设它不是性能最好的；有人能帮我吗？看看代码：

public class Test {
    public static void main(String[] args) throws IOException {
        List<String> words = Files.readAllLines(Paths.get("alice.txt"));
        OptionalInt longestWordLength = words.stream().mapToInt(String::length).max();
        Map<Integer, List<String>> groupedByLength = words.stream().collect(Collectors.groupingBy(String::length));
        List<String> result = groupedByLength.get(longestWordLength.getAsInt());
    }
}

我想澄清一下：

List<String> words = Files.readAllLines(Paths.get("alice.txt"));
List<String> result = // code

文件每行只包含一个单词，无论如何这并不重要——问题是关于正确的流代码。

Answer 1

迭代映射键以查找最长的字长

Answer 2

减少将帮助您：

    Optional<String> longest = words.stream()
            .reduce((s1, s2) -> {
                if (s1.length() > s2.length())
                    return s1;
                else
                    return s2;
            });

如果流为空，它将返回一个可选值。空的

如果你想要最大长度的所有单词的列表，这篇文章将帮助你：

    Optional<List<String>> longest = words.stream()
            .collect(Collectors.groupingBy(
                    String::length,
                    Collectors.toList()
            ))
            .entrySet()
            .stream()
            .reduce(
                    (entry1, entry2) -> {
                        if (entry1.getKey() > entry2.getKey())
                            return entry1;
                        else
                            return entry2;
                    }
            )
            .map(Map.Entry::getValue);

Answer 3

你可以将单词从它们的长度收集到单词的地图中，然后取最长的一个：

List<String> longestWords =
    Files.lines(Paths.get("alice.txt"))
         .collect(Collectors.groupingBy(String::length))
         .entrySet()
         .stream()
         .sorted(Map.Entry.<Integer, List<String>> comparingByKey().reversed())
         .map(Map.Entry::getValue)
         .findFirst()
         .orElse(null);

编辑：
正如Malte Hartwig所指出的，在流地图上使用max更优雅（可能更快）：

List<String> longestWords =
    Files.lines(Paths.get("alice.txt"))
         .collect(Collectors.groupingBy(String::length))
         .entrySet()
         .stream()
         .max(Map.Entry.comparingByKey())
         .map(Map.Entry::getValue)
         .orElse(null);

EDIT2:
上述两种解决方案都存在内在的低效性，因为它们都构建了一个映射，基本上存储了文件中所有字符串的长度，而不仅仅是最长的字符串。如果在您的用例中，性能比优雅更重要，您可以编写自己的收集器，只保留列表中最长的字符串：

private static int stringInListLength(List<String> list) {
    return list.stream().map(String::length).findFirst().orElse(0);
}

List<String> longestWords =
    Files.lines(Paths.get("alice.txt"))
         .collect(Collector.of(
             LinkedList::new,
             (List<String> list, String string) -> {
                 int stringLen = string.length();
                 int listStringLen = stringInListLength(list);
                 if (stringLen > listStringLen) {
                     list.clear();
                 }
                 if (stringLen >= listStringLen) {
                     list.add(string);
                 }
             },
             (list1, list2) -> {
                 int list1StringLen = stringInListLength(list1);
                 int list2StringLen = stringInListLength(list2);
                 if (list1StringLen > list2StringLen) {
                     return list1;
                 }
                 if (list2StringLen > list1StringLen) {
                     return list2;
                 }
                 list1.addAll(list2);
                 return list1;
             }
         ));