最好是抽象出类中数据的逻辑单元，在你的问题中你有两个清晰的单元：
1.单词出现（单词串和行号）。

class WordOccurrence {
         private final String word;
         private final int lineNumber;

         ...
     }

1.有关单词的统计信息（出现次数、出现的行号集等）。

class WordStats {
         private List<Word> occurrences;

         public String getWord() { ... }
         public int getCount() { ... }
         public Set<Integer> getLines() { ... }
     }

使用这些类，您可以首先将text分解为List或WordOccurrence的Map;因此，对于每个不同的字，Map将包含具有以下内容的条目：
1.等于实际String字的键
1.值等于List，其中包含WordOccurrence对象，用于text中的每个匹配项
您可以通过以下方式实现此目的：

public static Map<String, List<WordOccurrence>> createOccurrencesMap(String text) {
        text = text.replaceAll("\\.", " ");
//      text = text.replaceAll("'s", ""); // dog's != dog ???
        Map<String, List<WordOccurrence>> result = new HashMap<>();
        String[] lines = text.split("\n");
        for (int i = 0; i < lines.length; i++)
            for (String word : lines[i].split("\\s+")) 
                result.computeIfAbsent(word, w -> new ArrayList<>())
                            .add(new WordOccurrence(word, i + 1));
        
        return result;
    }

然后，你可以很容易地将这个Map转换成WordStats的List（使用灵活的参数化标准排序），如下所示：

List<WordStats> createStats(String text, Comparator<WordStats> sortingCriteria) {
        return createOccurrencesMap(text).values().stream()
                .map(WordStats::new)
                .sorted(sortingCriteria)
                .collect(Collectors.toList());
    }

一旦你把你的问题分解成更小的直观的逻辑分组组件（类、方法、数据结构等），剩下的唯一事情就是把它们连接起来。
以下代码是此解决方案的完整工作演示，供您使用：

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

public class CountWords {

    public static void main(String[] args) {
        String text = "the quick brown fox jumped over the lazy dog's bowl.\nthe dog was angry with the fox for considering him lazy.";
        Comparator<WordStats> sortingCriteria = Comparator
                .comparing(WordStats::getCount).reversed()
                .thenComparing(WordStats::getWord);

        createStats(text, sortingCriteria).forEach(System.out::println);
    }

    public static List<WordStats> createStats(String text, Comparator<WordStats> sortingCriteria) {
        return createOccurrencesMap(text).values().stream()
                .map(WordStats::new)
                .sorted(sortingCriteria)
                .collect(Collectors.toList());
    }
    
    public static Map<String, List<WordOccurrence>> createOccurrencesMap(String text) {
        text = text.replaceAll("\\.", " ");
//      text = text.replaceAll("'s", ""); // dog's != dog ???
        Map<String, List<WordOccurrence>> result = new HashMap<>();
        String[] lines = text.split("\n");
        for (int i = 0; i < lines.length; i++)
            for (String word : lines[i].split("\\s+")) 
                result.computeIfAbsent(word, w -> new ArrayList<>())
                            .add(new WordOccurrence(word, i + 1));
        
        return result;
    }
    
    static class WordStats {
        private List<WordOccurrence> occurrences;

        public WordStats(List<WordOccurrence> words) {
            this.occurrences = words;
        }
        
        public String getWord() {
            return occurrences.get(0).getWord();
        }

        public int getCount() {
            return occurrences.size();
        }
        
        public Set<Integer> getLines() {
            return occurrences.stream().map(WordOccurrence::getLineNumber).collect(Collectors.toSet());
        }
        
        public String toString() {
            return String.format("%s %d %s", getWord(), getCount(), getLines());
        }
    }
    
    static class WordOccurrence {
        private final String word;
        private final int lineNumber;

        public WordOccurrence(String word, int lineNumber) {
            this.word = word;
            this.lineNumber = lineNumber;
        }

        public String getWord() {
            return word;
        }

        public int getLineNumber() {
            return lineNumber;
        }
        
        public String toString() {
            return word + "@" + lineNumber;
        }
    }
}

Complete code on GitHub