Java 这个Lambda表达式的解释

我正在创建一个单词比较类，它也会计算单词的出现次数。（这是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()));

/**
*@param映射要搜索的单词地图
*@param num要打印的字数
*@返回单词列表
*/
公共静态列表findMaxOccurrence（映射映射，int num）{
列表l=新的ArrayList（）；
对于（Map.Entry:Map.entrySet（））
l、 添加（新单词compariable（entry.getKey（），entry.getValue（））；

我的IDE建议将循环和列表分配替换为“收集调用”：“流api调用”

它在其中生成了以下代码：

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

列表l=
map.entrySet（）.stream（）
.map（条目->新单词）
（entry.getKey（），entry.getValue（））.collect（collector.toList（））；

我对lambda数学的工作原理有点困惑。如果我的记忆正确，则->是for each循环的值，但其他调用完全混乱

My IDE还可以将代码扩展为以下两个片段：

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

列表l=
map.entrySet（）.stream（）
.map（条目->{
返回新单词
（entry.getKey（），entry.getValue（））；
}).collect（Collectors.toList（））；

及

列表l=
map.entrySet（）.stream（）
.map（新函数（）{
@凌驾
公共词汇可比应用（Map.Entry）{
返回新单词
（entry.getKey（），entry.getValue（））；
}
}).collect（Collectors.toList（））；

---

任何光线照射都会很棒。

这是a的lambda表达式。它接受一个对象并返回一个对象。在这种情况下，它接受一个

映射。条目

，并返回一个

单词

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(...);

final类转换函数
实现功能
{
@凌驾
公共词汇可比应用（Map.Entry）{
返回新的WordComparable（entry.getKey（），entry.getValue（））；
}
}
map.entrySet（）.stream（）.map（新的转换函数（））.collect（…）；

Stream.map（）

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

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

您的规则意味着您使用每个元素（带有“entry”别名）为map（）结果集合创建新元素。
然后，您应该使用合适的收集器将元素收集到合适的集合中

注意，collect应用于map（）结果。
让我们更仔细地看看for循环，看看如何编写它：

现在我们有了这个转换器，我们需要在所有条目上使用它。Java 8还引入了元素序列的概念（注意，这个序列可以是无限的）。使用这个序列，我们最终可以将前面提到的内容写入代码中，即“对于每个条目，让我们将其转换为
WordComparable
”。我们使用该方法，其目标是对流的每个元素应用一个方法

我们有一个方法：
EntryConverter
，我们使用该方法构建一个
条目的流

因此，我们得到：

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

剩下的是句子的最后一部分：“制作一个
列表
”，即将所有元素收集到
列表
。这是使用该方法完成的。该方法以一个作为参数，即一个能够将流减少到最终容器中的对象。Java 8附带了许多预构建的收集器；其中一个是

最后，我们得到：

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

也可以使用块体和返回语句编写此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());

List l=map.entrySet（）
.stream（）
.map（entry->newwordcompariable（entry.getKey（），entry.getValue（））
.collect（Collectors.toList（））；

更具可读性，这也是IDE的建议

你可以在上找到更多关于lambda表达式的信息。
我喜欢这个解释，希望你能完成。你，先生，就是那个人。通过这个成语。我不敢相信你解释得有多好。谢谢。非常感谢你的解释。：）如果Tunaki发布的最新答案没有完成，那么我将不得不将其标记为accep默认情况下，这是一个错误。
map.entrySet().stream().map(new EntryConverter()).collect(Collectors.toList());

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

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

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

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