java ArrayList中最常见的n字

我需要找到最频繁的单词n个单词，因此如果n=5，则在ArrayList中查找最频繁的5个单词

private ArrayList<String> wordList = new ArrayList<String>();


public ArrayList<String> mostOften(int k)
{
    ArrayList<String> lista = new ArrayList<String>();
    Set<String> unique = new HashSet<String>(wordList);
    for (String key : unique) 
        System.out.println(key + ": " + Collections.frequency(wordList, key));

    return lista;
}

---

该函数需要返回按频率排序的最频繁单词的列表。如果两个单词的频率相同，我需要按字母顺序对它们进行排序。我已经发布了我尝试过的内容，但这只找到了频率，我不知道如何做其余的。有什么帮助吗？

您可以编写一个比较器类，该类用列表初始化。然后可以使用列表和比较器调用Collections.sort。 代码可能如下所示：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class FrequencyComparator implements Comparator<String>{

    List<String> list;

    @Override
    public int compare(String o1, String o2) {
        if (Collections.frequency(list, o1) > Collections.frequency(list, o2)){
            return -1;
        }else if (Collections.frequency(list, o1) < Collections.frequency(list, o2)){
            return 1;
        }else{
            return o1.compareTo(o2);
        }
    }

    public FrequencyComparator(List<String> list){
        this.list = list;
    }

    public static void main(String[] args)
    {
        List<String> list = new ArrayList<String>();
        list.add("Hello");
        list.add("You");
        list.add("Hello");
        list.add("You");
        list.add("Apple");
        list.add("Apple");
        list.add("Hello");
        Set<String> unique = new HashSet<>(list);
        List<String> uniqueList = new ArrayList<>(unique);
        Collections.sort(uniqueList, new FrequencyComparator(list));
        System.out.println(uniqueList);
        //Take the most frequent 2 objects
        System.out.println(uniqueList.subList(uniqueList.size() - 2, uniqueList.size());
    }

}

---

下面是一个使用Java 8和streams的解决方案，包括计算词频、排序和限制为k个单词：

---

差不多好了。我需要将compareTo从现在的相反顺序反转。您可以在方法末尾使用Collections的reverse方法。您可以更改compareTo方法。只需将-1替换为1，将1替换为-1，我建议不要在比较中使用Collections.frequency。这样效率较低，但这仅在列表较长时才起作用Hello！我想问一下，您获取每个单词频率的方式与Java Collections.frequent获取单词的方式有什么区别，因为我试图在大量单词中找到最频繁的单词900000，因此，我使用Collection.frequent获取ArrayList中的每个单词的频率，我的计算机失败了，因为它太难处理。非常感谢。

class Pair {
    String text;
    int freq;

    public Pair(String text, int freq) {
       super();
       this.text = text;
       this.freq = freq;
    }

}

 public List<Pair> sortFreq(List<String> wordList) {
    Set<String> unique = new HashSet<String>(wordList);
    List<Pair> list = new ArrayList<Pair>(unique.size());
    for (String key : unique) {
        int freq = Collections.frequency(wordList, key);
        Pair tempPair = new Pair(key, freq);
        list.add(tempPair);
    }
    Collections.sort(list,new Comparator<Pair>() {

        @Override
        public int compare(Pair o1, Pair o2) {
        if(o1.freq == o2.freq){
            return o1.text.compareTo(o2.text);
        }
        return o2.freq - o1.freq;
        }

    });
    return list;
 }

public class WordFrequency {

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("Hello");
        list.add("aaaa");
        list.add("aaaa");
        list.add("World");
        list.add("abc");
        list.add("abc");
        list.add("cba");
        list.add("abc");
        list.add("World");
        list.add("abc");
        System.out.println(mostOften(list));
    }

    public static List<Word> mostOften(List<String> words){
        Map<String, Word> wordMap = new HashMap<>();
        for (String word : words) {
            Word currentWord = wordMap.get(word);
            if(currentWord == null) 
                wordMap.put(word, new Word(word, 1));
            else
                currentWord.frequency++;
        }

        List<Word> wordList = new ArrayList<>(wordMap.values());
        wordList.sort(new Comparator<Word>() {
            @Override
            public int compare(Word o1, Word o2) {
                if(o1.frequency == o2.frequency)
                    return o1.word.compareToIgnoreCase(o2.word);

                /* sort words with high frequency first */
                return Integer.compare(o2.frequency, o1.frequency);
            }
        });
        return wordList;
    }


}


public class Word{
    String word;
    int frequency;

    public Word(String word, int total) {
        this.word = word;
        this.frequency = total;
    }

    public String toString(){
        return "[" + word + ", " + frequency + "]";
    }
}

List<String> wordList = new ArrayList<String>();
int k = 5;
List<String> mostFrequentWords = wordList.stream().collect(Collectors.collectingAndThen(
    Collectors.groupingBy(Function.identity(), Collectors.counting()),
    map -> map.entrySet().stream()
        .sorted(Comparator.<Entry<String, Long>> comparingLong(Entry::getValue).reversed()
            .thenComparing(Entry::getKey))
        .map(Entry::getKey)
        .limit(k)
        .collect(Collectors.toList())));