课上练习—单词统计

 功能要求:

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

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

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

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

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

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

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

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

第3步:  想看看常用的短语是什么, 怎么办呢?  

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

 

  hello world   //这是一个短语

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

 

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

第4步:把动词形态都统一之后再计

发表一篇博客文章讲述设计思想,出现的问题,可能的解决方案(多选)、源代码、结果截图、总结。(来源于课堂ppt)

  1 package text;
  2 
  3 import java.io.BufferedReader;
  4 import java.io.File;
  5 import java.io.FileOutputStream;
  6 import java.io.FileReader;
  7 import java.io.IOException;
  8 import java.util.*;
  9 
 10 public class wordcontinue {
 11     public static void main(String [] args) throws IOException  {
 12         wordcontinue xm=new wordcontinue();
 13         wordcontinue.meau();
 14         
 15     }
 16     
 17     public static  void meau() throws IOException
 18     {
 19          System.out.println("*1.查找字母*");
 20          System.out.println("*2.查找单词 *");
 21          System.out.println("*3.按单词数查找*");
 22          Scanner sc=new Scanner (System.in);
 23          int n=sc.nextInt();//输入数字
 24          
 25          switch(n)
 26          {
 27              case 1:zimu(new File("E:\\eclipse\\p.txt"));break;
 28              case 2:danci(new File("E:\\eclipse\\p.txt"));break;
 29              case 3:danci2(new File("E:\\eclipse\\p.txt"));break;
 30          }
 31          
 32         sc.close();
 33 
 34     }
 35     
 36     
 37      public static void zimu(File file){
 38             double sum=0.0;
 39             BufferedReader bfr = null;   //定义字符读取(缓冲)流
 40             try{
 41                 bfr = new BufferedReader(new FileReader(file));
 42                 String value = null; 
 43                 String newValue = "";    
 44                 while((value = bfr.readLine())!=null){    //开始读取文件中的字符
 45                     newValue = newValue+value;    //存入newValue变量中
 46                 }
 47                 char[] ch = newValue.toCharArray();//把newValue变成字符数组
 48                 TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>(Collections.reverseOrder());
 49                 for(int x = 0;x<ch.length;x++){   
 50                     char c = ch[x];
 51                     if((c>=65&&c<=90)||(c>=97&&c<=122)) {
 52                         sum++;
 53                         if(tm.containsKey(c)){  //如果TreeMap(tm)中有该键,则取出该键中的值,也就是出现的次数
 54                             int conut = tm.get(c);
 55                             tm.put(c,conut+1);  //存入把新值存入tm集合中,如果键相同的话, 新键会替换老键,值也随着变化了
 56                         }
 57                         else{
 58                             tm.put(c, 1);  //如果没有出现该键就说明是第一次出现,然后就存入1次
 59                         }
 60                     }
 61                 }
 62                 //下面的是取出TreeMap(tm)中的键和值
 63                 Set<Map.Entry<Character, Integer>> set = tm.entrySet();
 64                 Iterator<Map.Entry<Character, Integer>> iter = set.iterator();
 65                 while(iter.hasNext()){
 66                     Map.Entry<Character, Integer> map = iter.next();
 67                     char k = map.getKey();
 68                     int v = map.getValue();
 69                    // double baifenbi=0.0;
 70                    // baifenbi=v/sum;
 71                    // System.out.println(baifenbi);
 72                     System.out.println(k+"("+v+")  ");
 73                 }
 74                 meau();
 75             }
 76             catch(IOException e){
 77                 System.out.println("文件读取错误");
 78             }
 79             finally{
 80                 try{
 81                     if(bfr!=null)
 82                         bfr.close();
 83                 }
 84                 catch(IOException e){
 85                     System.out.println("文件关闭错误");
 86                 }
 87             }
 88         }
 89      
 90      
 91      
 92      public static void danci(File file) throws IOException {
 93 
 94             BufferedReader br = null;
 95             br = new BufferedReader(new FileReader(file));
 96             StringBuffer sb = new StringBuffer();
 97             String text =null;
 98             while ((text=br.readLine())!= null){
 99                 sb.append(text);// 将读取出的字符追加到stringbuffer中
100             }
101             br.close();  // 关闭读入流
102 
103             String str = sb.toString().toLowerCase(); // 将stringBuffer转为字符并转换为小写
104             String[] words = str.split("[^(a-zA-Z)]+");  // 非单词的字符来分割,得到所有单词
105             Map<String ,Integer> map = new HashMap<String, Integer>() ;
106 
107             for(String word :words){
108                 if(map.get(word)==null){  // 若不存在说明是第一次,则加入到map,出现次数为1
109                     map.put(word,1);
110                 }else{
111                     map.put(word,map.get(word)+1);  // 若存在,次数累加1
112                 }
113             }
114 
115             // 排序
116             List<Map.Entry<String ,Integer>> list = new ArrayList<Map.Entry<String,Integer>>(map.entrySet());
117 
118             Comparator<Map.Entry<String,Integer>> comparator = new Comparator<Map.Entry<String, Integer>>() {
119                 public int compare(Map.Entry<String, Integer> left, Map.Entry<String, Integer> right) {
120                     return (left.getValue().compareTo(right.getValue()));
121                 }
122             };
123             // 集合默认升序升序
124             Collections.sort(list,comparator);
125             
126             
127             float sum=0;
128             float a=0;
129             
130      
131             for(int i=0;i<list.size();i++){// 由高到低输出
132                 if(list.get(list.size()-i-1).getKey().equals("the")||list.get(list.size()-i-1).getKey().equals("and"))
133                 {
134                     
135                 }
136                 else
137                 {
138                     a=list.get(list.size()-i-1).getValue();  
139                     sum=sum+a;        //求总字母数
140                     System.out.println(list.get(list.size()-i-1).getKey() +":"+list.get(list.size()-i-1).getValue());
141                 }
142             }
143             System.out.println("单词总数为:"+sum);
144             meau();
145         }
146 
147      
148      public static void danci2(File file) throws IOException {
149 
150             BufferedReader br = null;
151             br = new BufferedReader(new FileReader(file));
152             StringBuffer sb = new StringBuffer();
153             String text =null;
154             while ((text=br.readLine())!= null){
155                 sb.append(text);// 将读取出的字符追加到stringbuffer中
156             }
157             br.close();  // 关闭读入流
158 
159             String str = sb.toString().toLowerCase(); // 将stringBuffer转为字符并转换为小写
160             String[] words = str.split("[^(a-zA-Z)]+");  // 非单词的字符来分割,得到所有单词
161             Map<String ,Integer> map = new HashMap<String, Integer>() ;
162 
163             for(String word :words){
164                 if(map.get(word)==null){  // 若不存在说明是第一次,则加入到map,出现次数为1
165                     map.put(word,1);
166                 }else{
167                     map.put(word,map.get(word)+1);  // 若存在,次数累加1
168                 }
169             }
170 
171             // 排序
172             List<Map.Entry<String ,Integer>> list = new ArrayList<Map.Entry<String,Integer>>(map.entrySet());
173 
174             Comparator<Map.Entry<String,Integer>> comparator = new Comparator<Map.Entry<String, Integer>>() {
175                 public int compare(Map.Entry<String, Integer> left, Map.Entry<String, Integer> right) {
176                     return (left.getValue().compareTo(right.getValue()));
177                 }
178             };
179             // 集合默认升序升序
180             Collections.sort(list,comparator);
181             
182             BufferedReader br1 = new BufferedReader(new FileReader("E:\\eclipse\\stopwords.txt"));
183 
184             StringBuffer sb1 = new StringBuffer();
185             String text1 =null;
186             while ((text1=br1.readLine())!= null){
187                 sb1.append(text1);// 将读取出的字符追加到stringbuffer中
188             }
189             br1.close();  // 关闭读入流
190 
191             String str1 = sb1.toString().toLowerCase(); // 将stringBuffer转为字符并转换为小写
192             String[] words1 = str1.split("[^(a-zA-Z)]+");  // 非单词的字符来分割,得到所有单词
193             Map<String ,Integer> map1 = new HashMap<String, Integer>() ;
194 
195             for(String word :words1){
196                 if(map1.get(word)==null){  // 若不存在说明是第一次,则加入到map,出现次数为1
197                     map1.put(word,1);
198                 }else{
199                     map1.put(word,map1.get(word)+1);  // 若存在,次数累加1
200                 }
201             }
202           
203             // 排序
204             List<Map.Entry<String ,Integer>> list1 = new ArrayList<Map.Entry<String,Integer>>(map1.entrySet());
205 
206             Comparator<Map.Entry<String,Integer>> comparator1 = new Comparator<Map.Entry<String, Integer>>() {
207                 public int compare(Map.Entry<String, Integer> left, Map.Entry<String, Integer> right) {
208                     return (left.getValue().compareTo(right.getValue()));
209                 }
210             };
211             // 集合默认升序升序
212            
213             Collections.sort(list1,comparator1);
214             
215 
216             
217             
218             
219             
220             float sum=0;
221             float a=0;
222             System.out.printf("请输入单词数");
223             Scanner sc=new Scanner (System.in);
224              int num=sc.nextInt();//输入数字
225 
226              
227             for(int i=0;i<num;i++){// 由高到低输出
228             int b=0;
229                 for(int v=0;v<list1.size();v++) {
230                     if(list1.get(list1.size()-v-1).getKey().equals(list.get(list.size()-i-1).getKey())) {
231                         System.out.println(list.get(list.size()-i-1).getKey()+"单词为无用词汇");
232                         b=1;
233                         break;
234                     }
235                 }
236                 if(b==1) {
237                     
238                 }else {
239                     a=list.get(list.size()-i-1).getValue();  
240                     sum=sum+a;        //求总字母数
241                     System.out.println(list.get(list.size()-i-1).getKey() +":"+list.get(list.size()-i-1).getValue());
242                     FileOutputStream fileOutputStream = null;
243                     File file1 = new File("E:\\eclipse\\output.txt");
244                     if(!file.exists()){
245                         file.createNewFile();
246                     }
247                     fileOutputStream = new FileOutputStream(file1);
248                     fileOutputStream.write(list.get(list.size()-i-1).getKey().getBytes("gbk"));
249                     fileOutputStream.flush();
250                     fileOutputStream.close();
251                 }
252                     
253                 
254             }
255             System.out.println("单词总数为:"+sum);
256             meau();
257         }
258 
259 }

运行结果:

//p.txt

 //stopwords.txt

//output.txt

 

posted on 2019-05-11 18:05  小朝~~~  阅读(193)  评论(0编辑  收藏  举报

导航