以繼承的硬編碼方式實現的代理

package question3;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/*
 * 	寫一個ArrayList類的代理，其內部實現和ArrayList中完全相同的功能，
 * 	並可以計算每個方法運行的時間。
 * 
 *  解題方式一
 *  1.通過實現一個List接口來獲得ArrayList的List代理功能
 *  2.爲每一個list接口的方法實現代理調用
 *  3.爲每一個list接口的方法輸出運行時間，單位爲納秒ns
 *  4.測試每一個方法的調用耗時
 *  
 *  優點：拋棄了傳統的繼承覆蓋機制，更靈活的代理和目標代碼
 *  	   轉換
 *  缺點：該方式會使代碼量成倍遞增，維護不便
 *  
 *  注：1秒=1 000 000 000納秒 jdk api中以毫微秒錶示納秒
 */
public class ArrayListProxy_1<E> implements List<E>
{
	/**
	 * 此代理的目標ArrayList,該成員只有代理類
	 * 可以持有，所以不應該暴露給用戶，而是私有
	 */
	private ArrayList<E> list = new ArrayList<E>();
	/**
	 * 緩衝的耗時變量，用來統計方法的耗時
	 * 單位爲納秒（毫微秒）
	 * 
	 * 該變量的提升方式在多線程環境會產生錯誤
	 * 並導致時間不準確,多線程中應該使其局部化
	 */
	private long taken;
	
	public static void main(String[] args)
	{
		/*
		 * 頂一個ArrayList實現的cellection實例，
		 * 並用來測試該代理的參數爲cellection的方法
		 * 也用來保證集合中有效元素的個數
		 */
		ArrayList<String> arrayList = new ArrayList<String>();
		arrayList.add("a");
		arrayList.add("b");
		arrayList.add("c");
		
		/*
		 * 創建一個代理List，該實現可以以config的方法進行配置
		 * 實現代理和真實目標的轉換
		 * 
		 * 但是該方式無法實現ArrayList的本地方法調用，只能實現
		 * ArrayList上層接口的方法調用
		 */
		List<String> list = new ArrayListProxy_1<String>();
		list.size();
		list.isEmpty();
		list.contains("zhangsan");
		list.iterator();
		list.toArray();
		list.toArray(new String[]{});
		list.add("wangwu");
		list.remove("lisi");
		list.containsAll(arrayList);
		list.addAll(arrayList);
		list.indexOf("a");
		list.lastIndexOf("c");
		list.addAll(0,arrayList);
		list.get(0);
		list.set(0, "loli");
		list.removeAll(arrayList);
		list.retainAll(arrayList);
		list.clear();
		list.add(0, "tom");
		list.remove(0);
		list.listIterator();
		list.listIterator(0);
		list.subList(0, 00);
	}
	
	/*
	 * 爲每一個方法編寫代理方式，並實現
	 * 以單位爲納秒的精確時間統計
	 * System.currentTimeMillis()在
	 * 精度上會有損失，低於100毫秒時，
	 * 精度會有+5 -5之間的偏差
	 * 
	 * After here, the other methods look like the same
	 * 後邊的不用看了。。。都一樣的
	 */
	@Override
    public int size()
    {
		int returnValue;
		taken = System.nanoTime();
		returnValue = list.size();
		taken = System.nanoTime()- taken;
		System.out.println(getClass().getName()+".size() -> "+this.list.getClass().getName()+".size() times taken by "+taken+" ns");
	    return returnValue;
    }

	@Override
    public boolean isEmpty()
    {
		boolean returnValue;
		taken = System.nanoTime();
		returnValue = list.isEmpty();
		taken = System.nanoTime()- taken;
		System.out.println(getClass().getName()+".isEmpty() -> "+this.list.getClass().getName()+".isEmpty() times taken by "+taken+" ns");
	    return returnValue;
    }

	@Override
    public boolean contains(Object o)
    {
		boolean returnValue;
		taken = System.nanoTime();
		returnValue = list.contains(o);
		taken = System.nanoTime()- taken;
		System.out.println(getClass().getName()+".contains(Object) -> "+this.list.getClass().getName()+".contains(Object) times taken by "+taken+" ns");
	    return returnValue;
    }

	@Override
    public Iterator<E> iterator()
    {
		Iterator<E> iterator;
		taken = System.nanoTime();
		iterator = list.iterator();
		taken = System.nanoTime()- taken;
		System.out.println(getClass().getName()+".iterator() -> "+this.list.getClass().getName()+".iterator() times taken by "+taken+" ns");
	    return iterator;
    }

	@Override
    public Object[] toArray()
    {
		Object[] objs;
		taken = System.nanoTime();
		objs = list.toArray();
		taken = System.nanoTime()- taken;
		System.out.println(getClass().getName()+".toArray() -> "+this.list.getClass().getName()+".toArray() times taken by "+taken+" ns");
	    return objs;
    }

	
	@Override
    public <T> T[] toArray(T[] a)
    {
		T[] objs;
		taken = System.nanoTime();
		objs = list.toArray(a);
		taken = System.nanoTime()- taken;
		System.out.println(getClass().getName()+".toArray(T[]) -> "+this.list.getClass().getName()+".toArray(T[]) times taken by "+taken+" ns");
	    return objs;
    }

	@Override
    public boolean add(E e)
    {
		boolean returnValue;
		taken = System.nanoTime();
		returnValue = list.add(e);
		taken = System.nanoTime()- taken;
		System.out.println(getClass().getName()+".add(E) -> "+this.list.getClass().getName()+".add(E) times taken by "+taken+" ns");
	    return returnValue;
    }

	@Override
    public boolean remove(Object o)
    {
		boolean returnValue;
		taken = System.nanoTime();
		returnValue = list.remove(o);
		taken = System.nanoTime()- taken;
		System.out.println(getClass().getName()+".remove(Object o) -> "+this.list.getClass().getName()+".remove(Object o) times taken by "+taken+" ns");
	    return returnValue;
    }

	@Override
    public boolean containsAll(Collection<?> c)
    {
		boolean returnValue;
		taken = System.nanoTime();
		returnValue = list.containsAll(c);
		taken = System.nanoTime()- taken;
		System.out.println(getClass().getName()+".containsAll(Collection) -> "+this.list.getClass().getName()+".containsAll(Collection) times taken by "+taken+" ns");
	    return returnValue;
	}

	@Override
    public boolean addAll(Collection<? extends E> c)
    {
		boolean returnValue;
		taken = System.nanoTime();
		returnValue = list.addAll(c);
		taken = System.nanoTime()- taken;
		System.out.println(getClass().getName()+".addAll(Collection) -> "+this.list.getClass().getName()+".addAll(Collection) times taken by "+taken+" ns");
		return returnValue;
    }

	@Override
    public boolean addAll(int index, Collection<? extends E> c)
    {
		boolean returnValue;
		taken = System.nanoTime();
		returnValue = list.addAll(index,c);
		taken = System.nanoTime()- taken;
		System.out.println(getClass().getName()+".addAll(int,Collection) -> "+this.list.getClass().getName()+".addAll(int,Collection) times taken by "+taken+" ns");
		return returnValue;
    }

	@Override
    public boolean removeAll(Collection<?> c)
    {
		boolean returnValue;
		taken = System.nanoTime();
		returnValue = list.removeAll(c);
		taken = System.nanoTime()- taken;
		System.out.println(getClass().getName()+".removeAll(Collection) -> "+this.list.getClass().getName()+".removeAll(Collection) times taken by "+taken+" ns");
		return returnValue;
    }

	@Override
    public boolean retainAll(Collection<?> c)
    {
		boolean returnValue;
		taken = System.nanoTime();
		returnValue = list.retainAll(c);
		taken = System.nanoTime()- taken;
		System.out.println(getClass().getName()+".retainAll(Collection) -> "+this.list.getClass().getName()+".retainAll(Collection) times taken by "+taken+" ns");
		return returnValue;
    }

	@Override
    public void clear()
    {
		taken = System.nanoTime();
		list.clear();
		taken = System.nanoTime()- taken;
		System.out.println(getClass().getName()+".clear() -> "+this.list.getClass().getName()+".clear() times taken by "+taken+" ns");
    }

	@Override
    public E get(int index)
    {
		E returnValue;
		taken = System.nanoTime();
		returnValue = list.get(index);
		taken = System.nanoTime()- taken;
		System.out.println(getClass().getName()+".get(int) -> "+this.list.getClass().getName()+".get(int) times taken by "+taken+" ns");
		return returnValue;
    }

	@Override
    public E set(int index, E element)
    {
		E returnValue;
		taken = System.nanoTime();
		returnValue = list.set(index,element);
		taken = System.nanoTime()- taken;
		System.out.println(getClass().getName()+".set(int,E) -> "+this.list.getClass().getName()+".set(int,E) times taken by "+taken+" ns");
		return returnValue;
    }

	@Override
    public void add(int index, E element)
    {
		taken = System.nanoTime();
		list.add(index,element);
		taken = System.nanoTime()- taken;
		System.out.println(getClass().getName()+".add(int,E) -> "+this.list.getClass().getName()+".add(int,E) times taken by "+taken+" ns");
    }

	@Override
    public E remove(int index)
    {
		E returnValue;
		taken = System.nanoTime();
		returnValue = list.remove(index);
		taken = System.nanoTime()- taken;
		System.out.println(getClass().getName()+".remove(int) -> "+this.list.getClass().getName()+".remove(int) times taken by "+taken+" ns");
		return returnValue;
    }

	@Override
    public int indexOf(Object o)
    {
		int returnValue;
		taken = System.nanoTime();
		returnValue = list.indexOf(o);
		taken = System.nanoTime()- taken;
		System.out.println(getClass().getName()+".indexOf(Object) -> "+this.list.getClass().getName()+".indexOf(Object) times taken by "+taken+" ns");
		return returnValue;
    }

	@Override
    public int lastIndexOf(Object o)
    {
		int returnValue;
		taken = System.nanoTime();
		returnValue = list.lastIndexOf(o);
		taken = System.nanoTime()- taken;
		System.out.println(getClass().getName()+".lastIndexOf(Object) -> "+this.list.getClass().getName()+".lastIndexOf(Object) times taken by "+taken+" ns");
		return returnValue;
    }

	@Override
    public ListIterator<E> listIterator()
    {
		ListIterator<E> returnValue;
		taken = System.nanoTime();
		returnValue = list.listIterator();
		taken = System.nanoTime()- taken;
		System.out.println(getClass().getName()+".listIterator() -> "+this.list.getClass().getName()+".listIterator() times taken by "+taken+" ns");
		return returnValue;
    }

	@Override
    public ListIterator<E> listIterator(int index)
    {
		ListIterator<E> returnValue;
		taken = System.nanoTime();
		returnValue = list.listIterator(index);
		taken = System.nanoTime()- taken;
		System.out.println(getClass().getName()+".listIterator(int) -> "+this.list.getClass().getName()+".listIterator(int) times taken by "+taken+" ns");
		return returnValue;
    }

	@Override
    public List<E> subList(int fromIndex, int toIndex)
    {
		List<E> returnValue;
		taken = System.nanoTime();
		returnValue = list.subList(fromIndex,toIndex);
		taken = System.nanoTime()- taken;
		System.out.println(getClass().getName()+".subList(int,int) -> "+this.list.getClass().getName()+".subList(int,int) times taken by "+taken+" ns");
		return returnValue;
    }
}