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();

         }

     }

 }