JAVA实现一段文本中单词数量统计

任务：

编写一个能计算一段文本内容中出现单词的次数的降序排列的小程序。

统计字符串中单词个数

//使用map集合进行存储  
String s="Day by Day";  
Map<String,Integer> map=new HashMap<String,Integer>();  
StringTokenizer tokenizer=new StringTokenizer(s);  
int count;//记录次数  
String word;//单个单词  
while(tokenizer.hasMoreTokens()){  
    word=tokenizer.nextToken(" ");  
    if(map.containsKey(word)){  
        //拿到之前存在map集合中该单词的次数  
        count=map.get(word);  
        map.put(word, count+1);  
    }else{  
        map.put(word, 1);  
    }  
}  
Set<Entry<String, Integer>> entrySet = map.entrySet();  
for (Entry<String, Integer> entry : entrySet) {  
    System.out.println(entry.getKey()+"-"+entry.getValue());  
}  

如何进行排序

使用Collections包装类。它包含有各种有关集合操作的静态多态方法。

//可根据指定比较器产生的顺序对指定列表进行排序。  
 Collections.sort(List<T> list, Comparator<? super T> c)  

示例

//以上实例中的map集合为例   将map集合的每一项添加进list集合中  
List<Map.Entry<String, Integer>> infos = new ArrayList<Map.Entry<String, Integer>>(map.entrySet());  
Collections.sort(infos, new Comparator<Map.Entry<String, Integer>>() {  
    public int compare(Map.Entry<String, Integer> o1,  
        Map.Entry<String, Integer> o2) {  
        //前者-后者  升序         后者-前者  降序  
        return (o2.getValue() - o1.getValue());  
    }  
});  

要求

将指定文本(可以通过右侧文件目录下的readme.txt查看)以降序的方式输出每个单词出现的次数。

实现

package split;

import java.util.*;

public class StudentDemo {
    //获取单词的数量
    public Map<String, Integer> getWordCount(String str) {
        Map<String, Integer> map = new HashMap<String, Integer>();
        StringTokenizer st = new StringTokenizer(str);
//请在此添加实现代码
        int count;
        String word;
        while (st.hasMoreTokens()) {
            word = st.nextToken("[ ,?.!:\n;’]");
            if (map.containsKey(word)) {
                count = map.get(word);
                map.put(word, count + 1);
            } else {
                map.put(word, 1);
            }
        }
        List<Map.Entry<String, Integer>> entries = new ArrayList<>(map.entrySet());
        /*
        排序方法1:实现Comparator接口的compare方法来完成自定义排序
        并用reversed()实现倒序
         */

        Comparator<Map.Entry> entryComparator = new Comparator<>() {
            @Override
            public int compare(Map.Entry o1, Map.Entry o2) {
                return ((int) o1.getValue() - (int) o2.getValue());
            }
        };
        Collections.sort(entries, entryComparator.reversed());

//       Collections.sort(entries, (o1, o2) -> (o2.getValue() - o1.getValue()));
       /*
       排序方法 2
         Lambda表达式的标准格式为：
        (参数类型 参数名称) ‐> { 代码语句 }
        格式说明：
        小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。
        -> 是新引入的语法格式，代表指向动作。
        大括号内的语法与传统方法体要求基本一致
        省略规则
        在Lambda标准格式的基础上，使用省略写法的规则为：

        小括号内参数的类型可以省略；
        如果小括号内有且仅有一个参，则小括号可以省略；
        如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号
        lambda本质就是为了简写接口实现而存在的语法糖
         */

        return map;
    }
}

package split;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.*;
import java.util.Map.Entry;

public class test {
    public static void main(String[] args) throws IOException {
        StudentDemo demo = new StudentDemo();
        BufferedReader buffer = new BufferedReader(new FileReader("C:\\Users\\Davidlee\\Desktop\\java\\new\\src\\main\\java\\split\\readme.txt"));
        String str = "", s = "";
        while ((str = buffer.readLine()) != null) {
            s += str;
        }
        Map<String, Integer> wordCount = demo.getWordCount(s);
        List<Entry<String, Integer>> sortWordCount = sortWordCount(wordCount);
        for (Entry<String, Integer> entry : sortWordCount) {
            System.out.println(entry.getKey() + "-" + entry.getValue());
        }
    }

    //对单词出现的次数进行排序
    public static List<Entry<String, Integer>> sortWordCount(Map<String, Integer> map) {
        List<Map.Entry<String, Integer>> infos = new ArrayList<Map.Entry<String, Integer>>(map.entrySet());
        Collections.sort(infos, new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
                return (o2.getValue() - o1.getValue());
            }
        });
        return infos;
        //排序方法3 重写倒序
    }

}