PTA (统计文字中的单词数量并按出现次数排序)

现在需要统计若干段文字(英文)中的单词数量，并且还需统计每个单词出现的次数。

注1：单词之间以空格(1个或多个空格)为间隔。
注2：忽略空行或者空格行。

基本版:
统计时，区分字母大小写，且不删除指定标点符号。

进阶版:
统计前，需要从文字中删除指定标点符号! . , : * ?，注意：所谓的删除，就是用1个空格替换掉相应字符。
统计单词时需要忽略单词的大小写。
输入说明
若干行英文，最后以!!!为结束。

输出说明
单词数量
出现次数排名前10的单词（次数按照降序排序，如果次数相同，则按照键值的字母升序排序）及出现次数。

输入样例1

failure is probably the fortification in your pole

it is like a peek your wallet as the thief when you
are thinking how to spend several hard-won lepta

when you are wondering whether new money it has laid
background because of you then at the heart of the

most lax alert and most low awareness and left it

godsend failed
!!!!!

输出样例1

46
the=4
it=3
you=3
and=2
are=2
is=2
most=2
of=2
when=2
your=2

输入样例2

Failure is probably The fortification in your pole!

It is like a peek your wallet as the thief when You
are thinking how to. spend several hard-won lepta.

when yoU are? wondering whether new money it has laid
background Because of: yOu?, then at the heart of the
Tom say: Who is the best? No one dare to say yes.
most lax alert and! most low awareness and* left it

godsend failed
!!!!!

输出样例2

54
the=5
is=3
it=3
you=3
and=2
are=2
most=2
of=2
say=2
to=2

1. 首先处理读入的问题，读入的时候看似需要按行nextLine读入，实则按照读到空格next读入即可。因为读到空行一样需要忽略，为何不直接利用next读入直接忽略掉空格和空行，按照单词读入。虽然这种读法可能慢一点，但是处理起来方便。而且也不见得比按行读慢，因为按行读需要处理一些东西也块不到哪里去。

2. 由于按照单词读入，单词中必定有一些需要忽略的字符，利用StringBuffer或者StringBuilder字符串处理类将这个单词处理一下，跳掉空格。其他字符照常连接最后toString返回即可。

3. 对处理完的单词进行HashMap<String，Integer>映射，如果出现那么次数+1，否则次数就为1。当处理完所有的单词时建立ArrayList<Map.Entry<String, Integer>>动态数组。这个数组每个单元格存放的就是一个个的Key - Value键值对。

4. 调用Collection.sort方法对ArrayList容器排序，并且重写Comparator接口。按照Value键次数降序排序，其次按照Key键单词字典序升序排列。

5. 最后先输出HashMap容器中单词个数，其次遍历的时候以键值对的方式遍历ArrayList数组，按要求输出即可。重点get一下ArrayList怎么对Map容器排序输出。

import java.util.*;

public class Main {

    static String change(String s){
        StringBuffer sb = new StringBuffer();
        for(int i = 0;i < s.length();i++){
            char x = s.charAt(i);
            if(x == '!' || x == '.' || x == ',' || x == ':' || x == '?' || x == '*'){
                continue;
            }
            sb.append(x);
        }
        return sb.toString().toLowerCase();
    }

    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        HashMap<String,Integer> m = new HashMap<String,Integer>();

        while(true){
            String s = cin.next();
            if(s.equals("!!!!!"))   break;
            s = change(s);
            if(m.containsKey(s)){
                m.put(s,m.get(s)+1);
            }
            else{
                m.put(s,1);
            }
        }

        //ArrayList中放入成对的 k->v 键值对
        ArrayList<Map.Entry<String, Integer> > list = new ArrayList<>(m.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
            public int compare(Map.Entry<String, Integer> m1, Map.Entry<String, Integer> m2) {

                if(m1.getValue() - m2.getValue() != 0)
                    return m2.getValue().compareTo(m1.getValue());
                else
                    return m1.getKey().compareTo(m2.getKey());
            }
        });
        System.out.println(m.size());
        int cnt = 0;
        for(Map.Entry<String, Integer> x : list){			//以键值对的方式遍历list数组
            System.out.println(x.getKey()+"="+x.getValue());
            cnt++;
            if(cnt >= 10)		break;
        }
    }
}