《Thinking in Java》十七章_容器深入研究_练习13(Page484)

练习13：

单词计数器

 import java.io.BufferedReader;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.util.Arrays;
 import java.util.Iterator;
 import java.util.Map;

 import org.cc.foo_005.AssocitiveArray.AssocitiveArrayEntry;

 public class Main {

     public static void main(String[] args) {

         String path="D:/test_001/practice_002/1.Harry Potter and the Sorcerer's Stone.txt";

         AssocitiveArray<String,Integer> ans=wordCount(path);

         Iterator<AssocitiveArrayEntry<String,Integer>> iter=ans.iterator();
         while(iter.hasNext()){
             AssocitiveArrayEntry<String,Integer> o=iter.next();
             System.out.printf("%s=%d\n",o.getKey(),o.getValue());
         }

     }

     public static AssocitiveArray<String,Integer> wordCount(String filePath){

         BufferedReader reader=null;
         AssocitiveArray<String,Integer> res=null;

         try {
             reader=new BufferedReader(new InputStreamReader(new FileInputStream(filePath),"UTF-8"));
             StringBuilder sb=new StringBuilder();

             while(reader.ready()){
                 sb.append(reader.readLine());
             }

             String words[]=sb.toString().split("[(\\s{1,})]");

             res=new AssocitiveArray<String,Integer>();

             for(String s:words){
                 if(!"".equals(s)){
                     Integer t=res.get(s);
                     res.put(s,t==null?1:t+1);
                 }
             }
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }finally{
             try {
                 if(reader!=null) reader.close();
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }

         return res;
     }

 }

 //关联数组
 class AssocitiveArray<K, V> implements Iterable {

     //存储数据
     private Object pairs[][];
     //当前最大有效数据的下标+1，即下一个可用位置，类似于栈顶指针
     private int index;

     public AssocitiveArray() {
         this(17);
     }

     public AssocitiveArray(int length) {
         pairs=new Object[length][2];
     }

     public void put(K key,V value){
         //先检查，如果key已经存在的话就直接覆盖掉
         for(int i=0;i<index;i++){
             if(key.equals(pairs[i][0])){
                 pairs[i][1]=value;
                 return ;
             }
         }
         //检查是否需要扩充空间
         if(index==pairs.length) pairs=Arrays.copyOf(pairs,pairs.length*2);
         pairs[index++]=new Object[]{key,value};
     }

     public V get(K key){
         for(int i=0;i<index;i++){
             if(key.equals(pairs[i][0])) return (V) pairs[i][1];
         }
         return null;
     }

     public V remove(K key){
         for(int i=0;i<index;i++){
             if(key.equals(pairs[i][0])){
                 V oldValue=(V) pairs[i][1];
                 pairs[i]=pairs[--index];
                 return oldValue;
             }
         }
         return null;
     }

     public int size(){
         return index;
     }

     @Override
     public String toString() {
         StringBuilder sb=new StringBuilder();
         sb.append("[");
         for(int i=0;i<index;i++){
             sb.append(pairs[i][0]).append(":").append(pairs[i][1].toString());
             if(i!=pairs.length-1) sb.append(",");
         }
         sb.append("]");
         return sb.toString();
     }

     @Override
     public Iterator<AssocitiveArrayEntry<K,V>> iterator() {
         return new Iterator<AssocitiveArrayEntry<K,V>>() {

             private int curIndex;

             @Override
             public boolean hasNext() {
                 return curIndex<index;
             }

             @Override
             public AssocitiveArrayEntry<K,V> next() {
                 AssocitiveArrayEntry<K,V> ans=new AssocitiveArrayEntry<K,V>((K)pairs[curIndex][0],(V)pairs[curIndex][1]);
                 curIndex++;
                 return ans;
             }

             @Override
             public void remove() {
                 throw new UnsupportedOperationException();
             }
         };
     }

     static class AssocitiveArrayEntry<K,V> implements Map.Entry<K,V>{

         private K key;
         private V value;

         public AssocitiveArrayEntry(K key, V value) {
             super();
             this.key = key;
             this.value = value;
         }

         @Override
         public K getKey() {
             return key;
         }

         @Override
         public V getValue() {
             return value;
         }

         @Override
         public V setValue(Object value) {
             throw new UnsupportedOperationException();
         }

     }

 }

测试结果如图：