1. <p>
   
2. </p><p>import java.io.File;
   
3. import java.io.FileNotFoundException;
   
4. import java.io.FileReader;
   
5. import java.io.FileWriter;
   
6. import java.io.IOException;
   
7. import java.io.Reader;
   
8. import java.io.Writer;
   
9. import java.util.HashMap;
   
10. import java.util.Iterator;
    
11. import java.util.Map;
    
12. import java.util.Map.Entry;
    
13. import java.util.Set;</p><p>public class Test16 {
    
14. /*
    
15.   * 6.
    
16.    题目：把当前文件中的所有文本拷贝，存入一个txt文件，统计每个字符出现的次数并输出，例如：</p><p>        a：  21 次
    
17.         b：  15 次
    
18.         c:： 15 次
    
19.         把：  7 次
    
20.         当：  9 次
    
21.         前：  3 次
    
22.         ，： 30 次
    
23.   */
    
24. public static void main(String[] args) {
    
25.   /*
    
26.    * 调用文件读写的方法，返回一个Map集合
    
27.    * 第一个参数目录名
    
28.    * 第二个参数目标txt文件名
    
29.    */
    
30.   Map<Character,Integer> map = copy("c:\\","copy.txt");
    
31.   
    
32.   /*
    
33.    * 对Map集合进行遍历，并输出
    
34.    */
    
35.   Set<Entry<Character,Integer>>entrySet = map.entrySet();
    
36.   Iterator<Entry<Character, Integer>> it = entrySet.iterator();
    
37.   while(it.hasNext()){
    
38.    Entry<Character,Integer> entry = it.next();
    
39.    System.out.println(entry.getKey()+":"+entry.getValue()+"次");
    
40.   }
    
41. }</p><p> /*
    
42.   * 文件复制
    
43.   */
    
44. private static Map<Character, Integer> copy(String dirname, String filename) {
    
45.   //创建Map
    
46.   Map<Character,Integer> map = new HashMap<Character,Integer>();
    
47.   //创建目录file对象
    
48.   File dir = new File(dirname);
    
49.   //判断是否是目录
    
50.   if(dir.isDirectory()){
    
51.    //创建目标txt文件file对象
    
52.    File file = new File(dirname, filename);
    
53.    try {
    
54.     //创建输出流，因为输出流要输出多个文件的内容，所以在for循环外边
    
55.     Writer out = new FileWriter(file);
    
56.     //获取目录下面的所有文件及文件夹
    
57.     File[ ] files = dir.listFiles();
    
58.     for(int i=0;i<files.length;i++){
    
59.      //判断file为文件而不是文件夹，并且是txt文件
    
60.      if(files[i].isFile()&&files[i].getName().endsWith(".txt")){
    
61.       //关联txt文件，创建输入流
    
62.        Reader in = new FileReader(files[i]);
    
63.        int cbuf = 0;
    
64.        /*
    
65.         * 开始读取文件， cubuf每次读取一个字符对应int型数值，
    
66.         * 文件结尾in.read()返回-1；
    
67.         */
    
68.        while((cbuf=in.read())!=-1){
    
69.         //将每个字符出现的次数，添加到Map集合
    
70.         add(map, cbuf);
    
71.         //效率太低求改进
    
72.         out.write(cbuf);
    
73.        }
    
74.        //刷新缓冲区
    
75.        out.flush();
    
76.        //关闭输入流
    
77.        in.close();
    
78.      }
    
79.     }
    
80.     //所有文件输出完毕，关闭输出流
    
81.     out.close();
    
82.    } catch (Exception e)  {
    
83.     e.printStackTrace();
    
84.    }
    
85.   }
    
86.   return map;
    
87. }
    
88. /*
    
89. * 给Map添加字符出现的次数
    
90. */
    
91. private static void add(Map<Character, Integer> map, int cbuf) {
    
92.   //先获取Map集合该字符出现的次数
    
93.   Integer value = map.get((char)cbuf);
    
94.   //如果为null表明字符第一次出现value=1；
    
95.   if(value==null){
    
96.    value=1;
    
97.   }else{
    
98.    //否则字符出现次数+1
    
99.    value++;
    
100.   }
     
101.   //添加到集合
     
102.   map.put((char) cbuf, value);
     
103. }
     
104. }
     
105. 
     
106. </p>

复制代码

文件读写的时候，是一个字符写一次效率太低，求改进


关于Map的使用见
【技术问题】Map及HashMap的使用-黑马程序员IT技术论坛
http://bbs.itheima.com/forum.php?mod=viewthread&tid=190044&page=1#pid1376424

要读取的是文本文件，可以使用BufferReader，使用这个对象的ReadLine()方法，每次读取一行，然后将读取的字符串转换成字符数组，再存入Map集合中。

用Buffered类包装流

sisel 发表于 2015-4-22 16:40
用Buffered类包装流

但是每次还必须读取一个字符，进行判断啊，怎么办

蓝墨清幽 发表于 2015-4-22 17:09
但是每次还必须读取一个字符，进行判断啊，怎么办

一个个字符判断，这是做这道题不可避免的，这个代价是必须要花的。但是，你一个个字符从文件中读取，效率很低，因为每次读取都要跟操作系统底层打交道。不如一次读一行，再一个个字符判断，效率高多了

妹子你好！楼上的正解啊，用带缓冲的包装类，一行一行的读，写的时候也一行一行的写，效率当然就高的多了，简单示范如下：

1. BufferedReader reader = new BufferedReader(new FileReader(new File("src.txt")));
   
2. String line = reader.readLine();
   
3. for (int i = 0, len = line.length(); i< len; i++) {
   
4.         char c = line.charAt(i);
   
5. }
   
6.                
   
7. BufferedWriter writer = new BufferedWriter(new FileWriter(new File("result.txt")));
   
8. writer.write(line);
   
9. writer.newLine();

复制代码