Question

我正在创建一个Word Comparison类，它也会计算单词的出现次数。（这是Java）

这是我原来的方法：

/**
 * @param map The map of words to search
 * @param num The number of words you want printed
 * @return list of words
 */
public static List<String> findMaxOccurrence(Map<String, Integer> map, int num) {
    List<WordComparable> l = new ArrayList<>();
    for (Map.Entry<String, Integer> entry : map.entrySet())
        l.add(new WordComparable(entry.getKey(), entry.getValue()));

我的IDE建议循环和列表分配可以替换为“收集呼叫”：“stream api calls”

它生成了这段代码：

    List<WordComparable> l =
            map.entrySet().stream()
                    .map(entry -> new WordComparable
                            (entry.getKey(), entry.getValue())).collect(Collectors.toList());

我对lambda数学如何运作感到困惑。如果我的记忆正常，那么 - ＆gt;是每个循环，但其他调用完全令人困惑。

我的IDE还可以将代码扩展为这两个片段：

    List<WordComparable> l =
            map.entrySet().stream()
                    .map(entry -> {
                        return new WordComparable
                                (entry.getKey(), entry.getValue());
                    }).collect(Collectors.toList());

和

    List<WordComparable> l =
            map.entrySet().stream()
                    .map(new Function<Map.Entry<String, Integer>, WordComparable>() {
                        @Override
                        public WordComparable apply(Map.Entry<String, Integer> entry) {
                            return new WordComparable
                                    (entry.getKey(), entry.getValue());
                        }
                    }).collect(Collectors.toList());

任何光线都会很棒。

Answer 1

让我们看一下for循环，看看我们如何写它functionally：

List<WordComparable> l = new ArrayList<>();
for (Map.Entry<String, Integer> entry : map.entrySet())
    l.add(new WordComparable(entry.getKey(), entry.getValue()));

如果我们用简单的英语阅读该代码，我们可能会说＆＃34;对于我的地图的每个条目，让我们将其转换为WordComparable并将其添加到列表中＃34;。

现在，我们可以将该句子改为＆＃34;对于我的地图的每个条目，让我们将其转换为WordComparable，当我们将其全部转换后，让我们列出一个清单＆＃34;。

使用该句子，我们发现我们需要创建一个函数：一个获取地图条目并将其转换为WordComparable的函数。所以，让我们建立一个！ Java 8引入了一个名为Function的新类型，它有一个重要的方法：apply。此方法接受一个输入，转换它并返回一个输出。

编写好的旧Java，因为Function是一个接口，我们可以实现它来编写我们的转换代码：

public class EntryConverter implements Function<Map.Entry<String, Integer>, WordComparable> {

    public WordComparable apply(Map.Entry<String, Integer> entry) {
        return new WordComparable(entry.getKey(), entry.getValue());
    }

}

现在我们有了这个转换器，我们需要在所有条目上使用它。 Java 8还引入了Stream的概念，也就是说，一系列元素（注意这个序列可以是无限的）。使用这个序列，我们最终可以写入我们之前所说的代码，即＆＃34;对于每个条目，让我们将其转换为WordComparable＆＃34;。我们使用map方法，其目标是在流的每个元素上应用方法。

我们有方法：EntryConverter，我们使用stream方法构建Stream条目。

所以，我们得到：

map.entrySet().stream().map(new EntryConverter());

句子的最后一部分是什么：＆＃34;从中{＃1}}制作一个List，即将所有元素收集到List中。这是使用collect方法完成的。此方法采用Collector作为参数，即能够将流减少到最终容器的对象。 Java 8附带了许多预先构建的收集器;其中一个是Collectors.toList()。

最后，我们得到：

map.entrySet().stream().map(new EntryConverter()).collect(Collectors.toList());

现在，如果我们删除临时类EntryConverter并使其匿名，我们会得到您的IDE提议的内容：

List<WordComparable> l = map.entrySet()
                            .stream() //make a Stream of our entries
                            .map(new Function<Map.Entry<String, Integer>, WordComparable>() {
                                 @Override
                                 public WordComparable apply(Map.Entry<String, Integer> entry) {
                                     return new WordComparable(entry.getKey(), entry.getValue());
                                 }
                             }) //let's convert each entry to a WordComparable
                             .collect(Collectors.toList()); //and make a List out of it

现在，编写所有代码有点麻烦，尤其是匿名类的声明。 Java 8通过新的->运算符来解决问题。此运算符允许比以前更轻松地创建Function：左侧对应于函数的参数，右侧对应于结果。这称为lambda expression。

在我们的案例中，我们得到：

entry -> new WordComparable(entry.getKey(), entry.getValue())

也可以使用块体和return语句来编写这个lambda表达式：

entry -> {
    return new WordComparable(entry.getKey(), entry.getValue());
}

请注意这与我们之前在EntryConverter中所写的内容相对应。

这意味着我们可以将代码重构为：

List<WordComparable> l = map.entrySet()
                            .stream()
                            .map(entry -> new WordComparable(entry.getKey(), entry.getValue()))
                            .collect(Collectors.toList());

更具可读性，是您的IDE提出的。

您可以在Oracle site上找到有关lambda表达式的更多信息。

Answer 2

这是Function的lambda表达式。它需要一个对象并返回一个对象。在这种情况下，它需要Map.Entry<String, Integer>，并返回WordComparable。

entry -> new WordComparable(entry.getKey(), entry.getValue())

您可以手动编写等效代码：

final class ConversionFunction 
  implements Function<Map.Entry<String, Integer>, WordComparable>
{
  @Override
  public WordComparable apply(Map.Entry<String, Integer> entry) {
    return new WordComparable(entry.getKey(), entry.getValue());
  }
}

map.entrySet().stream().map(new ConversionFunction()).collect(...);

Stream.map()方法采用可以应用于流中每个元素（Function）的Map.Entry，并生成新类型的元素流（{{1} }）。

WordComparable方法使用Stream.collect()将流的所有元素压缩为单个对象。通常它是一个集合，就像在这里一样，但它可以是任何类型的集合函数。

此Lambda表达式的说明

2 个答案: