java如何做聚类分析_K-means算法的Java实现 聚类分析681个三国武将
一，k-means算法介紹：
k-means算法接受輸入量 k ；然后將n個數據對象劃分為 k個聚類以便使得所獲得的聚類滿足：同一聚類中的對象相似度較高；而不同聚類中的對象相似度較小。聚類相似度是利用各聚類中對象的均值所獲得一個“中心對象”(引力中心)來進行計算的。k個聚類具有以下特點：各聚類本身盡可能的緊湊，而各聚類之間盡可能的分開。 k個聚類具有以下特點：各聚類本身盡可能的緊湊，而各聚類之間盡可能的分開。
k-means算法的工作過程說明如下：首先從n個數據對象任意選擇 k 個對象作為初始聚類中心；而對于所剩下其它對象，則根據它們與這些聚類中心的相似度(距離)，分別將它們分配給與其最相似的(聚類中心所代表的)聚類；然后再計算每個所獲新聚類的聚類中心(該聚類中所有對象的均值)；不斷重復這一過程直到標準測度函數開始收斂為止。一般都采用均方差作為標準測度函數。k個聚類具有以下特點：各聚類本身盡可能的緊湊，而各聚類之間盡可能的分開。
二，k-means算法基本步驟：
(1) 從 n個數據對象任意選擇 k 個對象作為初始聚類中心；
(2) 根據每個聚類對象的均值(中心對象)，計算每個對象與這些中心對象的距離；并根據最小距離重新對相應對象進行劃分；
(3) 重新計算每個(有變化)聚類的均值(中心對象)；
(4) 計算標準測度函數，當滿足一定條件，如函數收斂時，則算法終止；如果條件不滿足則回到步驟(2)，不斷重復直到標準測度函數開始收斂為止。(一般都采用均方差作為標準測度函數。)
三，k-means算法的java實現：
一共有七個類，General.java代表武將對象, Distance.java距離類計算各個武將到中心武將之間的距離, Cluster.java聚類對象包含一個中心武將和該聚類中所有武將, Kmeans.java核心的聚類算法類, Tool.java工具類用于轉換武將的星級為數字等操作, TestKmeans.java測試類即入口文件, DomParser.java用于讀取xml中的681個武將。
具體思路：先從general.xml文件中讀取681個武將，然后隨機選取初始類中心，計算各個武將到中心武將的距離，根據最小的距離進行聚類，然后重新根據平均值新的聚類的類中心，重新計算各個武將到新的中心武將的距離，直到更新后的聚類與原來的聚類包含的武將不再改變，即收斂時結束。
具體代碼如下：
1,General.java
packagekmeans;publicclassGeneral?{
privateString?name;//?姓名
privateintrender;//?星級
privateinttongshai;//?統帥
privateintwuli;//?武力
privateintzhili;//?智力
privateintpolic;//?政治
privateintqiangbin;//?槍兵
privateintjibin;//?戟兵
privateintnubin;//?弩兵
privateintqibin;//?騎兵
privateintbinqi;//?兵器
privateinttongwu;//?統武
privateinttongzhi;//?統智
privateinttongwuzhi;//?統武智
privateinttongwuzhizheng;//?統武智政
privateintsalary;//?50級工資
publicGeneral(intrender,?String?name,inttongshai,intwuli,intzhili,
intpolic,intqiangbin,intjibin,intnubin,intqibin,
intbinqi,inttongwu,inttongzhi,inttongwuzhi,
inttongwuzhizheng,intsalary)?{
super();
this.name?=?name;
this.render?=?render;
this.tongshai?=?tongshai;
this.wuli?=?wuli;
this.zhili?=?zhili;
this.polic?=?polic;
this.qiangbin?=?qiangbin;
this.jibin?=?jibin;
this.nubin?=?nubin;
this.qibin?=?qibin;
this.binqi?=?binqi;
this.tongwu?=?tongwu;
this.tongzhi?=?tongzhi;
this.tongwuzhi?=?tongwuzhi;
this.tongwuzhizheng?=?tongwuzhizheng;
this.salary?=?salary;
}
publicGeneral(intrender,inttongshai,intwuli,intzhili,intpolic,
intqiangbin,intjibin,intnubin,intqibin,intbinqi,
inttongwu,inttongzhi,inttongwuzhi,inttongwuzhizheng,
intsalary)?{
super();
this.name?="聚類中心";
this.render?=?render;
this.tongshai?=?tongshai;
this.wuli?=?wuli;
this.zhili?=?zhili;
this.polic?=?polic;
this.qiangbin?=?qiangbin;
this.jibin?=?jibin;
this.nubin?=?nubin;
this.qibin?=?qibin;
this.binqi?=?binqi;
this.tongwu?=?tongwu;
this.tongzhi?=?tongzhi;
this.tongwuzhi?=?tongwuzhi;
this.tongwuzhizheng?=?tongwuzhizheng;
this.salary?=?salary;
}
publicGeneral()?{
}
@Override
publicString?toString()?{
return"武將?[name="+?name?+",?render="+?Tool.dxingji(render)
+",?tongshai="+?tongshai?+",?wuli="+?wuli?+",?zhili="
+?zhili?+",?polic="+?polic?+",?qiangbin="
+?Tool.dchange(qiangbin)?+",?jibin="+?Tool.dchange(jibin)
+",?nubin="+?Tool.dchange(nubin)?+",?qibin="
+?Tool.dchange(qibin)?+",?binqi="+?Tool.dchange(binqi)
+",?tongwu="+?tongwu?+",?tongzhi="+?tongzhi
+",?tongwuzhi="+?tongwuzhi?+",?tongwuzhizheng="
+?tongwuzhizheng?+",?salary="+?salary?+"]";
}
publicString?getName()?{
returnname;
}
publicvoidsetName(String?name)?{
this.name?=?name;
}
publicintgetRender()?{
returnrender;
}
publicvoidsetRender(intrender)?{
this.render?=?render;
}
publicintgetTongshai()?{
returntongshai;
}
publicvoidsetTongshai(inttongshai)?{
this.tongshai?=?tongshai;
}
publicintgetWuli()?{
returnwuli;
}
publicvoidsetWuli(intwuli)?{
this.wuli?=?wuli;
}
publicintgetZhili()?{
returnzhili;
}
publicvoidsetZhili(intzhili)?{
this.zhili?=?zhili;
}
publicintgetPolic()?{
returnpolic;
}
publicvoidsetPolic(intpolic)?{
this.polic?=?polic;
}
publicintgetQiangbin()?{
returnqiangbin;
}
publicvoidsetQiangbin(intqiangbin)?{
this.qiangbin?=?qiangbin;
}
publicintgetJibin()?{
returnjibin;
}
publicvoidsetJibin(intjibin)?{
this.jibin?=?jibin;
}
publicintgetNubin()?{
returnnubin;
}
publicvoidsetNubin(intnubin)?{
this.nubin?=?nubin;
}
publicintgetQibin()?{
returnqibin;
}
publicvoidsetQibin(intqibin)?{
this.qibin?=?qibin;
}
publicintgetBinqi()?{
returnbinqi;
}
publicvoidsetBinqi(intbinqi)?{
this.binqi?=?binqi;
}
publicintgetTongwu()?{
returntongwu;
}
publicvoidsetTongwu(inttongwu)?{
this.tongwu?=?tongwu;
}
publicintgetTongzhi()?{
returntongzhi;
}
publicvoidsetTongzhi(inttongzhi)?{
this.tongzhi?=?tongzhi;
}
publicintgetTongwuzhi()?{
returntongwuzhi;
}
publicvoidsetTongwuzhi(inttongwuzhi)?{
this.tongwuzhi?=?tongwuzhi;
}
publicintgetTongwuzhizheng()?{
returntongwuzhizheng;
}
publicvoidsetTongwuzhizheng(inttongwuzhizheng)?{
this.tongwuzhizheng?=?tongwuzhizheng;
}
publicintgetSalary()?{
returnsalary;
}
publicvoidsetSalary(intsalary)?{
this.salary?=?salary;
}
}
2,Distance.java
packagekmeans;/**
*?這個類用于計算距離的。。
*
*/
publicclassDistance?{
intdest;//?目的
intsource;//?源
doubledist;//?歐式距離
publicintgetDest()?{
returndest;
}
publicvoidsetDest(intdest)?{
this.dest?=?dest;
}
publicintgetSource()?{
returnsource;
}
publicvoidsetSource(intsource)?{
this.source?=?source;
}
publicdoublegetDist()?{
returndist;
}
publicvoidsetDist(doubledist)?{
this.dist?=?dist;
}
/**
*?計算源和目的的距離
*?@param?dest?目的武將
*?@param?source?源武將
*?@param?dist?兩者間的距離
*/
publicDistance(intdest,intsource,doubledist)?{
this.dest?=?dest;
this.source?=?source;
this.dist?=?dist;
}
publicDistance()?{
}
}
3,Cluster.java
packagekmeans;importjava.util.ArrayList;
publicclassCluster?{
privateintcenter;//?聚類中心武將的id
privateArrayList?ofCluster?=newArrayList();//?屬于這個聚類的武將的集合
publicintgetCenter()?{
returncenter;
}
publicvoidsetCenter(intcenter)?{
this.center?=?center;
}
publicArrayList?getOfCluster()?{
returnofCluster;
}
publicvoidsetOfCluster(ArrayList?ofCluster)?{
this.ofCluster?=?ofCluster;
}
publicvoidaddGeneral(General?general)?{
if(!(this.ofCluster.contains(general)))
this.ofCluster.add(general);
}
}
4,Kmeans.java
packagekmeans;
importjava.util.*;
publicclassKmeans?{
publicArrayList?allGenerals?=null;
publicinttotalNumber?=0;//?得到所有的武將數目
publicintK?=0;//?假設K=10
publicKmeans()?{
allGenerals?=newDomParser().prepare();
totalNumber?=?allGenerals.size();
K?=3;
}
//?第一次隨機選取聚類中心
publicSet?firstRandom()?{
Set?center?=newHashSet();//?聚類中心的點的id,采用set保證不會有重復id
Random?ran?=newRandom();
introll?=?ran.nextInt(totalNumber);
while(center.size()?
roll?=?ran.nextInt(totalNumber);
center.add(roll);
}
returncenter;
}
//?根據聚類中心初始化聚類信息
publicArrayList?init(Set?center)?{
ArrayList?cluster?=newArrayList();//?聚類?的數組
Iterator?it?=?center.iterator();
while(it.hasNext())?{
Cluster?c?=newCluster();//?代表一個聚類
c.setCenter(it.next());
cluster.add(c);
}
returncluster;
}
/**
*?計算各個武將到各個聚類中心的距離，重新聚類
*
*?@param?cluster
*????????????聚類數組,用來聚類的，根據最近原則把武將聚類
*?@param?center
*????????????中心點id,用于計算各個武將到中心點的距離?return?cluster?聚類后的所有聚類組成的數組
*/
publicArrayList?juLei(Set?center,
ArrayList?cluster)?{
ArrayList?distence?=newArrayList();//?存放距離信息,表示每個點到各個中心點的距離組成的數組
General?source?=null;
General?dest?=null;
intid?=0;//?目的節點id
intid2?=0;//?源節點id
Object[]?p?=?center.toArray();//?p?為聚類中心點id數組
booleanflag?=false;
//?分別計算各個點到各個中心點的距離，并將距離最小的加入到各個聚類中，進行聚類
for(inti?=0;?i?
//?每個點計算完,并聚類到距離最小的聚類中就清空距離數組
distence.clear();
//?計算到j個類中心點的距離,便利各個中心點
for(intj?=0;?j?
//?如果該點不在中心點內?則計算距離
if(!(center.contains(i)))?{
flag?=true;
//?計算距離
source?=?allGenerals.get(i);//?某個點
dest?=?allGenerals.get((Integer)?p[j]);//?各個?中心點
//?計算距離并存入數組
distence.add(newDistance((Integer)?p[j],?i,?Tool.juli(
source,?dest)));
}else{
flag?=false;
}
}
//?說明計算完某個武將到類中心的距離,開始比較
if(flag?==true)?{
//?排序比較一個點到各個中心的距離的大小,找到距離最小的武將的?目的id,和源id,
//?目的id即類中心點id，這個就歸到這個中心點所在聚類中
doublemin?=?distence.get(0).getDist();//?默認第一個distance距離是最小的
//?從1開始遍歷distance數組
intminid?=0;
for(intk?=1;?k?
if(min?>?distence.get(k).getDist())?{
min?=?distence.get(k).getDist();
id?=?distence.get(k).getDest();//?目的，即類中心點
id2?=?distence.get(k).getSource();//?某個武將
minid?=?k;
}else{
id?=?distence.get(minid).getDest();
id2?=?distence.get(minid).getSource();
}
}
//?遍歷cluster聚類數組，找到類中心點id與最小距離目的武將id相同的聚類
for(intn?=0;?n?
//?如果和中心點的id相同?則setError
if(cluster.get(n).getCenter()?==?id)?{
cluster.get(n).addGeneral(allGenerals.get(id2));//?將與該聚類中心距離最小的武將加入該聚類
break;
}
}
}
}
returncluster;
}
//?產生新的聚類中心點數組
publicSet?updateCenter()?{
Set?center?=newHashSet();
for(inti?=0;?i?
center.add(i);
}
returncenter;
}
//?更新聚類中心,?求平均值
publicArrayList?updateCluster(ArrayList?cluster)?{
ArrayList?result?=newArrayList();
//?重新產生的新的聚類中心組成的數組
//?k個聚類進行更新聚類中心
for(intj?=0;?j?
ArrayList?ps?=?cluster.get(j).getOfCluster();//?該聚類的所有?武將
//?組成的數組
ps.add(allGenerals.get(cluster.get(j).getCenter()));//?同時將該類中心對應的武將加入該武將數組
intsize?=?ps.size();//?該聚類的長度大小
//?計算和，然后在計算平均值
intsumrender?=0,?sumtongshai?=0,?sumwuli?=0,?sumzhili?=0,?sumjibin?=0,?sumnubin?=0,?sumqibin?=0,?sumpolic?=0,?sumqiangbin?=0,?sumbinqi?=0,?sumtongwu?=0,?sumtongzhi?=0,?sumtongwuzhi?=0,?sumtongwuzhizheng?=0,?sumsalary?=0;
for(intk1?=0;?k1?
sumrender?+=?ps.get(k1).getRender();
sumtongshai?+=?ps.get(k1).getRender();
sumwuli?+=?ps.get(k1).getWuli();
sumzhili?+=?ps.get(k1).getZhili();
sumjibin?+=?ps.get(k1).getJibin();
sumnubin?+=?ps.get(k1).getNubin();
sumqibin?+=?ps.get(k1).getQibin();
sumpolic?+=?ps.get(k1).getPolic();
sumqiangbin?+=?ps.get(k1).getQiangbin();
sumbinqi?+=?ps.get(k1).getBinqi();
sumtongwu?+=?ps.get(k1).getTongwu();
sumtongzhi?+=?ps.get(k1).getTongzhi();
sumtongwuzhi?+=?ps.get(k1).getTongwuzhi();
sumtongwuzhizheng?+=?ps.get(k1).getTongwuzhizheng();
sumsalary?+=?ps.get(k1).getSalary();
}
//?產生新的聚類，然后加入到聚類數組中
Cluster?newCluster?=newCluster();
newCluster.setCenter(j);
//?計算平均值并構造新的武將對象
newCluster.addGeneral(newGeneral(sumrender?/?size,?sumtongshai
/?size,?sumwuli?/?size,?sumzhili?/?size,?sumjibin?/?size,
sumnubin?/?size,?sumqibin?/?size,?sumpolic?=0,
sumqiangbin?=0,?sumbinqi?/?size,?sumtongwu?/?size,
sumtongzhi?/?size,?sumtongwuzhi?/?size,?sumtongwuzhizheng
/?size,?sumsalary?/?size));
result.add(newCluster);
}
returnresult;
}
/**
*?計算各個武將到各個更新后的聚類中心的距離，重新聚類
*?@param?update?更新后的聚類中心
*?@param?cluster?要存儲的聚類中心
*/
publicArrayList?updateJuLei(ArrayList?update,
ArrayList?cluster)?{
ArrayList?distence?=newArrayList();//?存放距離信息,表示每個點到各個中心點的距離組成的數組
General?source?=null;
General?dest?=null;
intid?=0;//?目的節點id
intid2?=0;//?源節點id
//Object[]?p?=?center.toArray();//?p?為聚類中心點id數組
booleanflag?=false;
//?分別計算各個點到各個中心點的距離，并將距離最小的加入到各個聚類中，進行聚類
for(inti?=0;?i?
//?每個點計算完,并聚類到距離最小的聚類中就清空距離數組
distence.clear();
//?計算到j個類中心點的距離,便利各個中心點
//for?(int?j?=?0;?j?
for(intj?=0;?j?
//?如果該點不在中心點內?則計算距離
//if?(!(center.contains(i)))?{
flag?=true;
//?計算距離
source?=?allGenerals.get(i);//?某個點
//?dest?=?allGenerals.get((Integer)?p[j]);//?各個?中心點
dest?=?update.get(j).getOfCluster().get(0);//?各個?中心點
//?計算距離并存入數組
//distence.add(new?Distance((Integer)?p[j],?i,?Tool.juli(
distence.add(newDistance(update.get(j).getCenter(),?i,?Tool.juli(
source,?dest)));
/*}?else?{
flag?=?false;
}*/
}
//?說明計算完某個武將到類中心的距離,開始比較
if(flag?==true)?{
//?排序比較一個點到各個中心的距離的大小,找到距離最小的武將的?目的id,和源id,
//?目的id即類中心點id，這個就歸到這個中心點所在聚類中
doublemin?=?distence.get(0).getDist();//?默認第一個distance距離是最小的
//?從1開始遍歷distance數組
intmid?=0;
for(intk?=1;?k?
if(min?>?distence.get(k).getDist())?{
min?=?distence.get(k).getDist();
id?=?distence.get(k).getDest();//?目的，即類中心點
id2?=?distence.get(k).getSource();//?某個武將
mid?=?k;
}else{
id?=?distence.get(mid).getDest();
id2?=?distence.get(mid).getSource();
}
}
//?遍歷cluster聚類數組，找到類中心點id與最小距離目的武將id相同的聚類
for(intn?=0;?n?
//?如果和中心點的id相同?則setError
if(cluster.get(n).getCenter()?==?id)?{
cluster.get(n).addGeneral(allGenerals.get(id2));//?將與該聚類中心距離最小的武將加入該聚類
}
}
}
}
returncluster;
}
//?不斷循環聚類直到各個聚類沒有重新分配
publicArrayList?getResult()?{
ArrayList?result?=newArrayList();
ArrayList?temp?=newArrayList();
booleanflag?=false;
//?得到隨機中心點然后進行聚類
Set?center?=?firstRandom();
result?=?juLei(center,?init(center));
print(result);
do{
//?重新聚類
ArrayList?up?=?updateCluster(result);//新的聚類中心
ArrayList?cluster?=?init(updateCenter());//?得到更新后的中心點對應的聚類數組
temp?=?updateJuLei(up,?cluster);
//print(temp);
flag?=?isEquals(temp,?result);
result?=?temp;
}while(!flag);
returnresult;
}
publicbooleanisEquals(ArrayList?temp,?ArrayList?result){
booleanflag?=false;
if(temp.size()?!=?result.size()){
returnflag;
}
for(Cluster?tem?:?temp){
for(Cluster?res?:?result){
if(tem.getCenter()?==?res.getCenter()){
flag?=true;
}
}
//?如果找了一輪沒找到?則說明兩個聚類
if(flag?==false){
returnfalse;
}else{//?如果找了一輪找到了，那么接著找
flag?=false;
}
}
//如果代碼能進行到這邊，說明是true
flag?=true;
returnflag;
}
//輸出所有的聚類
publicvoidprint(ArrayList?cs)?{
System.out.println("***************************************");
for(inti?=0;?i?
Cluster?c?=?cs.get(i);
System.out.println("-----------------------------------------------------");
System.out.println("center:?"+?allGenerals.get(c.getCenter()));
ArrayList?p?=?c.getOfCluster();
for(intj?=0;?j?
System.out.println("general:"+p.get(j)+"\n");
}
}
}
}
5,Tool.java
packagekmeans;publicclassTool?{
//將各種武器的精通程度轉為數字
publicstaticintchange(String?str)?{
intresult?=?str.equals("精")??4:?(str.equals("神")??3:?(str
.equals("通")??2:1));
returnresult;
}
//將星級轉為數字
publicstaticintxingji(String?str)?{
intresult?=?str.equals("★★★★★")??5:?(str.equals("★★★★")??4:?(str
.equals("★★★")??3:?(str.equals("★★")??2:1)));
returnresult;
}
//反轉?將各種武器的數字轉為精通程度
publicstaticString?dchange(intstr)?{
String?result?=?str==4?"精":?(str==3?"神":?(str==2?"通":"疏"));
returnresult;
}
//反轉?將數字轉為星級
publicstaticString?dxingji(intstr)?{
String?result?=?str==5?"★★★★★":?(str==4?"★★★★":?(str==3?"★★★":?(str?==2?"★★":"★")));
returnresult;
}
//計算歐式距離?傳入兩個將軍對象。。
publicstaticdoublejuli(General?g1,?General?g2)?{
doubleresult?=?(Double)?Math.sqrt(StrictMath.pow(g1.getRender()?-?g2.getRender(),2)
+?StrictMath.pow(g1.getTongshai()?-?g2.getTongshai(),2)
+?StrictMath.pow(g1.getWuli()?-?g2.getWuli(),2)
+?StrictMath.pow(g1.getZhili()?-?g2.getZhili(),2)
+?StrictMath.pow(g1.getPolic()?-?g2.getPolic(),2)
+?StrictMath.pow(g1.getQiangbin()?-?g2.getQiangbin(),2)
+?StrictMath.pow(g1.getQibin()?-?g2.getQibin(),2)
+?StrictMath.pow(g1.getJibin()?-?g2.getJibin(),2)
+?StrictMath.pow(g1.getNubin()?-?g2.getNubin(),2)
+?StrictMath.pow(g1.getBinqi()?-?g2.getBinqi(),2)
+?StrictMath.pow(g1.getTongwu()?-?g2.getTongwu(),2)
+?StrictMath.pow(g1.getTongzhi()?-?g2.getTongzhi(),2)
+?StrictMath.pow(g1.getTongwuzhizheng()?-?g2.getTongwuzhizheng(),2)
+?StrictMath.pow(g1.getTongwuzhi()?-?g2.getTongwuzhi(),2)
+?StrictMath.pow(g1.getSalary()?-?g2.getSalary(),2)
);
returnresult;
}
}
6,DomParser.java
packagekmeans;importjavax.xml.parsers.*;
importjava.io.*;
importjava.util.ArrayList;
importorg.w3c.dom.*;
importorg.xml.sax.SAXException;
publicclassDomParser?{
privateArrayList?generals?=newArrayList();
publicArrayList?prepare(){
//?get?dom解析器工廠
DocumentBuilderFactory?factory?=?DocumentBuilderFactory.newInstance();
factory.setIgnoringElementContentWhitespace(true);
//?get?dom?解析器
DocumentBuilder?builder?=null;
try{
builder?=?factory.newDocumentBuilder();
}catch(ParserConfigurationException?e)?{
e.printStackTrace();
}
//?解析文檔
Document?doc?=null;
try{
doc?=?builder.parse(newFile("general.xml"));
}catch(SAXException?e)?{
e.printStackTrace();
}catch(IOException?e)?{
e.printStackTrace();
}
//?取得根節點
Element?generalList?=?doc.getDocumentElement();
//?得到所有row節點
NodeList?nodeList?=?generalList.getElementsByTagName("Row");
//?便利所有row節點
for(inti?=1;?i?
System.out.println("------------the?"+?i
+"?element--------------");
Node?row?=?nodeList.item(i);
//?取得所有Data數據
NodeList?attList?=?row.getChildNodes();
//?取得數據中的各個部分,?并加入ArrayList中
generals.add(newGeneral(Tool.xingji(attList.item(1)
.getTextContent()),?attList.item(3).getTextContent(),
Integer.parseInt(attList.item(5).getTextContent()),
Integer.parseInt(attList.item(7).getTextContent()),
Integer.parseInt(attList.item(9).getTextContent()),
Integer.parseInt(attList.item(11).getTextContent()),
Tool.change(attList.item(13).getTextContent()),
Tool.change(attList.item(15).getTextContent()),
Tool.change(attList.item(17).getTextContent()),
Tool.change(attList.item(19).getTextContent()),
Tool.change(attList.item(21).getTextContent()),
Integer.parseInt(attList.item(23).getTextContent()),
Integer.parseInt(attList.item(25).getTextContent()),
Integer.parseInt(attList.item(27).getTextContent()),
Integer.parseInt(attList.item(29).getTextContent()),
Integer.parseInt(attList.item(31).getTextContent())));
System.out.println("?星級:"
+?Tool.xingji(attList.item(1).getTextContent())?+"?姓名:"
+?attList.item(3).getTextContent()?+"?統率:"
+?attList.item(5).getTextContent()?+"?武力:"
+?attList.item(7).getTextContent()?+"?智力:"
+?attList.item(9).getTextContent()?+"?政治:"
+?attList.item(11).getTextContent()?+"槍兵:"
+?Tool.change(attList.item(13).getTextContent())?+"?戟兵:"
+?Tool.change(attList.item(15).getTextContent())?+"?弩兵:"
+?Tool.change(attList.item(17).getTextContent())?+"?騎兵:"
+?Tool.change(attList.item(19).getTextContent())?+"?兵器:"
+?Tool.change(attList.item(21).getTextContent())?+"?統武:"
+?attList.item(23).getTextContent()?+"?統智:"
+?attList.item(25).getTextContent()?+"?統武智:"
+?attList.item(27).getTextContent()?+"?統武智政:"
+?attList.item(29).getTextContent()?+"?50級工資:"
+?attList.item(31).getTextContent()?+"?");
/*
*?for?(int?j?=?0;?j?
*?System.out.println(attList.item(j).getTextContent());?}
*/
}
returngenerals;
}
}
7,TestKmeans.java
packagekmeans;
publicclassTestKmeans?{
publicstaticvoidmain(String[]?args)?{
Kmeans_eold?kmeans?=newKmeans_eold();
kmeans.print(kmeans.getResult());
}
}
附部分general.xml：
xmlns:o="urn:schemas-microsoft-com:office:office"
xmlns:x="urn:schemas-microsoft-com:office:excel"
xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet"
xmlns:html="http://www.w3.org/TR/REC-html40">
2006-09-13T11:21:51Z
2012-04-26T13:39:57Z
14.00
5850
11070
0
90
False
False
x:FullRows="1"ss:DefaultColumnWidth="54"ss:DefaultRowHeight="13.5">
星級
姓名
統率
武力
智力
政治
槍兵
戟兵
弩兵
騎兵
兵器
統武
統智
統武智
統武智政
50級工資
★★★★★
呂布
87
100
26
13
精
神
神
神
疏
161
194
257
350
19250
★★★★★
張飛
85
98
30
22
神
神
疏
精
疏
168
193
264
350
19250
★★★★★
関羽
95
97
75
62
神
神
通
精
疏
165
191
260
347
19085
★★★★★
馬超
88
97
44
26
精
通
疏
神
通
168
187
259
353
19415
★★★★★
趙雲
91
96
76
65
神
通
神
神
疏
192
170
267
329
18095
★★★★★
許褚
65
96
36
20
精
通
疏
通
疏
161
101
197
217
11935
★★★★★
典韋
56
95
35
29
通
精
疏
疏
疏
151
91
186
215
11825
★★★★★
甘寧
86
94
76
18
神
精
精
精
神
181
183
270
351
19305
★★★★★
龐德
80
94
70
44
通
精
精
神
通
174
150
244
288
15840
★★★★★
文醜
78
94
25
25
精
通
精
神
疏
172
103
197
222
12210
★★★★★
黃忠
86
93
60
52
通
神
神
精
疏
185
171
263
321
17655
★★★★★
太史慈
82
93
66
58
精
神
疏
神
疏
175
148
241
299
16445
★★★★★
顏良
79
93
42
32
精
精
疏
神
疏
172
121
214
246
13530
★★★★★
張遼
93
92
78
58
神
神
通
神
通
183
167
257
330
18150
★★★★★
孫策
92
92
69
70
神
精
通
神
精
130
192
230
325
17875
★★★★★
魏延
81
92
69
49
精
神
通
精
疏
173
150
242
291
16005
★★★★★
華雄
81
92
56
40
通
通
疏
神
疏
173
137
229
269
14795
最終運行結果截圖如下：
讀取到得武將數據如圖，
運行后的部分截圖：
【編輯推薦】
【責任編輯：小林 TEL：(010)68476606】
點贊 0
總結
以上是生活随笔為你收集整理的java如何做聚类分析_K-means算法的Java实现 聚类分析681个三国武将的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： java mock私有方法_JMocki
- 下一篇： 使用validate注解做校验以及自定义