单词统计续

题目要求：

第1步：输出单个文件中的前 N 个最常出现的英语单词。

功能1：输出文件中所有不重复的单词，按照出现次数由多到少排列，出现次数同样多的，以字典序排列。

功能2：指定文件目录，对目录下每一个文件执行统计的操作。

功能3：指定文件目录，是会递归遍历目录下的所有子目录的文件进行统计单词的功能。

功能4：输出出现次数最多的前 n 个单词，

例如，提示统计统计前多少名：输入10。就是输出最常出现单词的前 10 名。当没有指明数量的时候，我们默认列出所有单词的频率。

第2步：第二步: 支持 stop words

在一本小说里，频率出现最高的单词一般都是 "a", "it", "the", "and", "this", 这些词，可以做一个 stop word 文件（停词表），在统计词汇的时候，跳过这些词。我们把这个文件叫 "stopwords.txt" file.

第三步: 想看看常用的短语是什么，怎么办呢？

先定义短语："两个或多个英语单词，它们之间只有空格分隔". 请看下面的例子：

　　hello world //这是一个短语

　　hello, world //这不是一个短语

同一频率的词组，按照字典序来排列。

第四步：把动词形态都统一之后再计数。

想找到常用的单词和短语，但是发现英语动词经常有时态和语态的变化，导致同一个词，同一个短语却被认为是不同的。怎么解决这个问题呢？

假设我们有这样一个文本文件，这个文件的每一行都是这样构成：

动词原型动词变形1 动词变形2... ，词之间用空格分开。

e.g. 动词 TAKE 有下面的各种变形：take takes took taken taking

我们希望在实现上面的各种功能的时候，有一个选项，就是把动词的各种变形都归为它的原型来统计。

功能支持动词形态的归一化

代码：

//信1705-2 20173460 李奔                                             Ctrl+C&&Ctrl+V 
package sec_piao;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

public class Main {

    public Main() {
        // TODO 自动生成的构造函数存根
    }

    public static void main(String[] args) {
        // TODO 自动生成的方法存根

        int n=0;
        while(n!=5)
        {
        @SuppressWarnings("resource")
        Scanner input =new Scanner(System.in);
        System.out.println("1.字母统计：");
        System.out.println("2.单词统计：");
        System.out.println("3.单词的前n个");
        System.out.println("4.字母的前n个");
        System.out.println("5.退出");
        System.out.println();
        String str="piao_chapter1.txt";
         n =input.nextInt();
        switch(n)
        {
        case 1:
            letter(str);
        break;
        case 2:
            try
            {
                word(str);
            } 
            catch (IOException e) 
            {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
        break;    
        case 3:
            int x=0;
            x=input.nextInt();
            try 
            {
                word(str,x);
            } 
            catch (IOException e) 
            {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
        break;
        case 4:
            x=input.nextInt();
                letter(str,x);         
            break;
        case 5:
            System.out.println("退出成功");
            break;
        }
        }
    }
    public static void  word(String s,int x) throws IOException{
        {
          BufferedReader br = new BufferedReader(new FileReader(s));
          StringBuffer sb = new StringBuffer();
          String text =null;
          while ((text=br.readLine())!= null){
              sb.append(text);// 将读取出的字符追加到stringbuffer中
          }
          br.close();  // 关闭读入流
          String str = sb.toString().toLowerCase(); // 将stringBuffer转为字符并转换为小写
          String[] words = str.split("[^(a-zA-Z)]+");  // 非单词的字符来分割，得到所有单词
          Map<String ,Integer> map = new HashMap<String, Integer>() ;
          for(String word :words){
              if(map.get(word)==null){  // 若不存在说明是第一次，则加入到map,出现次数为1
                  map.put(word,1);
              }else{
                  map.put(word,map.get(word)+1);  // 若存在，次数累加1
              }
          }
          // 排序
          List<Map.Entry<String ,Integer>> list = new ArrayList<Map.Entry<String,Integer>>(map.entrySet());
          Comparator<Map.Entry<String,Integer>> comparator = new Comparator<Map.Entry<String, Integer>>() {
              public int compare(Map.Entry<String, Integer> left, Map.Entry<String, Integer> right) {
                  return (left.getValue().compareTo(right.getValue()));
              }
          };
          // 集合默认升序升序
          Collections.sort(list,comparator);
          for(int i=0;i<list.size();i++){// 由高到低输出
              if(returnString(list.get(list.size()-i-1).getKey()).equals(""))
              {
                  
              }
              else
              {
                  if(i<=x)
                  {
                   System.out.println(list.get(list.size()-i-1).getKey()+":"+list.get(list.size()-i-1).getValue());
                  }
              }
          }
      }
    }
  public static void  word(String s) throws IOException{
    {
      BufferedReader br = new BufferedReader(new FileReader(s));

      StringBuffer sb = new StringBuffer();
      String text =null;
      while ((text=br.readLine())!= null){
          sb.append(text);// 将读取出的字符追加到stringbuffer中
      }
      br.close();  // 关闭读入流

      String str = sb.toString().toLowerCase(); // 将stringBuffer转为字符并转换为小写
      String[] words = str.split("[^(a-zA-Z)]+");  // 非单词的字符来分割，得到所有单词
      Map<String ,Integer> map = new HashMap<String, Integer>() ;

      for(String word :words){
          if(map.get(word)==null)
          {  // 若不存在说明是第一次，则加入到map,出现次数为1
              map.put(word,1);
          }
          else
          {
              map.put(word,map.get(word)+1);  // 若存在，次数累加1
          }
      }
      // 排序
      List<Map.Entry<String ,Integer>> list = new ArrayList<Map.Entry<String,Integer>>(map.entrySet());
      Comparator<Map.Entry<String,Integer>> comparator = new Comparator<Map.Entry<String, Integer>>() {
          public int compare(Map.Entry<String, Integer> left, Map.Entry<String, Integer> right) {
              return (left.getValue().compareTo(right.getValue()));
          }
      };
      // 集合默认升序升序
      Collections.sort(list,comparator);
      for(int i=0;i<list.size();i++){// 由高到低输出
          if(returnString(list.get(list.size()-i-1).getKey()).equals(""))
          {
         
          }
          else
          {
               System.out.println(list.get(list.size()-i-1).getKey()+":"+list.get(list.size()-i-1).getValue());
          }
      }
  }
}
    @SuppressWarnings("resource")
    public static void letter(String str)
    {
    double []list=new double[26];
    int []c=new int[26];
    for(int k=0;k<26;k++)
    {
        list[k]=0;
    }
    for(int k=0;k<26;k++)
    {
        c[k]=k+65;
    }
    String line="";
    int a=0;
    int b=0;
    int s=0;
    try
    {
        FileReader fr=new FileReader(str);
        Scanner in =new Scanner(fr);
        while(in.hasNext())
        {
        line=in.nextLine();
        //System.out.println(line);
        for(int i=0;i<line.length();i++)
        {
            a=line.charAt(i);
            
            if (a>=65&&a<=90)
            {
                b=a-65;
            }
            if(a>=97&&a<=122)
            {
                b=a-97;
            }
            //System.out.println(b);
            list[b]+=1;
            s++;
        }
        }
        for(int t=0;t<26;t++)
        {
            list[t]=list[t]/s;
            //System.out.println(list[t]);
        }
        int t,k;
        double d;
        int e;
        for(t=0;t<25;t++)
        {
            for(k=0;k<25-t;k++)
            {
                if(list[k]<list[k+1])
                {
                    d=list[k+1];
                    list[k+1]=list[k];
                    list[k]=d;
                    
                    e=c[k+1];
                    c[k+1]=c[k];
                    c[k]=e;
                }
            }
        }
        for(t=0;t<26;t++)
        {
            System.out.print((char)(c[t])+"  ");
            System.out.println(String.format("%.2f", list[t]*100)+"%");
        }
    }
    catch(Exception e)
    {
        
    }
}
    @SuppressWarnings("resource")
    public static void letter(String str,int x)
    {
    double []list=new double[26];
    int []c=new int[26];
    for(int k=0;k<26;k++)
    {
        list[k]=0;
    }
    for(int k=0;k<26;k++)
    {
        c[k]=k+65;
    }
    String line="";
    int a=0;
    int b=0;
    int s=0;
    try
    {
        FileReader fr=new FileReader(str);
        Scanner in =new Scanner(fr);
        while(in.hasNext())
        {
        line=in.nextLine();
        //System.out.println(line);
        for(int i=0;i<line.length();i++)
        {
            a=line.charAt(i);
            
            if (a>=65&&a<=90)
            {
                b=a-65;
            }
            if(a>=97&&a<=122)
            {
                b=a-97;
            }
            //System.out.println(b);
            list[b]+=1;
            s++;
        }
        }
        
        for(int t=0;t<26;t++)
        {
            list[t]=list[t]/s;
            
            //System.out.println(list[t]);
        }
        int t,k;
        double d;
        int e;
        for(t=0;t<25;t++)
        {
            for(k=0;k<25-t;k++)
            {
                if(list[k]<list[k+1])
                {
                    d=list[k+1];
                    list[k+1]=list[k];
                    list[k]=d;
                    
                    e=c[k+1];
                    c[k+1]=c[k];
                    c[k]=e;
                }
            }
        }
        
        for(t=0;t<26;t++)
        {
            if(t<x)
            {
            System.out.print((char)(c[t])+"  ");
            System.out.println(String.format("%.2f", list[t]*100)+"%");
            }
        }
    }
    catch(Exception e)
    {
        
    }
}
       public static String returnString(String s)
        {
            if(s.equals("the"))
            {    return "";}
            else
            {
                
                return s;
            }
            
        }
}

项目截图：

后续操作未截图，但是可用

单词 统计 续

单词统计续