• 个人作业9 单词统计续


    第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

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

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

    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.text.DecimalFormat;
    import java.util.*;
    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.Map.Entry;
    public class expression {
        public static void word() throws FileNotFoundException {
            File file=new File("D:\piao.txt");                  
            Scanner input=new Scanner(file);
            HashMap<String,Integer> hashMap=new HashMap<String,Integer>();
            while(input.hasNextLine()) {
                String line=input.nextLine();
                String[] lineWords=line.split("\W+");          
                Set<String> wordSet=hashMap.keySet();
                for(int i=0;i<lineWords.length;i++) {
                    
                    if(wordSet.contains(lineWords[i])) {
                        Integer number=hashMap.get(lineWords[i]);
                        number++;
                        hashMap.put(lineWords[i], number);  
                        }
                    else {
                        hashMap.put(lineWords[i], 1);
                    }
                }
            }
            for (String key : hashMap.keySet()) {
                System.out.println(key+"出现:"+hashMap.get(key)+"次");
            }
        }
        
        public static void danci2() throws IOException {
            Scanner input=new Scanner(System.in);
            System.out.println("输入要统计的个数:");
            int n=input.nextInt();
            File file = new File("D:\english.txt");
            FileInputStream fis = new FileInputStream(file);
            InputStreamReader isr = new InputStreamReader(fis);
    
            int thechar;
            StringBuffer sb = new StringBuffer();
            HashMap<String, Integer> wordList = new HashMap<String, Integer>();
            
            while ((thechar = isr.read()) != -1) {
                char letter = (char) thechar;
                if ((letter >= 'a' && letter <= 'z')
                        || (letter >= 'A' && letter <= 'Z')) {
                    sb.append(letter);
                } else if (sb.length() != 0) {
                    String theword = new String(sb);
                    if (wordList.containsKey(theword)) {
                        wordList.put(theword, wordList.get(theword) + 1);
                    } else {
                        wordList.put(theword, 1);
                    }
                    sb.delete(0, sb.length());
                }
            }
            isr.close();
            
            List<Map.Entry<String, Integer>> words = new ArrayList<Map.Entry<String, Integer>>(
                    wordList.entrySet());
            
            Collections.sort(words, new Comparator<Map.Entry<String, Integer>>() {
    
                @Override
                public int compare(Entry<String, Integer> o1,
                        Entry<String, Integer> o2) {
                    return -(o1.getValue() - o2.getValue());
                }
            });
            System.out.println("读取的文件中出现频率最多的"+n+"个单词是:");
            int i = 0;
            for (Map.Entry<String, Integer> node : words) {
                if (i < n) {
                    System.out.println(node.getKey() + " : " + node.getValue());
                } else {
                    break;
                }
                i++;
            }
        }
        public static void zimu() {
            DecimalFormat df = new DecimalFormat("0.00%");
            try {
                char shu[] = new char[100000];
                char zimu[] = new char[52];
                int j=0;
                int count[]=new int[52];
                String pathname="D:\english.txt";
                File filename=new File(pathname);
                InputStreamReader reader=new InputStreamReader(new FileInputStream(filename));
                BufferedReader br=new BufferedReader(reader);
                String line[]=new String[100000];;    
                for(int i=0;i<line.length;i++){
                line[i]=br.readLine();    
                }
                br.close();
                int k=0;
                while(line[k]!=null) {
                     for(int i=0;i<line[k].length();i++) {                                
                          shu[j]=line[k].charAt(i);
                          j++;                     
                     }
                     k++;
                }            
                for(int i=0;i<shu.length;i++) {
                     switch(shu[i]) {
                     case 'a':zimu[0]='a';count[0]++;break;
                     case 'b':zimu[1]='b';count[1]++;break;
                     case 'c':zimu[2]='c';count[2]++;break;
                     case 'd':zimu[3]='d';count[3]++;break;
                     case 'e':zimu[4]='e';count[4]++;break;
                     case 'f':zimu[5]='f';count[5]++;break;
                     case 'g':zimu[6]='g';count[6]++;break;
                     case 'h':zimu[7]='h';count[7]++;break;
                     case 'i':zimu[8]='i';count[8]++;break;
                     case 'j':zimu[9]='j';count[9]++;break;
                     case 'k':zimu[10]='k';count[10]++;break;
                     case 'l':zimu[11]='l';count[11]++;break;
                     case 'm':zimu[12]='m';count[12]++;break;
                     case 'n':zimu[13]='n';count[13]++;break;
                     case 'o':zimu[14]='o';count[14]++;break;
                     case 'p':zimu[15]='p';count[15]++;break;
                     case 'q':zimu[16]='q';count[16]++;break;
                     case 'r':zimu[17]='r';count[17]++;break;
                     case 's':zimu[18]='s';count[18]++;break;
                     case 't':zimu[19]='t';count[19]++;break;
                     case 'u':zimu[20]='u';count[20]++;break;
                     case 'v':zimu[21]='v';count[21]++;break;
                     case 'w':zimu[22]='w';count[22]++;break;
                     case 'x':zimu[23]='x';count[23]++;break;
                     case 'y':zimu[24]='y';count[24]++;break;
                     case 'z':zimu[25]='z';count[25]++;break;
                     case 'A':zimu[26]='A';count[26]++;break;
                     case 'B':zimu[27]='B';count[27]++;break;
                     case 'C':zimu[28]='C';count[28]++;break;
                     case 'D':zimu[29]='D';count[29]++;break;
                     case 'E':zimu[30]='E';count[30]++;break;
                     case 'F':zimu[31]='F';count[31]++;break;
                     case 'G':zimu[32]='G';count[32]++;break;
                     case 'H':zimu[33]='H';count[33]++;break;
                     case 'I':zimu[34]='I';count[34]++;break;
                     case 'J':zimu[35]='G';count[35]++;break;
                     case 'K':zimu[36]='K';count[36]++;break;
                     case 'L':zimu[37]='L';count[37]++;break;
                     case 'M':zimu[38]='M';count[38]++;break;
                     case 'N':zimu[39]='N';count[39]++;break;
                     case 'O':zimu[40]='O';count[40]++;break;
                     case 'P':zimu[41]='P';count[41]++;break;
                     case 'Q':zimu[42]='Q';count[42]++;break;
                     case 'R':zimu[43]='R';count[43]++;break;
                     case 'S':zimu[44]='S';count[44]++;break;
                     case 'T':zimu[45]='T';count[45]++;break;
                     case 'U':zimu[46]='U';count[46]++;break;
                     case 'V':zimu[47]='V';count[47]++;break;
                     case 'W':zimu[48]='W';count[48]++;break;
                     case 'X':zimu[49]='X';count[49]++;break;
                     case 'Y':zimu[50]='Y';count[50]++;break;
                     case 'Z':zimu[51]='Z';count[51]++;
                     }
                }    
                int ci=0;
                int sum=0;
                System.out.println("短文中各字母出现情况统计如下:");
                int a[]=new int[26];
                for(int i=0;i<26;i++)
                {
                    
                    a[i]=count[i]+count[i+26];                
                    int max=a[0];                
                    if(count[i]!=0) {                    
                        ci++;
                        sum+=count[i];             
                        System.out.println(ci+".字母"+zimu[i]+"或字母"+zimu[i+26]+"的出现次数是:"+a[i]);
                        }
                }
                for (int i = 0; i < 26; i++) {
                    System.out.println(zimu[i]+"或字母"+zimu[i+26]+"出现的百分比为:"+df.format(count[i]*1.0/sum));
                }
                System.out.println("字母共计:"+sum+"个");
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
       public static  void main(String[] args) throws IOException   {
        
        Scanner shuru=new Scanner(System.in);
        int a=1;
        
        while(a!=0) {
            System.out.println("功能:");
            System.out.println("1.统计字母频率");
            System.out.println("2.统计不重复单词");
            System.out.println("3.统计出现次数前n个单词");
            System.out.println("0.退出");
            System.out.println("请选择:");
            a=shuru.nextInt();
            switch(a)
            {
            case 1:zimu();break;
            case 2:danci();break;
            case 3:danci2();break;
            case 0:a=0;break;
            default:a=0;break;
            }
        }
    }
    }

  • 相关阅读:
    [51NOD]大数加法(模拟)
    LCS记录路径
    BISTU-(1)-4-17-2016
    [CF580B]Kefa and Company(滑动窗口)
    [CF660C]Hard Process(尺取法)
    [POJ3061]Subsequence(二分,前缀和)
    [HDOJ2602]Bone Collector(01背包)
    [HDOJ1171]Big Event in HDU(01背包)
    [HDOJ2512]一卡通大冒险(DP)
    hdu 1269 迷宫城堡 最简单的联通图题 kosaraju缩点算法
  • 原文地址:https://www.cnblogs.com/jbwen/p/11071764.html
Copyright © 2020-2023  润新知