粗糙集属性约简的一些关键步骤(第一次写)

为了大家能够更好的实现粗糙集属性约简以及了解相关知识，在这里给出了构造决策表部分的代码，希望读者通过阅读代码自己实现一些论文中的简单算法,代码中有什么不懂得可以与我交流，论文代码实现也可以与我一起探讨，互相学习。

import java.util.ArrayList;
import java.util.Iterator;
public class MyElement implements Cloneable
{
	public MyElement(){}
	public MyElement(ArrayList<Float> condition, ArrayList<Float> decision, int iNo)
	{
		this.valueOfCondition = condition;
		this.valueOfDecision = decision;
		this.u = iNo;
	}
	public MyElement(MySet condition, MySet decision, int iNo)
	{
		this.valueOfCondition = condition.toIntArrayList();
		this.valueOfDecision = condition.toIntArrayList();
		this.u = iNo;
	}
	public MyElement clone() throws CloneNotSupportedException
	{
		MyElement cloned = new MyElement();
		cloned.u = this.getU();
		Iterator<Float> itCondition = this.getCondition().iterator();
		while(itCondition.hasNext())
		{
			cloned.valueOfCondition.add(itCondition.next());
		}
		Iterator<Float> itDecision = this.getDecision().iterator();
		while(itDecision.hasNext())
		{
			cloned.valueOfDecision.add(itDecision.next());
		}
		return cloned;
	}
	public ArrayList<Float> getCondition()
	{
		return this.valueOfCondition;
	}
	public ArrayList<Float> getDecision()
	{
		return this.valueOfDecision;
	}
	public int getU()
	{
		return this.u;
	}
	void setCondition(ArrayList<Float> condition)
	{
		this.valueOfCondition = condition;
	}
	void setDecision(ArrayList<Float> decision)
	{
		this.valueOfDecision = decision;
	}
	void setU(int u)
	{
		this.u = u;
	}
	boolean isConditionEqual(MyElement another)
	{
		Iterator<Float> it1 = this.valueOfCondition.iterator();
		Iterator<Float> it2 = another.valueOfCondition.iterator();
		
		while(it1.hasNext() && it2.hasNext())
		{
			if(it1.next() != it2.next())
				return false;
		}
		return true;
	}
	boolean isDecisionEqual(MyElement another)
	{
		Iterator<Float> it1 = this.getDecision().iterator();
		Iterator<Float> it2 = another.getDecision().iterator();
		
		while(it1.hasNext() && it2.hasNext())
		{
			if(it1.next() != it2.next())
				return false;
		}
		return true;
	}
	boolean isUEqual(MyElement another)
	{
		if(this.getU() != another.getU())
			return false;
		else 
			return true;
	}
	boolean isEqual(MyElement another)
	{
		if(this.isConditionEqual(another) && this.isDecisionEqual(another))
			return true;
		else 
			return false;
	}
	void removeConditionAttribute(int it)
	{
		this.valueOfCondition.remove(it);
	}
	void addConditionAttribute(Float a)
	{
		this.valueOfCondition.add(a);
	}
	void print()
	{
		if(!this.valueOfCondition.isEmpty() && !this.valueOfDecision.isEmpty())
		{
			System.out.print("(");
			Iterator<Float> it = this.valueOfCondition.iterator();
			System.out.print(it.next());
			while(it.hasNext())
			{
				System.out.print(",\t" + it.next());
			}
			System.out.print(")\t->\t(");
			it = this.valueOfDecision.iterator();
			System.out.print(it.next());
			while(it.hasNext())
			{
				System.out.print(",\t" + it.next());
			}
			System.out.println(")\tu" + u);
		}
		else
			System.out.println("该样本不符合条件，无意义");
	}
	
	private ArrayList<Float> valueOfCondition = new ArrayList<Float>(0);
	private ArrayList<Float> valueOfDecision = new ArrayList<Float>(0);
	private int u;
}

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Scanner;
import java.io.*;
import java.math.*;
public class DecisionTable implements Cloneable
{
	private static final Float Interger = null;
	public static int iNo;
	public DecisionTable()
	{
		
	}
	public DecisionTable(String fileName)
	{
		try
		{
			File file = new File(fileName);
			Scanner in = new Scanner(file);
			String[] temp;
			while(in.hasNextLine())
			{
				temp = in.nextLine().split(" |,");
				
				if(temp[0].equals( "@conditionAttribute"))
				{
//					System.out.println("#####"+temp.length);
					for(int i=1; i<temp.length; i++)
					{
//						System.out.print(" "+(temp[i]));
						this.conditionSet.add( Integer.parseInt(temp[i]));
						
					}
				}
				else if(temp[0].equals("@decisionAttribute"))
				{
					for(int i=1; i<temp.length; i++)
					{
						this.decisionSet.add(Integer.parseInt(temp[i]));
					}
				}
				else if(temp[0].equals("%") || temp[0].equals("@data"))
				{
					continue;
				}
				else if(temp[0].equals("@end"))
				{
					break;
				}
		
				else if(Float.parseFloat(temp[0]) < Float.MAX_VALUE)
				{
					MyElement e = new MyElement();
					int i = 0;
					ArrayList<Float> C = new ArrayList<Float>(0);
					ArrayList<Float> D = new ArrayList<Float>(0);
					for(; i< this.conditionSet.size(); i++)
					{
						C.add(Float.parseFloat(temp[i]));
						
					}
					for(int j=0; j<this.decisionSet.size(); j++)
					{
						D.add(Float.parseFloat(temp[i+j]));
					}
					e.setCondition(C);
					e.setDecision(D);
					this.addElement(e);
				}
				else
				{
					System.out.print(temp[0]+"!!!");
					System.out.println("数据数目有误，请检查");
					break;
				}
			}
	
		}

		catch(IOException e)
		{
			
			System.out.print("不能打开文件" + fileName + " " + e.getMessage());
		}
	}
	public DecisionTable clone() throws CloneNotSupportedException
	{
		DecisionTable cloned = new DecisionTable();
		
		cloned.conditionSet = (ArrayList<Integer>)this.conditionSet.clone();
		cloned.decisionSet = (ArrayList<Integer>)this.decisionSet.clone();
		ArrayList<MyElement> arrayElements = new ArrayList<MyElement>(0);
		MyElement tempElement = new MyElement();
		Iterator<MyElement> itElements = this.DT.iterator();
		while(itElements.hasNext())
		{
			tempElement = itElements.next().clone();
			arrayElements.add(tempElement);
		}
		cloned.DT = arrayElements;
		
		return cloned;
	}
	public float [][]  to_Condition_table(){
		ArrayList<MyElement> temp = this.getDT();
		float table[][] = new float[temp.size()][this.conditionSet.size()];
		Iterator<MyElement> itElements = this.DT.iterator();
		for(int i = 0 ; i < this.numberOfElements() ;i++){
			for(int j = 0 ; j < this.conditionSet.size() ; j++ ){
				table[i][j] = temp.get(i).getCondition().get(j);
			}
		}
		return table;
		
	}	

	public float [][]  to_Decision_table(){
		ArrayList<MyElement> temp = this.getDT();
		float table[][] = new float[temp.size()][this.decisionSet.size()];
		Iterator<MyElement> itElements = this.DT.iterator();
		for(int i = 0 ; i < this.numberOfElements() ;i++){
			for(int j = 0 ; j < this.decisionSet.size() ; j++ ){
				table[i][j] = temp.get(i).getDecision().get(j);
			}
		}
		return table;
		
	}	
	void setConditionSet(ArrayList<Integer> condition)
	{
		this.conditionSet = condition;
	}
	void setDecisionSet(ArrayList<Integer> decision)
	{
		this.decisionSet = decision;
	}
	void setU(int index, int newU)
	{
		MyElement temp = DT.get(index);
		temp.setU(newU);
		DT.set(index,temp);
	}
	ArrayList<Integer> getConditionSet()
	{
		return this.conditionSet;
	}
	ArrayList<Integer> getDecisionSet()
	{
		return this.decisionSet;
	}
	ArrayList<MyElement> getDT()
	{
		return DT;
	}
	MyElement getElement(float f)
	{
		MyElement temp = new MyElement();
		Iterator<MyElement> it = this.DT.iterator();
		while(it.hasNext())
		{
			temp = it.next();
			if(temp.getU() == f)
			{
				return temp;
			}
		}
		System.out.println("不存在你所指定的样本");
		return null;
	}
	
	//返回决策表DT中的样本数
	int numberOfElements()
	{
		return DT.size();	
	}
	void addElement(MyElement e)
	{
		this.serialNumberOfElement++;
		if(DecisionTable.iNo < Integer.MAX_VALUE)
		{
			e.setU(this.serialNumberOfElement);
			DT.add(e);
		}
		else
		{
			System.out.println("可用编号已耗尽，添加样本失败");
		}
	}
	void addElement(MyElement e, boolean flag)
	{
		if(flag)
		{
			this.addElement(e);
		}
		else
		{
			DT.add(e);
		}
	}
	int findElement(MyElement e)
	{
		Iterator<MyElement> it = this.DT.iterator();
		while(it.hasNext())
		{
			MyElement temp = it.next();
			if(temp.equals(e))
			{
				return temp.getU();
			}
		}
		return -1;
	}
	void removeElement(int iNo)
	{
		if(iNo >= 1 && iNo <= this.serialNumberOfElement)
		{
			Iterator<MyElement> it = this.DT.iterator();
			while(it.hasNext())
			{
				if(it.next().getU() == iNo)
				{
					this.DT.remove(iNo);
					break;
				}
			}
		}
		else
		{
			System.out.println("越界，不存在这样的样本");
		}
	}
	boolean containsConditionAttribute(int c )
	{
		Iterator<Integer> itConditionAttr = this.getConditionSet().iterator();
		while(itConditionAttr.hasNext())
		{
			if(itConditionAttr.next() == c)
				return true;
		}
		return false;
	}
	boolean containsDecisionAttribute(int d)
	{
		Iterator<Integer> itConditionAttr = this.getDecisionSet().iterator();
		while(itConditionAttr.hasNext())
		{
			if(itConditionAttr.next() == d)
				return true;
		}
		return false;
	}
	DecisionTable removeConditionAttribute(int c)
	{
		int index =0;
		Iterator<Integer> it = this.conditionSet.iterator();
		int temp;
		while(it.hasNext())
		{
			index++;
			temp = it.next();
			if(temp == c)
			{//有可能位置有问题；
				it.remove();
				break;
			}
		}
		index--;
		Iterator<MyElement> itEle = this.DT.iterator();
		while(itEle.hasNext())
		{
			itEle.next().removeConditionAttribute(index);
		}
		return this;
	}
	MySet POS()
	{
		boolean flag;
		MySet pos = new MySet();
		Iterator<MyElement> it1 = this.DT.iterator();
		Iterator<MyElement> it2;
		MyElement temp1 = new MyElement(),temp2 = new MyElement();
		while(it1.hasNext())
		{
			temp1 = it1.next();
			flag = true;
			it2 = this.DT.iterator();
			while(it2.hasNext())
			{
				temp2 = it2.next();
				if(temp1.isConditionEqual(temp2) && !temp1.isDecisionEqual(temp2))
				{
					flag = false;
					break;
				}
			}
			if(flag)
			{
				pos.add(temp1.getU());
			}
		}
		return pos;
	}
	double relyDegreeOfDToC()
	{
		double result = 0.0d;
		MySet pos = this.POS();
		
		result = (double) pos.card() / this.numberOfElements();
		
		return result;
	}
	float relyDegreeOfDToc(float x)
	{
		float result = 0.0f;
		
		result = (float) x / this.numberOfElements();
			
		return result;
	}
	double relyDegreeOfDToAttribute(int c) throws CloneNotSupportedException
	{
		DecisionTable temp = (DecisionTable)this.clone();
		Iterator<Integer> it = temp.conditionSet.iterator();
		double result = 0.0d;
		int nowCondition;
		while(it.hasNext())
		{
			nowCondition = it.next();
			if(c != nowCondition)
			{
				temp.removeConditionAttribute(nowCondition);
			}
		}
		MySet pos = temp.POS();
		result = (double)pos.card() / this.numberOfElements();
		return result;
	}
	double sigOfAttribute(int c) throws CloneNotSupportedException
	{
		double sig = 0.0d;
		double x,y;
		DecisionTable temp = (DecisionTable)this.clone();
		temp.removeConditionAttribute(c);
		MySet posx = this.POS();
		x = (double) posx.card() / this.numberOfElements();
		MySet posy = temp.POS();
		y = (double) posy.card() / temp.numberOfElements();
		sig = x- y;
		return sig;
	}
	float sigOfC(ArrayList<Integer> alChar) throws CloneNotSupportedException
	{
		float sig_C ;
		sig_C = 0;
		DecisionTable temp = (DecisionTable)this.clone();

		Iterator<MySet> equClass = temp.equivalenceClass2(alChar).iterator();
		while(equClass.hasNext())
		{
			MySet tt=equClass.next();
			sig_C += ((float)tt.card()/temp.numberOfElements())*
					(    (float)Math.log(  (double)tt.card()/temp.numberOfElements()    )/ (float)Math.log ((double)2)  );	
		}
		return  (float) (sig_C*(-1.0)); 
	}
	ArrayList<Integer> core() throws CloneNotSupportedException
	{
		ArrayList<Integer> temp = new ArrayList<Integer>(0);
		Iterator<Integer> it = this.getConditionSet().iterator();
		int tmpChar;
		while(it.hasNext())
		{
			tmpChar = it.next();
			if(this.sigOfAttribute(tmpChar) != 0)
			{
				temp.add(tmpChar);
			}
		}
		return temp;
	}
	MySet lowerApproximation(ArrayList<Integer> alChar) throws CloneNotSupportedException{
		Iterator<Integer> itPara = alChar.iterator();
		ArrayList<MySet> equClass = new ArrayList<MySet>(0);
		boolean availablePara_C = true;
		while(itPara.hasNext()){
			int temp_At=itPara.next();
		
			
			if(!this.containsConditionAttribute(temp_At)){
//				System.out.println(temp_At+" ###");
				availablePara_C = false;
			}
		}
		if(availablePara_C){
			MySet lowAppSet = new MySet();
			ArrayList<Integer> d = new ArrayList<Integer>(0);
			d.addAll(this.getDecisionSet());
			ArrayList<MySet> equClass_D = this.equivalenceClass2(d);
			ArrayList<MySet> equClass_C = this.equivalenceClass2(alChar);
			Iterator<MySet> itSet_D = equClass_D.iterator();
			while(itSet_D.hasNext()){
				Iterator<MySet> itSet_C = equClass_C.iterator();
				MySet temp_C = new MySet();
				MySet temp_D = new MySet();
				temp_D = itSet_D.next();
				while(itSet_C.hasNext()){
					temp_C=itSet_C.next();		
					if(temp_C.belongTo(temp_D)){
						lowAppSet.union(temp_C);
					}
				}
			}
			lowAppSet.sort();
			return lowAppSet;
		}
		else{
			System.out.println("您输入的属性不存在，不能为您求下近似");
			return null;
		}

	}
	//H(D|C)
	float sigOfC_D(ArrayList<Integer> alChar) throws CloneNotSupportedException
	{
		float sig_C ;
		sig_C = 0;
		DecisionTable temp = (DecisionTable)this.clone();      
		Iterator<MySet> equClass_c = temp.equivalenceClass2(alChar).iterator();
		while(equClass_c.hasNext())
		{
			MySet C_i=equClass_c.next();
			Iterator<Integer> itAllDecisionAttr= this.getDecisionSet().iterator();
			DecisionTable tempDT = (DecisionTable)this.clone();
			int U = C_i.card();
			ArrayList<Boolean> flag = new ArrayList<Boolean>(0);
			
			for(int i=0; i < U ; i++){
				flag.add(false);
			}

			ArrayList<MySet> equClass = new ArrayList<MySet>(0);
			
			for(int i=0 ; i< U ; i++){	
				int s = (int)C_i.keyAt(i);
				if(flag.get(i)!= true ){
					MySet temp1 = new MySet();
					temp1.add(s);
					flag.set(i,true);
					for(int j=i+1; j < U ; j++){
						int s2 = (int)C_i.keyAt(j);			
						if(flag.get(j) !=  true){							
							if(tempDT.getElement(s).getDecision().equals(tempDT.getElement(s2).getDecision())){				
								temp1.add(s2);
								flag.set(j, true);
							}
						}
					}
					equClass.add(temp1);
				}
			}
			float sig_t = 0;
			Iterator<MySet> fff = equClass.iterator();
			while(fff.hasNext()){
				float  P_x = (float)C_i.card();
				float  p_xy = (float)fff.next().toIntArrayList().size();
				sig_t += (p_xy/P_x)*(   (float)  Math.log((double)(p_xy / P_x) ) / Math.log((double)2) );

			}
			sig_t = sig_t*((float)C_i.card()/temp.numberOfElements());
			sig_C += sig_t;
		}
		return  (float) (sig_C*(-1.0)); 
	}	
	ArrayList<MySet> equivalenceClass2(ArrayList<Integer> alChar) throws CloneNotSupportedException{
		boolean availablePara_C = true,availablePara_D=true;
		Iterator<Integer> itPara = alChar.iterator();
		while(itPara.hasNext()){
			int temp_At=itPara.next();
			if(!this.containsConditionAttribute(temp_At))
				availablePara_C = false;
			if(!this.containsDecisionAttribute(temp_At))
				availablePara_D = false;
		}
		if(availablePara_C && !availablePara_D){
			ArrayList<Integer> conditionsToBeDeleted = new ArrayList<Integer>(0);
			Iterator<Integer> itAllConditionAttr= this.getConditionSet().iterator();
			int tempChar;
			while(itAllConditionAttr.hasNext()){
				tempChar = itAllConditionAttr.next();
				//判断是否为其余属性
				if(!alChar.contains(tempChar)){
					conditionsToBeDeleted.add(tempChar);
				}
			}
			Iterator<Integer> itconditionsToBeDeleted = conditionsToBeDeleted.iterator();
			DecisionTable tempDT = (DecisionTable)this.clone();
			while(itconditionsToBeDeleted.hasNext()){
				tempDT.removeConditionAttribute(itconditionsToBeDeleted.next());		
			}
			int U = tempDT.numberOfElements();
			int length = tempDT.getConditionSet().size();	
			float ss[][] = tempDT.to_Condition_table();
			float M_m[][] = new float [length][2];
             
			for(int j = 0 ; j < length;j++){
				M_m[j][0]=-1f;
        		M_m[j][1]=1000000f;
			}
        
			for(int j = 0 ; j < length;j++){
				for(int i = 0 ; i < U ; i++){
					M_m[j][0]=Math.max(M_m[j][0], ss[i][j]);
					M_m[j][1]=Math.min(M_m[j][1], ss[i][j]);
				}
			}
        
			ArrayList<Integer> List = new ArrayList<Integer>(0);
			Iterator<MyElement> it = tempDT.getDT().iterator();
    	
			while(it.hasNext()){
				List.add(it.next().getU());			}	

			for(int i = 0 ; i < length ; i++){		//3,for(i =1 ; i 
				Map<Integer,LinkedList> que = new LinkedHashMap<Integer,LinkedList>();
				int tem =  (int) ((int)M_m[i][0]-(int)M_m[i][1]+1);
				for(int k  = 0 ; k < tem ; k++){   //j建立Mi-mi+1空队列
					LinkedList lk = new LinkedList();
					que.put(k,lk);
				}
				for(int j = 0 ; j < List.size() ; j++){
					int num = List.get(j);        
					Float e = tempDT.getElement(num).getCondition().get(i);	
					LinkedList lk = (LinkedList) que.get((int)(e - M_m[i][1]));
					lk.add(num);
					que.put((int)(e - M_m[i][1]),lk);
				}

				List.clear();
				for(int j = 0 ; j < que.size(); j++){//第i趟收集结果
					List.addAll(que.get(j));
				}
			}
		
			ArrayList<MySet> equClass = new ArrayList<MySet>(0);
			MySet temp = new MySet();	
			temp.add(List.get(0));
		
			for(int i = 1 ; i < List.size() ; i++){//第i条记录
				boolean  flag =  true;
				for(int j = 0 ;  j < length ; j++){//第j个属性
					float  f_j_i=tempDT.getElement(List.get(i)).getCondition().get(j);  //第i条记录第j个属性的取值
					float  f_j2_i = tempDT.getElement(List.get(i-1)).getCondition().get(j);  //第i-1条记录第j个属性的取值
//					System.out.println(List.get(i)+" : "+f_j_i+"   "+List.get(i-1)+" :"+f_j2_i+" "+j);
					if(f_j_i != f_j2_i){
						flag = false;
						break;
					}
				}	
				if(flag){
					temp.add(List.get(i));
					if(i==List.size()-1){
						MySet temp3 = new MySet();	
						for(int  k = 0 ; k < temp.card()  ; k++){
							temp3.add(temp.keyAt(k));
						}
					equClass.add(temp3);
					}
				}
				else{
//					System.out.println(temp.toIntArrayList()+" 第 "+i+" ci");
					MySet temp2 = new MySet();	
					for(int  k = 0 ; k < temp.card()  ; k++){
						temp2.add(temp.keyAt(k));
					}
					equClass.add(temp2);
//					System.out.println("#### "+temp2.toIntArrayList());
					temp.clear();
					temp.add(List.get(i));
//					System.out.println("#### "+temp.toIntArrayList()+" "+List.get(i)+" "+i);
					if(i==List.size()-1){
						MySet temp3 = new MySet();	
//						System.out.println("*** "+temp.toIntArrayList()+" "+List.get(i)+" "+i);
						temp3.add(temp.keyAt(0));
						equClass.add(temp3);
					}
				}
			}
			return equClass;
		}
		else if(!availablePara_C && availablePara_D){	
			Iterator<Integer> itAllDecisionAttr= this.getDecisionSet().iterator();
			DecisionTable tempDT = (DecisionTable)this.clone();
			int U = tempDT.numberOfElements();
			int length = tempDT.getDecisionSet().size();	
			float ss[][] = tempDT.to_Decision_table();
			float M_m[][] = new float [length][2];
			
			for(int j = 0 ; j < length;j++){
				M_m[j][0]=-1f;
        		M_m[j][1]=1000000f;
			}
        
			for(int j = 0 ; j < length;j++){
				for(int i = 0 ; i < U ; i++){
					M_m[j][0]=Math.max(M_m[j][0], ss[i][j]);
					M_m[j][1]=Math.min(M_m[j][1], ss[i][j]);
				}
			}
        
			ArrayList<Integer> List = new ArrayList<Integer>(0);
			Iterator<MyElement> it = tempDT.getDT().iterator();
    	
			while(it.hasNext()){
				List.add(it.next().getU());		//保存x1,x2，xn编号
			}	

			for(int i = 0 ; i < length ; i++){		//3,for(i =1 ; i 
				Map<Integer,LinkedList> que = new LinkedHashMap<Integer,LinkedList>();
				int tem =  (int) ((int)M_m[i][0]-(int)M_m[i][1]+1);
				for(int k  = 0 ; k < tem ; k++){   //j建立Mi-mi+1空队列
					LinkedList lk = new LinkedList();
					que.put(k,lk);
				}
				for(int j = 0 ; j < List.size() ; j++){
					int num = List.get(j);        
					Float e = tempDT.getElement(num).getDecision().get(i);	
					LinkedList lk = (LinkedList) que.get((int)(e - M_m[i][1]));
					lk.add(num);
					que.put((int)(e - M_m[i][1]),lk);
				}

				List.clear();
				for(int j = 0 ; j < que.size(); j++){//第i趟收集结果
					List.addAll(que.get(j));
				}
			}
		
			ArrayList<MySet> equClass = new ArrayList<MySet>(0);
			MySet temp = new MySet();	
			temp.add(List.get(0));
		
			for(int i = 1 ; i < List.size() ; i++){//第i条记录
				boolean  flag =  true;
				for(int j = 0 ;  j < length ; j++){//第j个属性
					float  f_j_i=tempDT.getElement(List.get(i)).getDecision().get(j);  //第i条记录第j个属性的取值
					float  f_j2_i = tempDT.getElement(List.get(i-1)).getDecision().get(j);  //第i-1条记录第j个属性的取值
//					System.out.println(List.get(i)+" : "+f_j_i+"   "+List.get(i-1)+" :"+f_j2_i+" "+j);
					if(f_j_i != f_j2_i){
						flag = false;
						break;
					}
				}	
				if(flag){
					temp.add(List.get(i));
					if(i==List.size()-1){
						MySet temp3 = new MySet();	
						for(int  k = 0 ; k < temp.card()  ; k++){
							temp3.add(temp.keyAt(k));
						}
					equClass.add(temp3);
					}
				}
				else{
//					System.out.println(temp.toIntArrayList()+" 第 "+i+" ci");
					MySet temp2 = new MySet();	
					for(int  k = 0 ; k < temp.card()  ; k++){
						temp2.add(temp.keyAt(k));
					}
					equClass.add(temp2);
//					System.out.println("#### "+temp2.toIntArrayList());
					temp.clear();
					temp.add(List.get(i));
//					System.out.println("#### "+temp.toIntArrayList()+" "+List.get(i)+" "+i);
					if(i==List.size()-1){
						MySet temp3 = new MySet();	
//						System.out.println("*** "+temp.toIntArrayList()+" "+List.get(i)+" "+i);
						temp3.add(temp.keyAt(0));
						equClass.add(temp3);
					}
				}
			}
			return equClass;
		}
		else{
			System.out.println("您输入的属性不存在，不能为您求相应等价类");
			ArrayList<MySet> equClass = new ArrayList<MySet>(0);
			return equClass;
		}
	}
	DecisionTable attributeReduct() throws CloneNotSupportedException
	{
		DecisionTable reduction = (DecisionTable)this.clone();
		DecisionTable temp = (DecisionTable)this.clone();
		ArrayList<Integer> C = reduction.getConditionSet();
		Iterator<Integer> it = C.iterator();
		MySet pos = this.POS();//原决策表中D的C正域
		
		while(it.hasNext())
		{
			if(temp.removeConditionAttribute(it.next()).POS().isEqual(pos))
			{
				reduction = temp.clone();
			}
			else
			{
				temp = reduction.clone();
			}
		}
		return reduction;
	}
	DecisionTable attributeReductByRely() throws CloneNotSupportedException
	{
		DecisionTable reduction = this.clone();
		DecisionTable tempDT;
		double r = this.relyDegreeOfDToC();
		
		while(reduction.relyDegreeOfDToC() == r)
		{
			double sig = 1.0d;
			int index = 0;
			tempDT = reduction.clone();
			ArrayList<Integer> condition = reduction.getConditionSet();
			for(int i=0; i<condition.size(); i++)
			{
				if(reduction.sigOfAttribute(condition.get(i)) <sig)
				{
					sig = reduction.sigOfAttribute(condition.get(i));
					index = i;
				}
			}
			if(reduction.removeConditionAttribute(condition.get(index)).relyDegreeOfDToC() == r)
			{
				continue;
			}
			else
			{
				reduction = tempDT.clone();
				break;
			}
		}
		return reduction;
	}
	void print()
	{
		Iterator<Integer> itAttribute;
		itAttribute = this.getConditionSet().iterator();
		while(itAttribute.hasNext())
		{
			System.out.print(itAttribute.next() + "  ");
		}
		System.out.print("\t->");
		itAttribute = this.getDecisionSet().iterator();
		while(itAttribute.hasNext())
		{
			System.out.print("  " + itAttribute.next());
		}
		System.out.println();
	}
	
	private ArrayList<Integer> conditionSet = new ArrayList<Integer>(0);
	private ArrayList<Integer> decisionSet = new ArrayList<Integer>(0);
	private ArrayList<MyElement> DT = new ArrayList<MyElement>(0);
	int serialNumberOfElement;

	
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
public class MySet implements Cloneable
{
	public MySet(){}
	//用数组初始化集合
	public MySet(float A[])
	{
		for(float e : A)
		{
			arrayList.add(e);
		}
	}
	public MySet(MySet s)
	{
		arrayList = s.arrayList;
	}
	public MySet(ArrayList<Float> al)
	{
		arrayList = al;
	}
	public MySet clone() throws CloneNotSupportedException
	{
		MySet cloned = new MySet();
				
		Iterator<Float> itArrayList = this.arrayList.iterator();
		while(itArrayList.hasNext())
		{
			cloned.arrayList.add(itArrayList.next());
		}
		
		return cloned;
	}
	boolean isEmpty()
	{
		return arrayList.isEmpty();
	}
	int card()
	{
		return arrayList.size();
	}
	void clear()
	{
		arrayList.clear();
	}
	int find(float a)
	{
		for(int i=0; i<this.card();i++)
		{
			if(a == this.keyAt(i))
			{
				return i;
			}
		}
		return -1;
	}
	float keyAt(int loc)
	{
		return arrayList.get(loc);
	}
	void setKey(int loc,float val)
	{
		arrayList.set(loc, val);
	}
	void sort()
	{
		Collections.sort(arrayList);
	}
	void remove(float a)
	{
		if(-1 != find(a))
		{
			ArrayList<Float> temp = new ArrayList<Float>(0);
			for(int i=0;i<arrayList.size();i++)
			{
				if(arrayList.get(i) != a)
				{
					temp.add(arrayList.get(i));
				}
			}
			arrayList = temp;
		}
	}
	void add(float i)
	{
		arrayList.add(i);
	}
	boolean belongTo(MySet s)
	{
		for(float e : arrayList)
		{
			if(-1 == s.find(e))
				return false;
		}
		return true;
	}
	boolean isEqual(MySet s)
	{
		if(this.belongTo(s) && s.belongTo(this))
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	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("参数中集合并非当前集的子集，不能进行该运算");
			return null;
		}
	}
	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;
	}
	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;
	}
	ArrayList<Float> toIntArrayList()
	{
		ArrayList<Float> temp = new ArrayList<Float>(0);
		for(int i=0; i<this.card(); i++)
		{
			temp.add(this.keyAt(i));
		}
		return temp;
	}
	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<Float> arrayList = new ArrayList<Float>(0);
}

上面最基本的三个类，根据最基本的3个类添加自己代码部分，实现功能。