zoukankan      html  css  js  c++  java
  • 单词统计-续

    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

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

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

    【实验源码】

    1. static void Daunyu()throws IOException
      {
          Word word=new Word();                                      //单词的链头
          Word lian,xin;                                             
          String str="";
          FileReader f=new FileReader("E:\578095023\FileRecv\软件工程\课堂测试\读入txt\飘英文版.txt");                //读取英文文件 
          char[] c=new char[1];                                 //每次读取一个字母
          int b=0;
          boolean exist=false;                              //判断单词是否存在于  word 链中
          Word word1=new Word();
          Word lian1,xin1;
          String str1="";
          FileReader f1=new FileReader("E:\578095023\FileRecv\软件工程\课堂测试\读入txt\stopwords.txt");   
          char[] c1=new char[1];
          int b1=0;
          boolean exist1=false;
          //stopwords文本
        while((b1=f1.read(c1))!=-1)                              //每次读取一个字母直到最后
           {
               //如果字符为  换行、空格、单引号、双引号、逗号、句号  则为一个单词的结束及另一个单词的开始
               if(String.valueOf(c1).equals("
      ")||String.valueOf(c1).equals("
      ")||String.valueOf(c1).equals(" ")||String.valueOf(c1).equals(",")||String.valueOf(c1).equals(".")||String.valueOf(c1).equals(""")||String.valueOf(c1).equals("'"))
               {
                
                   lian1=word1;
                   while(lian1!=null)            
                   {
                    if(lian1.value.equalsIgnoreCase(str1))           //如果单词在单词链中存在,则单词个数++
                       {
                           lian1.geshu++;exist1=true;break;
                       }
                       else
                       {
                           lian1=lian1.next;
                       }
                       
                   }
                   if(exist1==false)                        //如果不存在,则在单词链中添加
                   {
                       xin1=new Word(str1,1);
                       xin1.next=word1.next;
                       word1.next=xin1;
                       str1="";
                   }
                   else
                   {
                       exist1=false;
                       str1="";
                   }
               }
               else                                      //单词
               {
                   str1+=String.valueOf(c1);
               }
           }                            //判断单词是否存在于  word 链中
           while((b=f.read(c))!=-1)                              //每次读取一个字母直到最后
           {
            
            
            
               //如果字符为  换行、空格、单引号、双引号、逗号、句号  则为一个单词的结束及另一个单词的开始
               if(String.valueOf(c).equals("‘")||String.valueOf(c).equals("’")||String.valueOf(c).equals("”")||String.valueOf(c).equals("“")||String.valueOf(c).equals("
      ")||String.valueOf(c).equals("
      ")||String.valueOf(c).equals(",")||String.valueOf(c).equals(".")||String.valueOf(c).equals(""")||String.valueOf(c).equals("'"))
               {
                
                   lian=word;
                   while(lian!=null)            
                   {
                    if(lian.value.equalsIgnoreCase(str))           //如果单词在单词链中存在,则单词个数++
                       {
                           lian.geshu++;exist=true;break;
                       }
                      else
                         {
                          int l1=0,l2=0;
                          while(true)
                       {
                        xin1=new Word("",0);
                              lian1=word1.next;
                              //找到单词链中个数最多的
                              while(lian1!=null)
                              {
                                 if(str.equals(lian1.value))
                                 {
                                  l1=1;
                                 }
                                  lian1=lian1.next;
                                  
                              }       
                        if(lian1==null)
                        {
                         break;
                        }
                       }
                           if(str.startsWith(" "))
                           {
                            str=str.substring(1);
       
                           }
      
                          if(l1==1||!str.contains(" "))
                          {
                           break;
                          }
                             lian=lian.next;
                         }
                       
                   }
                   if(exist==false)                        //如果不存在,则在单词链中添加
                   {
                       xin=new Word(str,1);
                       xin.next=word.next;
                       word.next=xin;
                       str="";
                   }
                   else
                   {
                       exist=false;
                       str="";
                   }
               }
               else                                      //单词
               {
                   str+=String.valueOf(c);
               }
           }
           
           
           //   循环10次
           System.out.println("请输入您想查询的前几个出现此处最多的单词");
        Scanner scan=new Scanner(System.in);
        int N=scan.nextInt();
           for(int i=1;i<=N;i++)                   
           {
               xin=new Word("",0);
               lian=word.next;
               //找到单词链中个数最多的
               while(lian!=null)
               {
                   if(lian.geshu>xin.geshu)
                   {
                       xin=lian;
                   }
                   lian=lian.next;
               }
               //输出单词链中个数最多的
               System.out.println("第"+i+"个 :"+xin.value+"个数:"+xin.geshu);
               lian=word;
               //删除单词链中单词个数最多的
               while(lian.next!=null)
               {
                   if(lian.next.value.equalsIgnoreCase(xin.value))
                   {
                       lian.next=lian.next.next;
                       break;
                   }
                   lian=lian.next;
               }
           }
       }
  • 相关阅读:
    转载:javaweb学习总结(八)——HttpServletResponse对象(二)
    转载:javaweb学习总结(七)——HttpServletResponse对象(一)
    转载:javaweb学习总结(六)——Servlet开发(二)
    转载:javaweb学习总结(五)——Servlet开发(一)
    转载:javaweb学习总结(四)——Http协议
    蓝桥杯 答题分数
    Saruman's Army (POJ 3069)
    Best Cow Line (POJ 3217)
    区间调度问题
    硬币问题
  • 原文地址:https://www.cnblogs.com/zql98/p/10994923.html
Copyright © 2011-2022 走看看