mainroutine.java

实现一个超级聚类程序,具有很好的参考价值.

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.StreamTokenizer;
import java.util.StringTokenizer;
public class MainRoutine 
{
	public final int PERSON_NUMBER = 40;//训练人数
	public final int TEST_NUMBER = 20;//测试的人数
	public final int CLASS_NUMBER = 2;//分类数
	public final int GENE_VECTOR = 114;//每人的基因数
	public double personGenes[][] = new double[PERSON_NUMBER][GENE_VECTOR];//基因数组,一维表示人,二维表示它的基因
	public double testGenes[][] = new double[PERSON_NUMBER][GENE_VECTOR];//后20个用于测试的基因数组
	public void readFile()
	{
		try
		{
			StringTokenizer in = null;
			FileReader myFileReader=new FileReader("data.txt");
			BufferedReader myBufferedReader=new BufferedReader(myFileReader);
			String myString=null;
			//String resultString=new String();
			for(int i=0;i<PERSON_NUMBER+TEST_NUMBER;i++)
			{
				myString=myBufferedReader.readLine();
				{
					//System.out.println(myString);
					in = new StringTokenizer(myString);
					in.nextToken();//跳过文件开始的数字
					if(i<PERSON_NUMBER)
					{
						for(int j=0;j<GENE_VECTOR;j++)
						{
							personGenes[i][j] = Double.parseDouble(in.nextToken());
							//System.out.println(personGenes[i][j]+"this is j"+j);
						}
					}
					else
					{
						for(int k=0;k<GENE_VECTOR;k++)
						{
							testGenes[i-PERSON_NUMBER][k] = Double.parseDouble(in.nextToken());
						}
					}
				}
			}
			myFileReader.close();		
		}
		catch(Exception e)
		{
			System.out.println(e.toString());
		}
	}
	
	public double compare(Person person,PersonClass personClass)//比较人和类之间的基因差异值,距离用超空间欧式距离
	{
		double result=0,tempResult=0;
		for(int i=0;i<GENE_VECTOR;i++)
		{
			tempResult = person.geneVector[i]-personClass.kmeanVector[i];
			result = result +  tempResult*tempResult;//得求出向量间的距离
		}	
		return result;
	}
	
	public boolean classFixed(Person person[])//确定类是否不再改变
	{
		for(int i=0;i<person.length;i++)
		{
			if(person[i].lastMark!=person[i].markClass)
			{
				return false;
			}
		}
		return true;
	}
	
	public void outClass(Person person[],String type)
	{
		
		for(int i=0;i<person.length;i++)
		{
			if(type.equals("training"))
				System.out.println("Training data: person "+i+" belongs to class "+person[i].markClass);
			else
				System.out.println("Testing data: person "+i+" belongs to class "+person[i].markClass);
		}
	}
	public static void main(String[] args)
	{	
		MainRoutine mr = new MainRoutine();
		Person person[] = new Person[mr.PERSON_NUMBER];
		Person testPerson[] = new Person[mr.TEST_NUMBER];
		PersonClass personClass[] = new PersonClass[mr.CLASS_NUMBER];
		mr.readFile();//读取内容至personGenes数组,
		
		for(int i=0;i<mr.PERSON_NUMBER;i++)
		{
			//将第i个person的基因数据及基因总数传给Person对象,用于初始化
			person[i] = new Person(mr.personGenes[i],mr.GENE_VECTOR);
			if(i<mr.TEST_NUMBER)
			{
				testPerson[i] = new Person(mr.testGenes[i],mr.GENE_VECTOR);
			}
						
		}
		/*int t,p=0;
		try
		{
			
			for( t = 0;t<mr.PERSON_NUMBER;t++)
			{
				for( p=0;p<mr.GENE_VECTOR;p++)
					System.out.print(person[t].geneVector[p]+" ");
				System.out.println(t);
			}
		}
		catch(Exception ex)
		{
			System.out.println("P IS "+p);
		}*/
		for(int i=0;i<mr.CLASS_NUMBER;i++)
		{
			//将前CLASS_NUMBER个人的初始基因数据作为初始分类,共CLASS_NUMBER个分类
			personClass[i] = new PersonClass(person[i],mr.GENE_VECTOR);
		}
		int ppp=0;
		while(!mr.classFixed(person)||ppp==0)//每一个person的分类值都不再改变
		{
			
			//计算每一个person与哪一个类的差异最小
			for(int i=0;i<mr.PERSON_NUMBER;i++)
			{
				person[i].lastMark = person[i].markClass;//保存上次记录的类
				for(int j=0;j<mr.CLASS_NUMBER;j++)
				{
					if(j==0)
					{
						//每遍循环开始时,认为每个人的基因与上次循环结果的第0个类差距最小
						person[i].minDistance = mr.compare(person[i],personClass[j]);
						person[i].markClass = 0;
					}
					else if(mr.compare(person[i],personClass[j])<person[i].minDistance)
					{
						//把第i个人的基因信息与第j个类的比较,如果找到一个更小的差异,则更改第i个人的最小距离,并标记最接近类为j
						person[i].minDistance = mr.compare(person[i],personClass[j]);
						person[i].markClass = j;	
					}
				}
			}
			//重划分类
			for(int k=0;k<mr.CLASS_NUMBER;k++)
			{
				for(int m=0;m<mr.GENE_VECTOR;m++)
				{
					personClass[k].temp[m]= 0;//每一个类的基因缓存清0
					personClass[k].personBelongTo = 0;
				}
			}
			//找到每个属于该类的人的基因向量组,添加至该类的临时向量组,并将属于该类的人数加1
			for(int k=0;k<mr.PERSON_NUMBER;k++)
			{
				for(int j=0;j<mr.GENE_VECTOR;j++)
				{	
					personClass[person[k].markClass].temp[j] += person[k].geneVector[j];		
				}	
				personClass[person[k].markClass].personBelongTo++;
			}
			//重新计算类
			for(int k =0;k<mr.CLASS_NUMBER;k++)
			{
				for(int j=0;j<mr.GENE_VECTOR;j++)
				{
					personClass[k].kmeanVector[j] = personClass[k].temp[j]/personClass[k].personBelongTo;	
					//personClass[k].kmeanVector[j] = personClass[k].temp[j];
				}		
			}
			ppp++;
		}//end while
		mr.outClass(person,"training");//输出训练数据的分类结果
		//下面用于测试数据，先计算测试数据属于的分类
		for(int i=0;i<mr.TEST_NUMBER;i++)
		{
			for(int j=0;j<mr.CLASS_NUMBER;j++)
			{
				if(j==0)
				{
					//每遍循环开始时,认为每个人的基因与上次循环结果的第0个类差距最小
					testPerson[i].minDistance = mr.compare(testPerson[i],personClass[j]);
					testPerson[i].markClass = 0;
				}
				else if(mr.compare(testPerson[i],personClass[j])<testPerson[i].minDistance)
				{
					//把第i个人的基因信息与第j个类的比较,如果找到一个更小的差异,则更改第i个人的最小距离,并标记最接近类为j
					testPerson[i].minDistance = mr.compare(testPerson[i],personClass[j]);
					testPerson[i].markClass = j;	
				}
			}
		}
		mr.outClass(testPerson,"testing");	//输出测试结果
		System.out.println("Partition time is "+ppp);//输出迭代次数
	}	
}