Java 8 Lambda 表达式

Question

我一直坚持使用一个 lambda 表达式和使用 Comparator.comparing(...).thenComparing(...) 方法的 Comparator 类来总结两种对流进行排序的方式。

我的两种方法都有效，但是当我将它们放在一起时，根本没有任何效果。

如果您想尝试验证练习，请点击以下链接：

http://codecheck.it/codecheck/files?repo=heigvdcs1&problem=poo3e

这是你必须做的：

对于流中的每个单词，确定“元音”，即元音的数量 - 辅音的数量。生成与元音值配对的元音最高的n 单词。首先按元音排序，然后按字符串排序。完成这个程序。 这一次，您可以使用一个隐藏的静态方法 long Words.vowels(String w)，它可以生成 w 中元音的数量，包括重复。

现在我已经做到了：

import java.util.*;
import java.util.stream.*;

public class Streams
{
   List<Pair<String, Long>> wordsWithManyVowels(Stream<String> words, int n)
   {
      return words
         .map( w -> Pair.of( w , ( Words.vowels(w) - ( w.length() - Words.vowels(w)))))
         .sorted(Comparator.comparingLong(f1 -> -f1.second())
         //This part is working without the first comparing
         //.thenComparing(f2 -> f2.first().length()))
         .limit(n)
         .collect(Collectors.toList());
   }
}

Pair 类：

import java.util.Objects;

public class Pair<T, S> 
{
   private T first;
   private S second;

   public Pair(T firstElement, S secondElement)
   {
      first = firstElement;
      second = secondElement;
   }

   /*
      Use Pair.of(x, y) instead of new Pair<...,...>(x, y)
      so you get the type inferred
   */

   public static <T, S> Pair<T, S> of(T firstElement, S secondElement)
   {
      return new Pair<T, S>(firstElement, secondElement);
   }

   public T first() { return first; }
   public S second() { return second; }

   public String toString() { return "(" + first + "," + second + ")"; }

   public boolean equals(Object otherObject)
   {
      if (this == otherObject) 
         return true;
      if (otherObject == null || !(otherObject instanceof Pair)) 
         return false;
      @SuppressWarnings("unchecked") Pair<T, S> other = (Pair<T, S>) otherObject;
      return Objects.equals(first, other.first) &&
         Objects.equals(second, other.second);
   }
}

Answer 1

解决方案 1

将比较方法提取为static 的工作方式如下

public class Streams {
    List<Pair<String, Long>> wordsWithManyVowels(Stream<String> words, int n) {
        return words
            .map(w -> Pair.of(w, (Words.vowels(w) - (w.length() - Words.vowels(w)))))
            .sorted(Comparator.comparingLong(Streams::vowelness).thenComparingInt(Streams::length))
            .limit(n)
            .collect(Collectors.toList());
    }

    static int length(Pair<String, Long> p) {
        return p.first().length();
    }

    static long vowelness(Pair<String, Long> p) {
        return -p.second();
    }
}

解决方案 2

使用此 Comparator 实现而不使用 static 方法

Comparator
    .comparingLong((Pair<String, Long> p) -> -p.second())
    .thenComparingInt((Pair<String, Long> p) -> p.first().length())

注意：看看thenComparingInt在两个解决方案中复合比较器的末尾是如何使用的。

解决方案 3

源代码的问题是静态Comparator 方法需要有关处理链中元素类型的信息。默认使用Object 类型。因此，可以这样指定（比解决方案 2 更简单）：

Comparator.<Pair<String, Long>>comparingLong(p -> -p.second()).thenComparing(p -> p.first().length())