使用lambda表达式的问题

Question

我在按单词的出现次数对单词的字母进行排序时遇到问题，如果字母出现的次数相同，则至少在字典上将其排序。我有一个代码，但在站点上却得到了编译错误，并且得到0分，因为它们使用的是Java 7，而且我不知道如何在没有“ lambda”的情况下解决问题的最后一部分。

    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.*;
    public class prog {
        public static void main(String[] args) throws IOException {
           String testString = " ";
           BufferedReader rd = new BufferedReader(new 
                 InputStreamReader(System.in));
           testString = rd.readLine();
           Map<Character, List<Character>> map = new HashMap<>();
           for (int i = 0; i < testString.length(); i++) {
               char someChar = testString.charAt(i);
               if (someChar == ' ') {
                   continue;
               }
               char ch = testString.charAt(i);
               List<Character> characters = 
                   map.getOrDefault(Character.toLowerCase(ch), new ArrayList<>());
               characters.add(ch);
               map.put(Character.toLowerCase(ch), characters);
           }
           List<Map.Entry<Character, List<Character>>> list =
                new ArrayList<>(map.entrySet());

           list.sort((o1, o2) -> {
                 if (o1.getValue().size() == o2.getValue().size()) {
                     return o1.getKey() - o2.getKey();
                 }
                 return o2.getValue().size() - o1.getValue().size();
            });
            list.forEach(entry -> entry.getValue().forEach(System.out::print));
       }
    }

Answer 1

您可以使用Collections.sort(List<T> list, Comparator<? super T> c)：

Collections.sort(list, new Comparator<Map.Entry<Character, List<Character>>>() {
    @Override
    public int compare(Map.Entry<Character, List<Character>> o1, Map.Entry<Character, List<Character>> o2) {
        if (o1.getValue().size() == o2.getValue().size()) {
            return o1.getKey() - o2.getKey();
        }
        return o2.getValue().size() - o1.getValue().size();
    }
});

for (Map.Entry<Character, List<Character>> characterListEntry : list) {
    System.out.println(characterListEntry);
}

Map#getOrDefault(Object key, V defaultValue)也是Java 8中引入的。您需要将其更改为类似的内容：

char cKey = Character.toLowerCase(ch);
List<Character> characters = map.containsKey(cKey) ? map.get(cKey) : new ArrayList<>();

Answer 2

对于这样的事情，我更喜欢写local classes来处理。另外，它们比匿名类还干净，但确实需要其他语法。如果您不熟悉这些内容，它将放在您的主类中。

    static class CountThenLex implements Comparator < Entry < Character, List < Character >>> {
        public int compare(
            Entry < Character, List < Character >> a,
            Entry < Character, List < Character >> b) {
            int asize = a.getValue().size();
            int bsize = b.getValue().size();
            // note that b is sorted first for descending count order.

            int aTob = bsize > asize ? 1 :
                bsize < asize ? -1 : 0;
            if (aTob != 0) {
                return aTob;
            }

            // if the counts are equal, then sort lexically.  Since the Character
            // class implements `Comparable` you can use the natural ordering.
            return a.getKey().compareTo(b.getKey());
        }
    }

然后，您仅使用类的实例调用sort。

    Collections.sort(list, new CountThenLex());

由于还存在其他Java 8功能，因此您还必须修改打印方法以及其他方法。这是基本的打印解决方案。

    for(Entry<?,List<Character>> e : list) {
        for (char c : e.getValue()) {
            System.out.print(c);
        }
    }
    System.out.println();