Как бы отсортировать список строк по убыванию, затем по возрастанию (если связаны)?

Question

ОК, этот вопрос может заставить вас сказать "Что ??"но я постараюсь дать немного контекста.Я работаю над программой, которая читает файл незашифрованный текст , сортирует строки в файле в порядке убывания по количеству повторений этого слова, а затем по словам, которые встречались с таким же числом раз,Я должен отсортировать эти слова в возрастающем алфавитном порядке ...

Прямо сейчас у меня есть arraylist под названием 'words', который содержит каждое слово в текстовом файле, который я открываю.Итак, как мне отсортировать его в порядке убывания по количеству появившихся слов, а затем по возрастанию в алфавитном порядке, если есть совпадение?

Итак, если бы у меня был список, который был:

[a, a, a, a, b, c, c, c, c, d, d, e, e, e, e, e]

Мой список вывода после сортировки будет:

e : 5
a : 4  // notice the words that occur 4 times are alphabetical sorted
c : 4
d : 2
b : 1

Answer 1

Из вашего вопроса.

сортирует строки в файле в порядке убывания по количеству повторений этого слова, а затем для слов, которые встречались с таким же числом раз, мне пришлосьсортировать эти слова по возрастанию в алфавитном порядке ...

Это означает, что

Во-первых, вам нужно получить отдельный список слов и подсчитать возникновениекаждое слово, это может быть достигнуто с помощью HashMap .

Во-вторых, упорядочить отдельный список слов сначала по номеру вхождения по убыванию, а затем по алфавиту по возрастанию, это может быть достигнуто путем реализации Компаратор и использование Collections.sort метод.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class SortOccurrence {
    Map<String, Integer> wordToOccurenceMap = new HashMap<String, Integer>();

    SortOccurrence(List<String> words) {
        // Count occurrence for each word
        for (String word : words) {
            if (!wordToOccurenceMap.containsKey(word)) {
                wordToOccurenceMap.put(word, 0);
            }
            wordToOccurenceMap.put(word, wordToOccurenceMap.get(word) + 1);
        }
    }

    List<String> getSortResult() {
        List<String> distinctWords = new ArrayList<String>(wordToOccurenceMap.keySet());
        Collections.sort(distinctWords, new OccurrenceComparator());
        List<String> sortResult = new ArrayList<String>();
        for (String distinctWord : distinctWords) {
            sortResult.add(distinctWord + " : " + wordToOccurenceMap.get(distinctWord));
        }
        return sortResult;
    }

    public class OccurrenceComparator implements Comparator<String> {

        @Override
        public int compare(String o1, String o2) {
            if (!wordToOccurenceMap.containsKey(o1) || !wordToOccurenceMap.containsKey(o2)) {
                throw new IllegalArgumentException("word not occur");
            }
            // if occurrence same, compare the string
            if (wordToOccurenceMap.get(o1).compareTo(wordToOccurenceMap.get(o2)) == 0) {
                return o1.compareTo(o2);
            }
            // compare by occurrence, '-' for descending
            return -wordToOccurenceMap.get(o1).compareTo(wordToOccurenceMap.get(o2));
        }
    }

    public static void main(String[] args) {
        List<String> input = Arrays.asList(
                new String[] { "a", "a", "a", "a", "b", "c", "c", "c", "c", "d", "d", "e", "e", "e", "e", "e" });

        SortOccurrence sortOccurence = new SortOccurrence(input);
        System.out.println(sortOccurence.getSortResult());
    }
}