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

}

测试结果如图：