写一个Java应用程序，使用RandomAccessFile流统计Hello.txt中的单词，要求如下：
（1）计算全文中共出现了多少个单词（重复的单词只计算一次）；
（2）统计出有多少个单词只出现了一次；
（3）统计并显示出每个单词出现的频率，并将这些单词按出现频率高低顺序显示在一个TextArea中。

求助，自己试过了，思路也知道，只是实现的时候除了些问题，半天找不到方法解决。劳烦希望大虾们留下代码，因为我想从中学习更多的思路。如果从中看到与我思路相关的问题可以再向你们请教。

1. import java.util.*;
   
2. import java.io.*;
   
3. import java.lang.*;
   
4. import java.awt.Frame;
   
5. import java.awt.TextArea;
   
6. 
   
7. class CountPara extends Frame
   
8. {
   
9.         CountPara(RandomAccessFile randomR)
   
10.         {
    
11.                 Map<String,Integer> map = new HashMap<String, Integer>();
    
12.                
    
13.                 map = countWords(map,randomR);
    
14.        
    
15.                 countOnce(map);
    
16.        
    
17. 
    
18.                 countFreq(map);
    
19.         }
    
20.        
    
21.         public Map countWords(Map<String,Integer> map, RandomAccessFile raf)
    
22.         {
    
23.                 byte[] b = new byte[1];
    
24.                 char[] temp = new char[1];
    
25.                 StringBuffer sb = new StringBuffer();
    
26.                 String s;
    
27.                 char c;
    
28.                
    
29.                 try
    
30.                 {
    
31.                         while(raf.getFilePointer()<raf.length())
    
32.                         {
    
33.                        
    
34.                                
    
35.                                 raf.readFully(b);
    
36.                                 s = new String(b);
    
37.                                
    
38.                                 temp = s.toCharArray();
    
39.                                
    
40.                                 c = temp[0];
    
41.                                
    
42.                                
    
43.                                 //从非空格字符开始数算       
    
44.                                 while(Character.isLetter(c))
    
45.                                 {
    
46.                                         sb.append(new String(temp));
    
47.                                        
    
48.                                         raf.readFully(b);
    
49.                                         s = new String(b);       
    
50.                                         temp = s.toCharArray();
    
51.                                         c = temp[0];
    
52.                                        
    
53.                                 }
    
54.                        
    
55.                                
    
56.                                
    
57.                                 if(map.containsKey(sb.toString()))
    
58.                                 {
    
59.                                         map.put(sb.toString(), 1+map.get(sb.toString()));
    
60.                                 }
    
61.                                        
    
62.                                 else if(sb.length()> 0)
    
63.                                 map.put(sb.toString(), 1);
    
64.                                
    
65.                                 sb.delete(0,sb.length());
    
66.                                
    
67.                                
    
68.                         }
    
69.                        
    
70.                         raf.close();
    
71.                 }
    
72.                
    
73.                
    
74.                 catch (EOFException e)
    
75.                 {
    
76.                         e.printStackTrace();
    
77.                 }
    
78.                 catch (IOException e)
    
79.                 {
    
80.                         e.printStackTrace();
    
81.                 }
    
82.                
    
83.                 System.out.println("全文共出现"+ map.size() +" 个单词。");
    
84.                
    
85.                 return map;
    
86.                
    
87.         }
    
88.        
    
89.         public void countOnce(Map<String, Integer> map)
    
90.         {
    
91.                 Set<String> keySet = map.keySet();
    
92.                
    
93.                 Iterator<String> it = keySet.iterator();
    
94.                
    
95.                 System.out.print("出现一次的单词有： ");
    
96.                
    
97.                 int i = 1;
    
98.                 while(it.hasNext())
    
99.                 {
    
100.                         String s = it.next();
     
101.                        
     
102.                        
     
103.                        
     
104.                         if(map.get(s)==1)
     
105.                         {
     
106.                                 System.out.print(i+"."+s+" ");
     
107.                                 i++;
     
108.                         }
     
109.                 }
     
110.                  
     
111.         }
     
112.        
     
113.        
     
114.         public void countFreq(Map<String,Integer> map)
     
115.         {
     
116.                 //将map.entry转换成arraylist
     
117.                 List<Map.Entry<String,Integer>> list = new ArrayList<
     
118.                 Map.Entry<String,Integer>>(map.entrySet());
     
119.                
     
120.                
     
121.                 Collections.sort(list,new Comparator<Map.Entry<String,Integer>>()
     
122.                 {
     
123.                         public int compare(Map.Entry<String,Integer> o1, Map.Entry<String,Integer> o2)
     
124.                         {
     
125.                                 return o1.getValue().compareTo(o2.getValue());
     
126.                         }
     
127.                        
     
128.                 });
     
129.                
     
130.                
     
131.                
     
132.                 Frame f = new Frame();
     
133.                
     
134.                 TextArea text = new TextArea();
     
135.                 f.setSize(400,300);
     
136.                 f.setLocation(300,200);
     
137. 
     
138.                 text.setRows(50);
     
139.                 text.setColumns(5);
     
140.                
     
141.                 f.add(text);
     
142. 
     
143.                 f.setVisible(true);
     
144. 
     
145.                 for(Map.Entry<String,Integer> mapping:list)
     
146.                 text.append(mapping.getKey()+":"+mapping.getValue()+" ");
     
147.                
     
148.         }
     
149.        
     
150.        
     
151. }       
     
152. 
     
153. public class Three
     
154. {
     
155.        
     
156.         public static void main (String[] args)
     
157.         {
     
158.                 System.out.println("hallelujah!");
     
159.                 System.out.println();
     
160.                
     
161.                 RandomAccessFile raf = null;
     
162.                
     
163.                
     
164.                 try
     
165.                 {
     
166.                         raf = new RandomAccessFile("hello.txt","r");
     
167.                        
     
168.                         CountPara ctp = new CountPara(raf);
     
169.                        
     
170.                         raf.close();
     
171.                 }
     
172.                
     
173.                
     
174.                 catch(EOFException e)
     
175.                 {
     
176.                         e.printStackTrace();
     
177.                 }
     
178.        
     
179.                 catch(IOException e)
     
180.                 {
     
181.                         e.printStackTrace();
     
182.                 }
     
183.                
     
184.                
     
185.         }
     
186. }

复制代码

自己给自己回复吧。 度了好久才一点点度出来。虽然实现了，但是里面的东西还的多消化消化。 望各位大虾予以指教，在个方面要如何改进。:lol

就1个想法和你不一样   我是读取文件里的单词到StringBuilder容器里  然后转成String  再用正则来获取符合单词格式的字符串, 然后把获得的字符串来做其他运算.   其他都差不多一样的

1. // 创建随机文件流,读取文件,返回读到的数据
   
2.         public static String readFile() throws Exception {
   
3.                 RandomAccessFile raf = new RandomAccessFile("d:/hello.txt", "rw");
   
4.                 // 创建一个容器来存储读到的数据
   
5.                 StringBuilder sb = new StringBuilder();
   
6.                 String line = null;
   
7.                 while ((line = raf.readLine()) != null) {
   
8.                         sb.append(line);
   
9.                         sb.append(" ");
   
10.                 }
    
11.                 raf.close();
    
12.                 return sb.toString();
    
13.         }
    
14. 
    
15.         // 将传入的数据进行判断
    
16.         private static Map<String, Integer> splitLine(String line) {
    
17.                 String regex = "\\b[A-Za-z]+\\b";
    
18.                 Pattern p = Pattern.compile(regex);
    
19.                 Matcher matcher = p.matcher(line);
    
20.                 // 创建map集合 将单词传入
    
21.                 Map<String, Integer> map = new TreeMap<String, Integer>();
    
22.                 while (matcher.find()) {
    
23.                         String key = matcher.group();
    
24.                         if (map.containsKey(key)) {
    
25.                                 int num = map.get(key);
    
26.                                 map.put(key, num + 1);
    
27.                         } else {
    
28.                                 map.put(key, 1);
    
29.                         }
    
30.                 }
    
31.                 ta.append("共出现的单词个数有:" + map.size() + "\r\n");
    
32.                 // 获取Set集合
    
33.                 Set<Map.Entry<String, Integer>> set = map.entrySet();
    
34.                 Iterator<Map.Entry<String, Integer>> it = set.iterator();
    
35.                 while (it.hasNext()) {
    
36.                         Entry<String, Integer> str = it.next();
    
37.                         if (str.getValue() == 1) {
    
38.                                 ta.append("单词:" + str.getKey() + ":只出现了一次\r\n");
    
39.                         }
    
40.                 }
    
41.                 return map;
    
42.         }

复制代码

楼主最好说明一下何为“单词”？不带空格的字符串就是单词？don't I'm 这种算一个单词吗？单词之间用一个或多个空格隔开？

fantacyleo 发表于 2014-9-7 00:13
楼主最好说明一下何为“单词”？不带空格的字符串就是单词？don't I'm 这种算一个单词吗？单词之间用一个或 ...

自然是空格 正常想法就是隔开了就算 否则要载入词典才能判断单词?

happy42779 发表于 2014-9-6 09:05
自己给自己回复吧。 度了好久才一点点度出来。虽然实现了，但是里面的东西还的多消化消化。 望各位大虾 ...

能不能加点注释啊？读起来太费劲了

︶ㄣ冰衅ヅ 发表于 2014-9-7 00:04
就1个想法和你不一样   我是读取文件里的单词到StringBuilder容器里  然后转成String  再用正则来获取符合 ...

好的。多谢指教。