一种快速统计文档的中文字符的JAVA代码

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

现在有个需求，我要统计一个文档集合中每一个中文字符出现的个数，规模在1000份，每一份文档的大小在20KB左右，我用java写了一段代码。
个人感触：程序=数据结构+算法。好的数据结构和算法对于程序的性能是不言而喻的。
其余类见附件

1. import java.io.BufferedReader;
   
2. import java.io.File;
   
3. import java.io.FileNotFoundException;
   
4. import java.io.FileOutputStream;
   
5. import java.io.FileReader;
   
6. import java.io.IOException;
   
7. import java.io.ObjectOutputStream;
   
8. import java.io.OutputStream;
   
9. import java.io.Reader;
   
10. import java.util.HashMap;
    
11. import java.util.Map;
    
12. /**
    
13. * 说明：当实现自定义容器时，千万不要忘记在进行读写操作时，使用serializable接口
    
14. * */
    
15. public class WordCount {
    
16.         public static void writeMap(File Origin,File newFile){
    
17.                 Map<String,Integer> map=getWordCount(Origin);
    
18.                 ObjectOutputStream oos=null;
    
19.                 try {
    
20.                         OutputStream out=new FileOutputStream(newFile);
    
21.                         oos=new ObjectOutputStream(out);
    
22.                         oos.writeObject(map);
    
23.                 } catch (FileNotFoundException e) {       
    
24.                         e.printStackTrace();
    
25.                 } catch (IOException e) {
    
26.                        
    
27.                         e.printStackTrace();
    
28.                 }finally{
    
29.                         try {
    
30.                                 oos.close();
    
31.                         } catch (IOException e) {
    
32.                                 e.printStackTrace();
    
33.                         }
    
34.                 }
    
35.                 System.out.println(map.toString());
    
36.         }
    
37.         public static Map<String,Integer> getWordCount(File f){
    
38.                 Reader reader=null;
    
39.                 BufferedReader bf=null;
    
40.                 String line=null;
    
41.                 try {
    
42.                         reader = new FileReader(f);
    
43.                         bf=new BufferedReader(reader);
    
44.                         line=bf.readLine();
    
45.                 } catch (FileNotFoundException e) {
    
46.                         e.printStackTrace();
    
47.                 } catch (IOException e) {
    
48.                         e.printStackTrace();
    
49.                 }finally{
    
50.                         try {
    
51.                                 bf.close();
    
52.                                 reader.close();
    
53.                         } catch (IOException e) {
    
54.                                 e.printStackTrace();
    
55.                         }
    
56.                 }
    
57.                 MapWords mapword=new MapWords();
    
58.                 for(int i=0;i<line.length();i++){
    
59.                         String m=line.substring(i, i+1);
    
60.                         Nodes node=new Nodes(m);
    
61.                         mapword.addNewNodeElement(m, f.getName(), i);
    
62.                 }
    
63.                 Map<String,Integer> map=new HashMap<String,Integer>();
    
64.                 for(int i=0;i<mapword.getMapSize()-1;i++){
    
65.                         String Keyword=mapword.toGetKeyByIndex(i+1);
    
66.                         Nodes node=mapword.getNode(Keyword);
    
67.                         map.put(Keyword,node.getWordCountAll());
    
68.                 }
    
69.                 return map;
    
70.         }
    
71.         public static void writerMapIndex(File Origin,File newFile){
    
72.                 Reader reader=null;
    
73.                 BufferedReader bf=null;
    
74.                 String line=null;
    
75.                 try {
    
76.                         reader = new FileReader(Origin);
    
77.                         bf=new BufferedReader(reader);
    
78.                         line=bf.readLine();
    
79.                 } catch (FileNotFoundException e) {
    
80.                         e.printStackTrace();
    
81.                 } catch (IOException e) {
    
82.                         e.printStackTrace();
    
83.                 }finally{
    
84.                         try {
    
85.                                 bf.close();
    
86.                                 reader.close();
    
87.                         } catch (IOException e) {
    
88.                                 e.printStackTrace();
    
89.                         }
    
90.                 }
    
91.                 MapWords mapword=new MapWords();
    
92. 
    
93.                 for(int i=0;i<line.length();i++){
    
94.                         String m=line.substring(i, i+1);
    
95. //                        Nodes node=new Nodes(m);
    
96. //                        List<String> list=new ArrayList<String>();
    
97. //                        list=node.getDocNameAll();
    
98. //                        seriMapArray[i]=new seriMap(m,list);
    
99.                         mapword.addNewNodeElement(m, Origin.getName(), i);
    
100.                 }
     
101. 
     
102. //                Set<Nodes> setArray=mapword.toGetValueSet();
     
103. //                Nodes nodeArray[]=new Nodes[setArray.size()];
     
104. //                Nodes node[]=setArray.toArray(nodeArray);
     
105. //                System.out.println("node[].length="+node.length);
     
106. //                System.out.println("Arrays.toString(node)="+Arrays.toString(node));
     
107. //                for(int i=1;i<node.length;i++){
     
108. //                        System.out.println("i="+i);
     
109. //                        seriMapArray[i-1]=new seriMap(node[i].getKeyword(),node[i].getDocNameAll());
     
110. //                }
     
111. //               
     
112.                 ObjectOutputStream oos=null;
     
113.                 try {
     
114.                         OutputStream out=new FileOutputStream(newFile);
     
115.                         oos=new ObjectOutputStream(out);
     
116.                         oos.writeObject(mapword);
     
117.                 } catch (FileNotFoundException e) {       
     
118.                         e.printStackTrace();
     
119.                 } catch (IOException e) {
     
120.                        
     
121.                         e.printStackTrace();
     
122.                 }finally{
     
123.                         try {
     
124.                                 oos.close();
     
125.                         } catch (IOException e) {
     
126.                                 e.printStackTrace();
     
127.                         }
     
128.                 }
     
129.         }
     
130.         public static void writerMapIndex(File[] Origin,File newFile){
     
131.                 MapWords mapword=new MapWords();
     
132.                 for(int n=0;n<Origin.length;n++){
     
133.                         Reader reader=null;
     
134.                         BufferedReader bf=null;
     
135.                         String line=null;
     
136.                         try {
     
137.                                 reader = new FileReader(Origin[n]);
     
138.                                 bf=new BufferedReader(reader);
     
139.                                 line=bf.readLine();
     
140.                                 for(int i=0;i<line.length();i++){
     
141.                                         String m=line.substring(i, i+1);
     
142.                                         mapword.addNewNodeElement(m, Origin[n].getName(), i);
     
143.                                 }       
     
144.                         } catch (FileNotFoundException e) {
     
145.                                 e.printStackTrace();
     
146.                         } catch (IOException e) {
     
147.                                 e.printStackTrace();
     
148.                         }finally{
     
149.                                 try {
     
150.                                         bf.close();
     
151.                                         reader.close();
     
152.                                 } catch (IOException e) {
     
153.                                         e.printStackTrace();
     
154.                                 }
     
155.                         }
     
156.                 }
     
157.                 ObjectOutputStream oos=null;
     
158.                 try {
     
159.                         OutputStream out=new FileOutputStream(newFile);
     
160.                         oos=new ObjectOutputStream(out);
     
161.                         oos.writeObject(mapword);
     
162.                 } catch (FileNotFoundException e) {       
     
163.                         e.printStackTrace();
     
164.                 } catch (IOException e) {
     
165.                        
     
166.                         e.printStackTrace();
     
167.                 }finally{
     
168.                         try {
     
169.                                 oos.close();
     
170.                         } catch (IOException e) {
     
171.                                 e.printStackTrace();
     
172.                         }
     
173.                 }
     
174.         }
     
175.         public static void FileProcessAll(File[] files){
     
176.                 File[] newFile=new File[files.length];
     
177.                 String uri=files[0].getAbsolutePath();
     
178.                 int m=uri.lastIndexOf(File.separator)+1;
     
179.                 String newUrl=uri.substring(0, m);
     
180.                 File f=new File(newUrl+"temp");
     
181.                 if(f.exists()==false){
     
182.                         f.mkdir();
     
183.                 }
     
184.                 for(int i=0;i<files.length;i++){
     
185.                         newFile[i]=new File(f.getAbsoluteFile()+File.separator+files[i].getName());
     
186.                 }
     
187.                 for(int i=0;i<files.length;i++){
     
188.                         FileProcess.processFile(files[i], newFile[i]);
     
189.                 }
     
190.         }
     
191.         public static void getWordCountAll(File[] files,File newFile){
     
192.                
     
193.                 MapWords mapword=new MapWords();
     
194.                
     
195.                 for(int j=0;j<files.length;j++){
     
196.                         Reader reader=null;
     
197.                         BufferedReader bf=null;
     
198.                         String line=null;
     
199.                         try {
     
200.                                 reader = new FileReader(files[j]);
     
201.                                 bf=new BufferedReader(reader);
     
202.                                 line=bf.readLine();
     
203.                                 for(int i=0;i<line.length();i++){
     
204.                                         String m=line.substring(i, i+1);
     
205.                                         Nodes node=new Nodes(m);
     
206.                                         mapword.addNewNodeElement(m, files[j].getName(), i);
     
207.                                 }
     
208.                         } catch (FileNotFoundException e) {
     
209.                                 e.printStackTrace();
     
210.                         } catch (IOException e) {
     
211.                                 e.printStackTrace();
     
212.                         }finally{
     
213.                                 try {
     
214.                                         bf.close();
     
215.                                         reader.close();
     
216.                                 } catch (IOException e) {
     
217.                                         e.printStackTrace();
     
218.                                 }
     
219.                         }
     
220.                 }
     
221.                 Map<String,Integer> map=new HashMap<String,Integer>();
     
222.                 for(int i=0;i<mapword.getMapSize()-1;i++){
     
223.                         String Keyword=mapword.toGetKeyByIndex(i+1);
     
224.                         Nodes node=mapword.getNode(Keyword);
     
225.                         map.put(Keyword,node.getWordCountAll());
     
226.                 }
     
227.                 ObjectOutputStream oos=null;
     
228.                 try {
     
229.                         OutputStream out=new FileOutputStream(newFile);
     
230.                         oos=new ObjectOutputStream(out);
     
231.                         oos.writeObject(map);
     
232.                 } catch (FileNotFoundException e) {       
     
233.                         e.printStackTrace();
     
234.                 } catch (IOException e) {
     
235.                        
     
236.                         e.printStackTrace();
     
237.                 }finally{
     
238.                         try {
     
239.                                 oos.close();
     
240.                         } catch (IOException e) {
     
241.                                 e.printStackTrace();
     
242.                         }
     
243.                 }
     
244.                 System.out.println(map.toString());
     
245.                 System.out.println(map.size());
     
246.         }
     
247. }

复制代码

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0 收藏0 回帖

关键词：Java jav exception tostring outputs import 中文 JAVA java 统计