一，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