集合操作类--序列

package com.opensource.collections;

/**
 * 对整数元素集合进行操作
 * 使用序列的方式
 * 使用数组实现，当元素数量大时，效率较低    
 */
public class DoubleArraySeq implements Cloneable{
	
	//DoubleArraySeq类不变式:
	//1.序列中元素的数目存储在实例变量manyItems中。
	//2.对于空序列,并不关心在任何data中存放了什么；对于
	//一个非空序列，序列的元素存储在data[0]到data[manyItems-1],
	//不需要关心data其他部分存放的是什么元素.
	//3.如果有当前元素，那么它位于data[currentIndex],如果没有当前元素,
	//则currentIndex等于manyItems.
	
	private double[] data;  //元素集合
	private int manyItems;  //元素数量
	private int currentIndex; //当前元素(若存在)的下标值
	
	/**
	 * 使用默认的10容量初始化一个空序列
	 */
	public DoubleArraySeq()
	{
		final int INITIAL_CAPACITY = 10;
		manyItems = 0;
		data = new double[10];
	}
	
	/**
	 * 使用指定大小初始化一个空包
	 * @param initialCapacity
	 */
	public DoubleArraySeq(int initialCapacity)
	{
	   if(initialCapacity < 0)
		  throw new IllegalArgumentException
			("initialCapacity is negative:"+initialCapacity);
		manyItems = 0;
		try
		{
		data = new double[initialCapacity];
		}catch(OutOfMemoryError e){
			throw new RuntimeException
			   ("System have no enough memory");
		}
	}
	
	/**
	 * 在当前元素前面增加元素
	 * @param element
	 */
	public void addBefore(double element)
	{
		if(manyItems == data.length)
		{
			ensureCapacity(manyItems*2+1);
		}else{
		     if(isCurrent())
		      {
				for(int i = manyItems ;i > currentIndex ; i--)
				{
					data[i] = data[i-1];
				}
				data[currentIndex] = element;
				manyItems++;
		     }
			 else
			    {
					for(int i = manyItems; i>0;i--)
					{
						data[i] = data[i-1];
					}
					data[0] = element;
					manyItems++;
			    }
		}	
	}
	
	/**
	 * 在当前元素后面增加元素
	 * @param element
	 */
	public void addAfter(double element)
	{

		if(manyItems == data.length)
		{
			ensureCapacity(manyItems*2+1);
			
		}else{
			if(isCurrent())
			{
				for(int i = manyItems ;i > currentIndex+1 ; i--)
				{
					data[i] = data[i-1];
				}
				data[currentIndex+1] = element;
				currentIndex +=1;
				manyItems++;
			}
			else{
				data[manyItems] = element;
			    manyItems++;
			}
		}
	}
	/**
	 * 判断序列是否有当前元素
	 * @return
	 */
	public boolean isCurrent()
	{
		if(currentIndex != manyItems)
		    return true;
		else{
			return false;
		}
	}
	
	/**
	 * 获取当前元素值
	 * @return
	 */
	public double getCurrent()
	{
		if(isCurrent())
			return data[currentIndex];
		else
			throw new IllegalArgumentException
			 ("Do not exist current element");
	}
	
	/**
	 * 初始化序列的当前元素为0
	 */
	public void start()
	{
		currentIndex = 0;
	}
	
	/**
	 * 返回当前元素的数量
	 * @return
	 */
	public int size()
	{
		return manyItems;
	}
	
	/**
	 * 改变序列的容量
	 * @param minimumCapacity
	 */
	public void ensureCapacity(int minimumCapacity) 
	{
		double[] biggerArray;
		if(data.length < minimumCapacity)
		{
			biggerArray = new double[minimumCapacity];
			System.arraycopy(data, 0, biggerArray, 0, manyItems);
			data = biggerArray;
		}
	}
	
	/**
	 * 删除当前元素
	 * @return
	 */
	public boolean removeCurrent()
	{
		if(isCurrent()){
			if(currentIndex == manyItems-1)
			{
				manyItems -=1;
			}else
			{
				for(int i= currentIndex;i<manyItems-1;i++)
				{
					data[i] = data[i+1];
				}
				manyItems--;
			}
			return true;
		}
		return false;
	}
	
	/**
	 * 将一个序列添加到现有序列的后面
	 * @param addend
	 */
	public void addAll(DoubleArraySeq addend)
	{
		//如果addend为null，那么将抛出NullPointerExceptino
		//如果总项数超过Integer.MAX_VALUE,将会出现算术溢出并且包失败
		ensureCapacity(manyItems+addend.manyItems);
		System.arraycopy(addend.data, 0, data, manyItems, addend.manyItems);
		manyItems += addend.manyItems;
	}
	
	/**
	 * 合并两个序列
	 * @param s1
	 * @param s2
	 * @return
	 */
	public static DoubleArraySeq concatenation(DoubleArraySeq s1,DoubleArraySeq s2)
	{
		DoubleArraySeq answer = new DoubleArraySeq(s1.getCapacity()+s2.getCapacity());
	    System.arraycopy(s1.data, 0, answer.data, 0, s1.manyItems);
	    System.arraycopy(s2.data, 0, answer.data, s1.manyItems, s2.manyItems);
		answer.manyItems = s1.manyItems+s2.manyItems;
		answer.currentIndex = answer.manyItems;
		
	    return answer;
	}
	
	/**
	 * 获取序列的容量
	 * @return
	 */
	public int getCapacity()
	{
		return data.length;
	}
	
	/**
	 * 使序列的下一个元素成为当前元素
	 */
	public void advance()
	{
		if(isCurrent())
			currentIndex +=1;
	}

	/**
	 * 将该序列当前容量缩减到它的实际大小
	 */
	public void trimToSize()
	{
		double[] trimmedArray;
		if(data.length != manyItems)
		{
			trimmedArray = new double[manyItems];
			System.arraycopy(data, 0, trimmedArray, 0, manyItems);
			data = trimmedArray;
		}
	}
	
	/**
	 * 克隆序列的副本
	 */
	public Object clone()
	{
		//复制一个IntArrayBag对象
		DoubleArraySeq answer=null;
		try
		{
		   answer = (DoubleArraySeq)super.clone();
		}catch(CloneNotSupportedException e)
		{
		   e.printStackTrace();
		}
		answer.data = (double[])data.clone();
		
		return answer;
	}
}