以继承的硬编码方式实现的代理

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;
    }
}