Java8新特性——lambda表达式.（案例：词频统计）

需求：读入一个文本文件，确定所有单词的使用频率并从高到低排序，打印出所有单词及其频率的排序列表

先用传统方法解：

package cn._1.wordfrequency;

import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/*
 * Functional Thinking by Neal Ford(O'Reilly).
 */
public class Word {

    @SuppressWarnings("serial")
    //统计除了以下单词的其他单词的使用频率
    private Set<String> NON_WORDS = new HashSet<String>() {{
        //匿名内部类+初始化块的初始化方式
            add("the");add("and");add("of");add("to");add("a");
            add("i");add("it");add("in");add("or");add("is");
            add("as");add("so");add("but");add("be");
        }};
    public Map<String, Integer> wordFreq(String words) {
        TreeMap<String,Integer> wordMap = new TreeMap<>();
        Matcher m = Pattern.compile("\w+").matcher(words);
        while(m.find()){
            String word = m.group().toLowerCase();
            if (!NON_WORDS.contains(word)) {
                if (wordMap.get(word) == null) {
                    wordMap.put(word, 1);
                }else {
                    wordMap.put(word, wordMap.get(word)+1);
                }
            }
        }
        return wordMap;
    }
}

再使用Java8的新特性解：

package cn._1.wordfrequency;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/*
 * Functional Thinking by Neal Ford(O'Reilly).
 */
public class Word2 {
    @SuppressWarnings("serial")
    private Set<String> NON_WORDS = new HashSet<String>() {{
        //匿名内部类+初始化块的初始化方式
            add("the");add("and");add("of");add("to");add("a");
            add("i");add("it");add("in");add("or");add("is");
            add("as");add("so");add("but");add("be");
        }};
    /*
     * 使用正则表达式获得包含所有单词的List
     */
    private List<String> regexToList(String words,String regex){
        List<String> wordList = new ArrayList<>();
        Matcher m = Pattern.compile(regex).matcher(words);
        while(m.find())
            wordList.add(m.group());
        return wordList;
    }
    public Map<String, Integer> wordFreq(String words){
        TreeMap<String, Integer> wordMap = new TreeMap<>();//使用TreeMap是为了使输出结果自然排序
        /*
         * java.util.stream.Stream:A sequence of elements supporting sequential and parallel aggregate operations.
         * map:Returns a stream consisting of the results of applying the given function to the elements of this stream.
         * filter:Returns a stream consisting of the elements of this stream that match the given predicate.
         * forEach:Performs an action for each element of this stream.
         */
        regexToList(words, "\w+").stream()//将collection对象变为stream
            .map(w -> w.toLowerCase())//返回一个经过小写处理的stream
            .filter(w -> !NON_WORDS.contains(w))//过滤,使流中的元素都是NON_WORDS集合中不包含的元素
            .forEach(w -> wordMap.put(w, wordMap.getOrDefault(w, 0)+1));//遍历执行操作
        return wordMap;
    }
}

测试类：

package cn._1.wordfrequency;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class Mmain {

    public static void main(String[] args) throws IOException {
        String str = readText("/home/yanshaochen/workspace/Functional_Thinking_Examples/mflie/sucai.txt");
        //调用老方法
        /*Map<String, Integer> map = new Word().wordFreq(str);*/
        //调用新方法：
        Map<String, Integer> map = new Word2().wordFreq(str);
        //自然排序：
        for (Entry<String, Integer> item : map.entrySet()) {
            System.out.println(item.getKey()+","+item.getValue());
        }
        //按照value进行排序（摘自网络）：
        /*List<Map.Entry<String, Integer>> infoIds = new ArrayList<>(map.entrySet());
        Collections.sort(infoIds, new Comparator<Map.Entry<String, Integer>>() {
            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {      
                return (o2.getValue() - o1.getValue()); 
                //return (o1.getKey()).toString().compareTo(o2.getKey());
                }
            }); 
        for (Entry<String, Integer> item : infoIds) {
            System.out.println(item.getKey()+","+item.getValue());
        }*/
    }

    /*
     * IO流
     */
    private static String readText(String path) throws IOException {
        FileInputStream fis = new FileInputStream(path);
        byte[] bytes = new byte[1024];
        int data;
        String str ="";
        while((data = fis.read(bytes))!=-1){
            str += new String(bytes, 0, data);
        }
        fis.close();
        return str;
    }
}