集合操作类--包(数组实现)

package com.opensource.collections;

/**
 * 对整数元素集合进行操作
 * 使用数组实现，当元素数量大时，效率较低    
 */
public class IntArrayBag implements Cloneable 
{
	//IntArrayBag类的不定式:
	//1.包中元素的数目存放在实例变量manyItems中.
	//2.对于一个空包，不需要关心存放的是什么数据，对于非空包，
	//包中的元素存放在data[0]到data[manyItems-1]中,
	//并且不需要关心data中其他部分的内容.

	private int[] data;   //元素集合
	private int manyItems; //元素数量

	/**
	 * 使用默认的10容量初始化一个空包
	 */
	public IntArrayBag()
	{
		final int INITIAL_CAPACITY = 10;
		manyItems = 0;
		data =new int[INITIAL_CAPACITY];
	}

	/**
	 * 使用指定大小初始化一个空包
	 * @param initialCapacity
	 */
	public IntArrayBag(int initialCapacity)
	{
		if(initialCapacity < 0)
			throw new IllegalArgumentException
			 ("initialCapacity is negative:"+initialCapacity);
		manyItems = 0;
		data = new int[initialCapacity];
	}

	/**
	 * 往包中添加元素
	 * @param element
	 */
	public void add(int element)
	{
		if(manyItems == data.length)
		{
			//将容量翻倍加1，即便manyItems为0也是如此。然而
			//如果manyItems*2+1超过Integer.MAX_VALUE
			//将会出现算术溢出并且包失败
			ensureCapacity(manyItems*2+1);
		}
		data[manyItems] = element;
		manyItems++;
	}

	/**
	 * 将另一个包的内容添加到该包中
	 * @param addend
	 */
	public void addAll(IntArrayBag addend)
	{
		//如果addend为null，那么将抛出NullPointerExceptino
		//如果总项数超过Integer.MAX_VALUE,将会出现算术溢出并且包失败
		ensureCapacity(manyItems+addend.manyItems);
		System.arraycopy(addend.data, 0, data, manyItems, addend.manyItems);
		manyItems += addend.manyItems;
	}

	/**
	 * 复制包对象
	 */
	public Object clone()
	{
		//复制一个IntArrayBag对象
		IntArrayBag answer=null;
		try
		{
		   answer = (IntArrayBag)super.clone();
		}catch(CloneNotSupportedException e)
		{
		   e.printStackTrace();
		}
		answer.data = (int[])data.clone();

		return answer;
	}

	/**
	 * 计算包中特定元素出现次数
	 * @param target
	 * @return
	 */
	public int countOccurrences(int target)
	{
		int answer = 0;

		for(int element:data)
		{
			if(element == target)
				answer++;
		}
		return answer;
	}

	/**
	 * 改变包的容量
	 * @param minimumCapacity
	 */
	public void ensureCapacity(int minimumCapacity) 
	{
		int[] biggerArray;
		if(data.length < minimumCapacity)
		{
			biggerArray = new int[minimumCapacity];
			System.arraycopy(data, 0, biggerArray, 0, manyItems);
			data = biggerArray;
		}
	}

	/**
	 * 获取该包的当前容量
	 * @return
	 */
	public  int getCapacity()
	{
		return data.length;
	}

	/**
	 * 删除包中的目标元素，如果不存在，返回false
	 * @param target
	 * @return
	 */
	public boolean remove(int target)
	{
		int index; //target在data数组中的位置
		//首先,将index设置成target在data数组中的位置
		//最小可为0，最大可为manyItems-1.
		//如果target不在数组中，那么将index设置成manyItesms;
		index = 0;
		while((index < manyItems) && (target != data[index]))
		{
			index++;
		}
		if(index == manyItems)
			//没有找到target，所以没有删除任何内容
			return false;
		else
		{
			manyItems--;
			data[index]=data[manyItems];
			return true;
		}
	}

	/**
	 * 获取包中的元素数量
	 * @return
	 *     manyItems
	 */
	public int size()
	{
		return manyItems;
	}

	/**
	 * 将该包的当前容量减小成为它的实际大小
	 */
	public  void trimToSize()
	{
		int[] trimmedArray;
		if(data.length != manyItems)
		{
			trimmedArray = new int[manyItems];
			System.arraycopy(data, 0, trimmedArray, 0, manyItems);
			data = trimmedArray;
		}
	}

	/**
	 * 合并两个包对象
	 * @param b1
	 *         包对象
	 * @param b2
	 *         包对象
	 * @return
	 *        answer
	 */
	public static IntArrayBag union(IntArrayBag b1,IntArrayBag b2)
	{
		//如果b1或者b2为null,那么抛出NullPointerException.
		//如果总项数超过Integer.MAX_VALUE,将会出现算术溢出并且包失败.
		IntArrayBag answer = new IntArrayBag(b1.getCapacity()+b2.getCapacity());
	    System.arraycopy(b1.data, 0, answer.data, 0, b1.manyItems);
	    System.arraycopy(b2.data, 0, answer.data, b1.manyItems, b2.manyItems);
	    answer.manyItems = b1.manyItems+b2.manyItems;
	    return answer;
	}

}