单词统计续

       这次练习是在一次的测试的基础上进行的，主要目的是要求我们进行功能模块的划分，这就要求我们写代码时思路要清晰，最大程度地实现代码的重构复用；这一点自己也是深有体会。

       本来第一问做的是很快的，大部分时间都用在了第二问----过滤无用词上，用了大概1个小时40分钟。至于为什么用了这么长时间，课下我也是认真反思，发现主要原因是在‘==’和‘equals’还有‘break’和‘continue’的区别上，这一点上学期老师让我们发博客总结过，但是当时没有认真对待，导致现在对这两点都有点迷糊。下来一定会好好总结下这些容易混淆的知识点。

       经过课下的研究，目前完成前两个功能，代码冗余比较严重，下来还会对代码进行改进，目前代码如下：

     

package xxx;
/* yr
 * 2019/4/28
 */

import java.io.*;
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;

import jdk.internal.org.objectweb.asm.util.CheckAnnotationAdapter;

public class Word{
    
    //统计26个英文字母（不区分大小写）出现的频率
    public void check1(String string) {
         try {
                char num[] = new char[10000];          //存储读取的各个字符
                char c[] = new char[26];                 //存储26个英文字母
                c[0]='a';
                for(int i=1;i<26;i++)
                {
                    c[i]=(char)(c[i-1]+1);
                }
                
                int j=0;
                double count[]=new double[26];                 //存储26个英文字母出现的次数
                double p[]=new double[26];               //存储26个英文字母出现的频率
                String pathname=string;
                File filename=new File(pathname);
                InputStreamReader reader=new InputStreamReader(new FileInputStream(filename));
                BufferedReader br=new BufferedReader(reader);
                String line[]=new String[100];;    
                for(int i=0;i<line.length;i++){
                line[i]=br.readLine();     //读取一行             
                }
         
                br.close();
                int n=0;
              
                 while(line[n]!=null) {
                    
                     for(int i=0;i<line[n].length();i++) {                                
                          num[j]=line[n].charAt(i);
                          j++;                     
                     }
              n++;
                }    
                
                for(int i=0;i<num.length;i++) {
                     switch(num[i]) {
                     
                     case 'a':count[0]++;break;
                     case 'b':count[1]++;break;
                     case 'c':count[2]++;break;
                     case 'd':count[3]++;break;
                     case 'e':count[4]++;break;
                     case 'f':count[5]++;break;
                     case 'g':count[6]++;break;
                     case 'h':count[7]++;break;
                     case 'i':count[8]++;break;
                     case 'j':count[9]++;break;
                     case 'k':count[10]++;break;
                     case 'l':count[11]++;break;
                     case 'm':count[12]++;break;
                     case 'n':count[13]++;break;
                     case 'o':count[14]++;break;
                     case 'p':count[15]++;break;
                     case 'q':count[16]++;break;
                     case 'r':count[17]++;break;
                     case 's':count[18]++;break;
                     case 't':count[19]++;break;
                     case 'u':count[20]++;break;
                     case 'v':count[21]++;break;
                     case 'w':count[22]++;break;
                     case 'x':count[23]++;break;
                     case 'y':count[24]++;break;
                     case 'z':count[25]++;break;
                     case 'A':count[0]++;break;
                     case 'B':count[1]++;break;
                     case 'C':count[2]++;break;
                     case 'D':count[3]++;break;
                     case 'E':count[4]++;break;
                     case 'F':count[5]++;break;
                     case 'G':count[7]++;break;
                     case 'H':count[6]++;break;
                     case 'I':count[8]++;break;
                     case 'J':count[9]++;break;
                     case 'K':count[10]++;break;
                     case 'L':count[11]++;break;
                     case 'M':count[12]++;break;
                     case 'N':count[13]++;break;
                     case 'O':count[14]++;break;
                     case 'P':count[15]++;break;
                     case 'Q':count[16]++;break;
                     case 'R':count[17]++;break;
                     case 'S':count[18]++;break;
                     case 'T':count[19]++;break;
                     case 'U':count[20]++;break;
                     case 'V':count[21]++;break;
                     case 'W':count[22]++;break;
                     case 'X':count[23]++;break;
                     case 'Y':count[24]++;break;
                     case 'Z':count[25]++;break;
                     }
                }    
                
     
                double sum=0.0;
                System.out.println("短文中各字母出现情况统计如下：");
                for(int i=0;i<26;i++)
                {
                    sum=sum+count[i];
                } 
                
                
                for(int i=0;i<26;i++)
                {
                    
                    p[i]=(Math.round(count[i]/sum * 10000) / 100.0);
                   
                }
              
                //对频率数组进行排序
                double temp;                
                char f;
                for(int i=0;i<25;i++) //冒泡排序，外循环有N－1轮
                    for(int t=0;t<25-i;t++)
                    if(p[t]<p[t+1])            //从大到小
                    {
                        temp=p[t];
                        p[t]=p[t+1];
                        p[t+1]=temp;                              
                        
                        f=c[t];
                        c[t]=c[t+1];
                        c[t+1]=f;
                    }
                
                //输出
                for(int i=0;i<26;i++)
                {
                    System.out.println(c[i]+"的频率为："+p[i]+"%");
                }
               
            }catch (Exception e) {
                e.printStackTrace();
            }
    }
    //统计最常出现的N个单词出现的
        public void check2(String string) {
              BufferedReader br = null;
            try {
                br = new BufferedReader(new FileReader(string));
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

                StringBuffer sb = new StringBuffer();
                String text =null;
                try {
                    while ((text=br.readLine())!= null){
                        sb.append(text);// 将读取出的字符追加到stringbuffer中
                    }
                } catch (IOException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
                try {
                    br.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }  // 关闭读入流
                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) {
                        int i=left.getValue()-right.getValue();
                        if(i==0) {
                            return (right.getKey().compareTo(left.getKey()));
                        }
                        return (left.getValue().compareTo(right.getValue()));
                    }
                };
              
                // 集合默认升序
                Collections.sort(list,comparator);
                int n=list.size();
                
            
                

                for(int i=0;i<list.size();i++){// 由高到低输出
                    System.out.println(list.get(list.size()-i-1).getKey() +":"+list.get(list.size()-i-1).getValue());
                }
        }
    
    //统计最常出现的N个单词出现的
    public void check3(String string) {
          BufferedReader br = null;
        try {
            br = new BufferedReader(new FileReader(string));
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

            StringBuffer sb = new StringBuffer();
            String text =null;
            try {
                while ((text=br.readLine())!= null){
                    sb.append(text);// 将读取出的字符追加到stringbuffer中
                }
            } catch (IOException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
            try {
                br.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }  // 关闭读入流
            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) {
                    int i=left.getValue()-right.getValue();
                    if(i==0) {
                        return (right.getKey().compareTo(left.getKey()));
                    }
                    return (left.getValue().compareTo(right.getValue()));
                }
            };
          
            // 集合默认升序
            Collections.sort(list,comparator);
            int n=list.size();
            System.out.println("请输入你要统计前多少个单词（<"+n+")");
            Scanner scanner=new Scanner(System.in);
            n=scanner.nextInt();

            for(int i=0;i<n;i++){// 由高到低输出
                System.out.println(list.get(list.size()-i-1).getKey() +":"+list.get(list.size()-i-1).getValue());
            }
    }
    
    //递归遍历目录下所有文件
    public void test(String fileDir) {

        List<File> fileList = new ArrayList<File>();

        File file = new File(fileDir);

        File[] files = file.listFiles();// 获取目录下的所有文件或文件夹

        if (files == null) {// 如果目录为空，直接退出

            return;

        }

        // 遍历，目录下的所有文件

        for (File f : files) {

            if (f.isFile()) {
                
                fileList.add(f);

            } else if (f.isDirectory()) {

                System.out.println(f.getAbsolutePath());

                test(f.getAbsolutePath());

            }

        }
        Word word=new Word();
        String str="";
        for (File f1 : fileList) {
            str=fileDir+"\\"+f1.getName();
            System.out.println(str);
            //对文件进行统计
            word.check1(str);
            word.check2(str);
        }
        
    }
    
    //过滤无用词
    public String []nouse()
    {
        BufferedReader br = null;
        try {
            br = new BufferedReader(new FileReader("D:\大二下\软件工程\stop.txt"));
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

            StringBuffer sb = new StringBuffer();
            String text =null;
            try {
                while ((text=br.readLine())!= null){
                    sb.append(text);// 将读取出的字符追加到stringbuffer中
                }
            } catch (IOException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
            try {
                br.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }  // 关闭读入流
            String str = sb.toString().toLowerCase(); // 将stringBuffer转为字符并转换为小写
            String[] words = str.split("[^(a-zA-Z)]+");  // 非单词的字符来分割，得到所有单词
//            for(int i=0;i<words.length;i++) {
//                System.out.print("words["+i+"]:"+words[i]+" ");
//            }
            return words;                   
    }
    //过滤无用词表
    public void check4(String string) {
        BufferedReader br = null;
        try {
            br = new BufferedReader(new FileReader(string));
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
            StringBuffer sb = new StringBuffer();
            String text =null;
            try {
                while ((text=br.readLine())!= null){
                    sb.append(text);// 将读取出的字符追加到stringbuffer中
                }
            } catch (IOException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
            try {
                br.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }  // 关闭读入流
            String str = sb.toString().toLowerCase(); // 将stringBuffer转为字符并转换为小写
            String[] words = str.split("[^(a-zA-Z)]+");  // 非单词的字符来分割，得到所有单词
            
            Map<String ,Integer> map = new HashMap<String, Integer>() ;
            Word word=new Word();
            String []c=word.nouse();    
            for(String word1 :words){
//                System.out.println(word1);
                int j=0;
                for(j=0;j<c.length;j++) {                    
                        if(word1.equals(c[j])) {
                            break;
                        }                                        
                 }                
                if(j==c.length)
                {
                    if(map.get(word1)==null){  // 若不存在说明是第一次，则加入到map,出现次数为1
                        map.put(word1,1);
                    }else{
                        map.put(word1,map.get(word1)+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) {
                        int i=left.getValue()-right.getValue();
                        if(i==0) {
                            return (right.getKey().compareTo(left.getKey()));
                        }
                        return (left.getValue().compareTo(right.getValue()));
                    }
                };
              
                // 集合默认升序
                Collections.sort(list,comparator);
                int n=list.size();
                System.out.println("请输入你要统计前多少个单词（<"+n+")");
                Scanner scanner=new Scanner(System.in);
                n=scanner.nextInt();

                for(int i=0;i<n;i++){// 由高到低输出
                    System.out.println(list.get(list.size()-i-1).getKey() +":"+list.get(list.size()-i-1).getValue());
                }
    }
    
     public static void main(String args[]) {
           Word word=new Word();
           Scanner scanner=new Scanner(System.in);
           System.out.println("请输入要查询的文件目录如（D:\\大二下\\软件工程\\word.txt）");
           String str=scanner.next();
//           System.out.println(str);
//           word.test(str);
           
          int a=0;
           do {
           System.out.println("请选择 ：0:字母出现的频率  1：统计最常出现的单词  2：统计前N个最常出现的单词  3:过滤无用词  其他：结束");
           a=scanner.nextInt();
           if(a==0)
           {
               word.check1(str);
           }
           else if(a==1)
           {
               word.check2(str);
           }
           else if(a==2)
           {
               word.check3(str);
           }
           else if(a==3)
           {
               word.check4(str);
           }
      }while(a!=0||a!=1||a!=2||a!=3);
                     
    }

}