import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
public class MySet implements Cloneable
{
	public MySet(){}
	//用數(shù)組初始化集合
	public MySet(int A[])
	{
		for(int e : A)
		{
			arrayList.add(e);
		}
	}
	
	//用集合初始化集合
	public MySet(MySet s)
	{
		arrayList = s.arrayList;
	}
	
	//用ArrayList<Integer>初始化集合
	public MySet(ArrayList<Integer> al)
	{
		arrayList = al;
	}
	
	//實(shí)現(xiàn)克隆功能
	public MySet clone() throws CloneNotSupportedException
	{
		MySet cloned = new MySet();
				
		Iterator<Integer> itArrayList = this.arrayList.iterator();
		while(itArrayList.hasNext())
		{
			cloned.arrayList.add(itArrayList.next());
		}
		
		return cloned;
	}
	
	//判斷集合是否為空集
	boolean isEmpty()
	{
		return arrayList.isEmpty();
	}
	
	//計(jì)算集合A的模
	int card()
	{
		return arrayList.size();
	}
	
	//集合清空
	void clear()
	{
		arrayList.clear();
	}
	
	//在集合中查找元素,存在則返回位置，不存在返回-1
	int find(int a)
	{
		for(int i=0; i<this.card();i++)
		{
			if(a == this.keyAt(i))
			{
				return i;
			}
		}
		return -1;
	}
	
	//返回集合中l(wèi)oc位置的值
	int keyAt(int loc)
	{
		return arrayList.get(loc);
	}
	
	//設(shè)置loc位置的值為val
	void setKey(int loc,int val)
	{
		arrayList.set(loc, val);
	}
	
	//對(duì)集合中的元素按從小到大排序
	void sort()
	{
		Collections.sort(arrayList);
	}
	
	//在集合中刪除元素得到新的集合
	void remove(int a)
	{
		if(-1 != find(a))
		{
			ArrayList<Integer> temp = new ArrayList<Integer>(0);
			for(int i=0;i<arrayList.size();i++)
			{
				if(arrayList.get(i) != a)
				{
					temp.add(arrayList.get(i));
				}
			}
			arrayList = temp;
		}
	}
	
	//在集合中添加元素得到新的集合
	void add(int a)
	{
		arrayList.add(a);
	}
	
	//判斷當(dāng)前集合是不是s集合的子集
	boolean belongTo(MySet s)
	{
		for(int e : arrayList)
		{
			if(-1 == s.find(e))
				return false;
		}
		return true;
	}
	
	//判斷兩個(gè)集合是否相等
	boolean isEqual(MySet s)
	{
		if(this.belongTo(s) && s.belongTo(this))
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	
	//當(dāng)前集合中去掉子集s,s必須是當(dāng)前集合的子集
	MySet sub(MySet s)
	{
		if(s.belongTo(this))
		{
			MySet temp = new MySet(arrayList);
			for(int i=0; i<s.card(); i++)
			{
				temp.remove(s.keyAt(i));
			}
			return temp;
		}
		else
		{
			System.out.println("參數(shù)中集合并非當(dāng)前集的子集，不能進(jìn)行該運(yùn)算");
			return null;
		}
	}
	
	//當(dāng)前集并上另一個(gè)集合
	MySet union(MySet s)
	{
		MySet temp = new MySet(arrayList);
		for(int i=0;i<s.card();i++)
			if(-1 == temp.find(s.keyAt(i)))
			{
				temp.add(s.keyAt(i));
			}
		return temp;
	}
	
	//當(dāng)前集與另一個(gè)集合的交集
	MySet interSect(MySet s)
	{
		MySet temp = new MySet(arrayList);
		for(int i=0; i<s.card();i++)
			if(-1 == s.find(s.keyAt(i)))
			{
				temp.remove(s.keyAt(i));
			}
		MySet VOfA = temp.valueOfAttribute();
		return VOfA;
	}
	
	//求某屬性值集的值域
	MySet valueOfAttribute()
	{
		MySet temp = new MySet();
		for(int i=0; i<this.card();i++)
		{
			if(this.keyAt(i) != Integer.MAX_VALUE)
			{
				temp.add(this.keyAt(i));
				for(int j=i+1; j<this.card();j++)
				{
					if(this.keyAt(i) == this.keyAt(j))
					{
						this.setKey(j, Integer.MAX_VALUE);
					}
				}
			}
			else
				continue;
		}
		return temp;
	}
	
	//把該集合轉(zhuǎn)化成整型數(shù)組
	ArrayList<Integer> toIntArrayList()
	{
		ArrayList<Integer> temp = new ArrayList<Integer>(0);
		for(int i=0; i<this.card(); i++)
		{
			temp.add(this.keyAt(i));
		}
		return temp;
	}
	
	//在屏幕打印集合A
	void print()
	{
		int i=0;
		System.out.print("{");
		if(!arrayList.isEmpty())
		{
			System.out.print(arrayList.get(i));
		}
		i++;
		for(; i<arrayList.size(); ++i)
		{
			System.out.print(","+arrayList.get(i));
		}
		System.out.print("}");
	}
	
	private ArrayList<Integer> arrayList = new ArrayList<Integer>(0);
}