Java nio 学习笔记(四) 淘宝2012校招技术笔试题

实现五:统计一个单词可重复的英文文件(假设4G)中每个单词出现的次数,把结果按照英文排序放入一个文件中。并能够检索特定单词的出现次数。由于文件过大,不重复单词总数有限,需要考虑到执行速度和内存使用情况。(淘宝笔试技术题)

[java]  view plain copy
  1. import java.io.File;  
  2. import java.io.FileNotFoundException;  
  3. import java.io.FileOutputStream;  
  4. import java.io.IOException;  
  5. import java.io.RandomAccessFile;  
  6. import java.nio.ByteBuffer;  
  7. import java.nio.MappedByteBuffer;  
  8. import java.nio.channels.FileChannel;  
  9. import java.nio.channels.FileLock;  
  10. import java.nio.charset.Charset;  
  11. import java.util.HashMap;  
  12. import java.util.Map;  
  13. import java.util.StringTokenizer;  
  14. import java.util.TreeMap;  
  15.   
  16. public class TestCountWords {  
  17.     public static void main(String[] args) {  
  18.         File wf = new File("words.txt");  
  19.         final CountWords cw1 = new CountWords(wf, 0, wf.length()/2);  
  20.         final CountWords cw2 = new CountWords(wf, wf.length()/2, wf.length());  
  21.         final Thread t1 = new Thread(cw1);  
  22.         final Thread t2 = new Thread(cw2);  
  23.         //开辟两个线程分别处理文件的不同片段  
  24.         t1.start();  
  25.         t2.start();  
  26.         Thread t = new Thread() {  
  27.             public void run() {  
  28.                 while(true) {  
  29.                     //两个线程均运行结束  
  30.                     if(Thread.State.TERMINATED==t1.getState() && Thread.State.TERMINATED==t2.getState()) {  
  31.                         //获取各自处理的结果  
  32.                         HashMap<String, Integer> hMap1 = cw1.getResult();  
  33.                         HashMap<String, Integer> hMap2 = cw2.getResult();  
  34.                         //使用TreeMap保证结果有序  
  35.                         TreeMap<String, Integer> tMap = new TreeMap<String, Integer>();  
  36.                         //对不同线程处理的结果进行整合  
  37.                         tMap.putAll(hMap1);  
  38.                         tMap.putAll(hMap2);  
  39.                         //打印输出,查看结果  
  40.                         for(Map.Entry<String,Integer> entry : tMap.entrySet()) {  
  41.                             String key = entry.getKey();    
  42.                             int value = entry.getValue();    
  43.                             System.out.println(key+":\t"+value);    
  44.                         }  
  45.                         //将结果保存到文件中  
  46.                         mapToFile(tMap, new File("result.txt"));  
  47.                     }  
  48.                     return;  
  49.                 }  
  50.             }  
  51.         };  
  52.         t.start();  
  53.     }  
  54.     //将结果按照 "单词:次数" 格式存在文件中  
  55.     private static void mapToFile(Map<String, Integer> src, File dst) {  
  56.         try {  
  57.             //对将要写入的文件建立通道  
  58.             FileChannel fcout = new FileOutputStream(dst).getChannel();  
  59.             //使用entrySet对结果集进行遍历  
  60.             for(Map.Entry<String,Integer> entry : src.entrySet()) {  
  61.                 String key = entry.getKey();  
  62.                 int value = entry.getValue();  
  63.                 //将结果按照指定格式放到缓冲区中  
  64.                 ByteBuffer bBuf = ByteBuffer.wrap((key+":\t"+value).getBytes());  
  65.                 fcout.write(bBuf);  
  66.                 bBuf.clear();  
  67.             }  
  68.         } catch (FileNotFoundException e) {  
  69.             e.printStackTrace();  
  70.         } catch (IOException e) {  
  71.             e.printStackTrace();  
  72.         }  
  73.     }  
  74. }  
  75.   
  76. class CountWords implements Runnable {  
  77.       
  78.     private FileChannel fc;  
  79.     private FileLock fl;  
  80.     private MappedByteBuffer mbBuf;  
  81.     private HashMap<String, Integer> hm;  
  82.       
  83.     public CountWords(File src, long start, long end) {  
  84.         try {  
  85.             //得到当前文件的通道  
  86.             fc = new RandomAccessFile(src, "rw").getChannel();  
  87.             //锁定当前文件的部分  
  88.             fl = fc.lock(start, end, false);  
  89.             //对当前文件片段建立内存映射,如果文件过大需要切割成多个片段  
  90.             mbBuf = fc.map(FileChannel.MapMode.READ_ONLY, start, end);  
  91.             //创建HashMap实例存放处理结果  
  92.             hm = new HashMap<String,Integer>();  
  93.         } catch (FileNotFoundException e) {  
  94.             e.printStackTrace();  
  95.         } catch (IOException e) {  
  96.             e.printStackTrace();  
  97.         }  
  98.     }  
  99.     @Override  
  100.     public void run() {  
  101.         String str = Charset.forName("UTF-8").decode(mbBuf).toString();  
  102.         //使用StringTokenizer分析单词  
  103.         StringTokenizer token = new StringTokenizer(str);  
  104.         String word;  
  105.         while(token.hasMoreTokens()) {  
  106.             //将处理结果放到一个HashMap中,考虑到存储速度  
  107.             word = token.nextToken();  
  108.             if(null != hm.get(word)) {  
  109.                 hm.put(word, hm.get(word)+1);  
  110.             } else {  
  111.                 hm.put(word, 1);  
  112.             }  
  113.         }  
  114.         try {  
  115.             //释放文件锁  
  116.             fl.release();  
  117.         } catch (IOException e) {  
  118.             e.printStackTrace();  
  119.         }  
  120.         return;  
  121.     }  
  122.       
  123.     //获取当前线程的执行结果  
  124.     public HashMap<String, Integer> getResult() {  
  125.         return hm;  
  126.     }  
  127. }  

以上代码是我自己实现的,主要思想是:

1.使用具有键值对结构的HashMap来快速存取;

2.由于文件过大,用一个线程处理可能结果较慢,使用到并发机制;

3.IO操作比较耗时,所以使用了nio的相关内容;

4.最终结果要有序的话,可以使用TreeMap。

评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值