定义类实现，输入一段英文段落，统计段落中出现的英文单词个数，不同英文单词个数，每个英文单词出现的次数；使用String,ArrayList完成相应功能； 再定义一个管理类，查找不同段落中出现的相同英文单词及出现的次数

好的，这是一个比较复杂的问题，但我会尽力解答。首先，我们可以定义一个名为WordCounter的类来完成这个任务。该类可以有以下方法：

public class WordCounter {
    private String paragraph;
    private ArrayList<String> words;

    public WordCounter(String paragraph) {
        this.paragraph = paragraph;
        this.words = new ArrayList<String>();
    }

    public int getWordCount() {
        String[] splitParagraph = this.paragraph.split(" ");
        return splitParagraph.length;
    }

    public int getUniqueWordCount() {
        HashSet<String> uniqueWords = new HashSet<String>(this.words);
        return uniqueWords.size();
    }

    public HashMap<String, Integer> getWordFrequency() {
        HashMap<String, Integer> frequencyMap = new HashMap<String, Integer>();
        for (String word : this.words) {
            if (frequencyMap.containsKey(word)) {
                frequencyMap.put(word, frequencyMap.get(word) + 1);
            } else {
                frequencyMap.put(word, 1);
            }
        }
        return frequencyMap;
    }

    public void processParagraph() {
        String[] splitParagraph = this.paragraph.split(" ");
        for (String word : splitParagraph) {
            this.words.add(word);
        }
    }
}

这个类有一个构造函数，它接受一个字符串参数，该字符串是我们要处理的段落。在构造函数中，我们还初始化了一个ArrayList，用于存储段落中的所有单词。

接下来，我们有一个名为getWordCount的方法，它返回段落中出现的单词总数。这个方法非常简单，它只需将段落字符串拆分成单词数组并返回该数组的长度即可。

然后，我们有一个名为getUniqueWordCount的方法，它返回段落中不同单词的数量。为此，我们使用了Java中的HashSet，它可以自动去重。

接下来，我们有一个名为getWordFrequency的方法，它返回一个HashMap，其中包含每个单词及其出现次数。我们遍历存储在ArrayList中的单词列表，并使用HashMap来记录每个单词出现的次数。

最后，我们有一个名为processParagraph的方法，它将段落字符串拆分成单词，并将每个单词添加到ArrayList中。

现在，我们可以创建一个名为WordCounterManager的类来管理多个WordCounter实例，从而处理多个段落。我们可以使用HashMap来存储每个段落及其对应的WordCounter实例。然后，我们可以实现一个名为findCommonWords的方法，该方法将查找所有段落中出现的相同单词及其出现次数。以下是WordCounterManager类的示例代码：

public class WordCounterManager {
    private HashMap<String, WordCounter> wordCounters;

    public WordCounterManager() {
        this.wordCounters = new HashMap<String, WordCounter>();
    }

    public void processParagraph(String paragraph) {
        WordCounter wordCounter = new WordCounter(paragraph);
        wordCounter.processParagraph();
        this.wordCounters.put(paragraph, wordCounter);
    }

    public HashMap<String, Integer> findCommonWords() {
        HashMap<String, Integer> commonWords = new HashMap<String, Integer>();
        for (WordCounter wordCounter : this.wordCounters.values()) {
            HashMap<String, Integer> frequencyMap = wordCounter.getWordFrequency();
            for (String word : frequencyMap.keySet()) {
                if (commonWords.containsKey(word)) {
                    commonWords.put(word, commonWords.get(word) + frequencyMap.get(word));
                } else {
                    commonWords.put(word, frequencyMap.get(word));
                }
            }
        }
        return commonWords;
    }
}

这个类有一个构造函数，它初始化了一个HashMap来存储多个WordCounter实例。我们还有一个名为processParagraph的方法，它接受一个段落字符串参数，并使用该字符串创建一个新的WordCounter实例。然后，我们将WordCounter实例添加到HashMap中，并调用其processParagraph方法来处理段落。

最后，我们有一个名为findCommonWords的方法，该方法将查找所有段落中出现的相同单词及其出现次数。我们遍历存储在WordCounterManager中的所有WordCounter实例，并使用HashMap来记录每个单词在所有段落中出现的总次数。

希望这个答案能够帮助到你！