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, );

                 }else {

                     wordMap.put(word, wordMap.get(word)+);

                 }

             }

         }

         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, )+));//遍历执行操作

         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[];

         int data;

         String str ="";

         while((data = fis.read(bytes))!=-){

             str += new String(bytes, , data);

         }

         fis.close();

         return str;

     }

 }