kalor

导航

 
K-Means java实现（未用Hadoop版改进）

K-means算法的java实现，聚类分析681个三国武将       

        分类：            java算法2012-05-07 16:58991人阅读评论(5)收藏举报
算法javastringdistancealignmentoffice

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

  1. package kmeans; 
  2.  
  3. publicclass General { 
  4.      
  5.     private String name; // 姓名 
  6.     privateint render; // 星级 
  7.     privateint tongshai; // 统帅 
  8.     privateint wuli; // 武力 
  9.     privateint zhili; // 智力 
  10.     privateint polic; // 政治 
  11.     privateint qiangbin; // 枪兵 
  12.     privateint jibin; // 戟兵 
  13.     privateint nubin; // 弩兵 
  14.     privateint qibin; // 骑兵 
  15.     privateint binqi; // 兵器 
  16.     privateint tongwu; // 统武 
  17.     privateint tongzhi; // 统智 
  18.     privateint tongwuzhi; // 统武智 
  19.     privateint tongwuzhizheng; // 统武智政 
  20.     privateint salary; // 50级工资 
  21.  
  22.     public General(int render, String name, int tongshai, int wuli, int zhili, 
  23.             int polic, int qiangbin, int jibin, int nubin, int qibin, 
  24.             int binqi, int tongwu, int tongzhi, int tongwuzhi, 
  25.             int tongwuzhizheng, int salary) { 
  26.         super(); 
  27.         this.name = name; 
  28.         this.render = render; 
  29.         this.tongshai = tongshai; 
  30.         this.wuli = wuli; 
  31.         this.zhili = zhili; 
  32.         this.polic = polic; 
  33.         this.qiangbin = qiangbin; 
  34.         this.jibin = jibin; 
  35.         this.nubin = nubin; 
  36.         this.qibin = qibin; 
  37.         this.binqi = binqi; 
  38.         this.tongwu = tongwu; 
  39.         this.tongzhi = tongzhi; 
  40.         this.tongwuzhi = tongwuzhi; 
  41.         this.tongwuzhizheng = tongwuzhizheng; 
  42.         this.salary = salary; 
  43.     } 
  44.  
  45.     public General(int render, int tongshai, int wuli, int zhili, int polic, 
  46.             int qiangbin, int jibin, int nubin, int qibin, int binqi, 
  47.             int tongwu, int tongzhi, int tongwuzhi, int tongwuzhizheng, 
  48.             int salary) { 
  49.         super(); 
  50.         this.name = "聚类中心"; 
  51.         this.render = render;  
  52.         this.tongshai = tongshai;  
  53.         this.wuli = wuli; 
  54.         this.zhili = zhili; 
  55.         this.polic = polic; 
  56.         this.qiangbin = qiangbin; 
  57.         this.jibin = jibin; 
  58.         this.nubin = nubin; 
  59.         this.qibin = qibin; 
  60.         this.binqi = binqi; 
  61.         this.tongwu = tongwu; 
  62.         this.tongzhi = tongzhi; 
  63.         this.tongwuzhi = tongwuzhi; 
  64.         this.tongwuzhizheng = tongwuzhizheng; 
  65.         this.salary = salary; 
  66.     } 
  67.  
  68.     public General() { 
  69.     } 
  70.  
  71.     @Override 
  72.     public String toString() { 
  73.         return"武将 [name=" + name + ", render=" + Tool.dxingji(render) 
  74.                 + ", tongshai=" + tongshai + ", wuli=" + wuli + ", zhili=" 
  75.                 + zhili + ", polic=" + polic + ", qiangbin=" 
  76.                 + Tool.dchange(qiangbin) + ", jibin=" + Tool.dchange(jibin) 
  77.                 + ", nubin=" + Tool.dchange(nubin) + ", qibin=" 
  78.                 + Tool.dchange(qibin) + ", binqi=" + Tool.dchange(binqi) 
  79.                 + ", tongwu=" + tongwu + ", tongzhi=" + tongzhi 
  80.                 + ", tongwuzhi=" + tongwuzhi + ", tongwuzhizheng=" 
  81.                 + tongwuzhizheng + ", salary=" + salary + "]"; 
  82.     } 
  83.  
  84.     public String getName() { 
  85.         return name; 
  86.     } 
  87.  
  88.     publicvoid setName(String name) { 
  89.         this.name = name; 
  90.     } 
  91.  
  92.     publicint getRender() { 
  93.         return render; 
  94.     } 
  95.  
  96.     publicvoid setRender(int render) { 
  97.         this.render = render; 
  98.     } 
  99.  
  100.     publicint getTongshai() { 
  101.         return tongshai; 
  102.     } 
  103.  
  104.     publicvoid setTongshai(int tongshai) { 
  105.         this.tongshai = tongshai; 
  106.     } 
  107.  
  108.     publicint getWuli() { 
  109.         return wuli; 
  110.     } 
  111.  
  112.     publicvoid setWuli(int wuli) { 
  113.         this.wuli = wuli; 
  114.     } 
  115.  
  116.     publicint getZhili() { 
  117.         return zhili; 
  118.     } 
  119.  
  120.     publicvoid setZhili(int zhili) { 
  121.         this.zhili = zhili; 
  122.     } 
  123.  
  124.     publicint getPolic() { 
  125.         return polic; 
  126.     } 
  127.  
  128.     publicvoid setPolic(int polic) { 
  129.         this.polic = polic; 
  130.     } 
  131.  
  132.     publicint getQiangbin() { 
  133.         return qiangbin; 
  134.     } 
  135.  
  136.     publicvoid setQiangbin(int qiangbin) { 
  137.         this.qiangbin = qiangbin; 
  138.     } 
  139.  
  140.     publicint getJibin() { 
  141.         return jibin; 
  142.     } 
  143.  
  144.     publicvoid setJibin(int jibin) { 
  145.         this.jibin = jibin; 
  146.     } 
  147.  
  148.     publicint getNubin() { 
  149.         return nubin; 
  150.     } 
  151.  
  152.     publicvoid setNubin(int nubin) { 
  153.         this.nubin = nubin; 
  154.     } 
  155.  
  156.     publicint getQibin() { 
  157.         return qibin; 
  158.     } 
  159.  
  160.     publicvoid setQibin(int qibin) { 
  161.         this.qibin = qibin; 
  162.     } 
  163.  
  164.     publicint getBinqi() { 
  165.         return binqi; 
  166.     } 
  167.  
  168.     publicvoid setBinqi(int binqi) { 
  169.         this.binqi = binqi; 
  170.     } 
  171.  
  172.     publicint getTongwu() { 
  173.         return tongwu; 
  174.     } 
  175.  
  176.     publicvoid setTongwu(int tongwu) { 
  177.         this.tongwu = tongwu; 
  178.     } 
  179.  
  180.     publicint getTongzhi() { 
  181.         return tongzhi; 
  182.     } 
  183.  
  184.     publicvoid setTongzhi(int tongzhi) { 
  185.         this.tongzhi = tongzhi; 
  186.     } 
  187.  
  188.     publicint getTongwuzhi() { 
  189.         return tongwuzhi; 
  190.     } 
  191.  
  192.     publicvoid setTongwuzhi(int tongwuzhi) { 
  193.         this.tongwuzhi = tongwuzhi; 
  194.     } 
  195.  
  196.     publicint getTongwuzhizheng() { 
  197.         return tongwuzhizheng; 
  198.     } 
  199.  
  200.     publicvoid setTongwuzhizheng(int tongwuzhizheng) { 
  201.         this.tongwuzhizheng = tongwuzhizheng; 
  202.     } 
  203.  
  204.     publicint getSalary() { 
  205.         return salary; 
  206.     } 
  207.  
  208.     publicvoid setSalary(int salary) { 
  209.         this.salary = salary; 
  210.     } 
  211.  
  212. }  
package kmeans;

public class General {
	
	private String name; // 姓名
	private int render; // 星级
	private int tongshai; // 统帅
	private int wuli; // 武力
	private int zhili; // 智力
	private int polic; // 政治
	private int qiangbin; // 枪兵
	private int jibin; // 戟兵
	private int nubin; // 弩兵
	private int qibin; // 骑兵
	private int binqi; // 兵器
	private int tongwu; // 统武
	private int tongzhi; // 统智
	private int tongwuzhi; // 统武智
	private int tongwuzhizheng; // 统武智政
	private int salary; // 50级工资

	public General(int render, String name, int tongshai, int wuli, int zhili,
			int polic, int qiangbin, int jibin, int nubin, int qibin,
			int binqi, int tongwu, int tongzhi, int tongwuzhi,
			int tongwuzhizheng, int salary) {
		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;
	}

	public General(int render, int tongshai, int wuli, int zhili, int polic,
			int qiangbin, int jibin, int nubin, int qibin, int binqi,
			int tongwu, int tongzhi, int tongwuzhi, int tongwuzhizheng,
			int salary) {
		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;
	}

	public General() {
	}

	@Override
	public String 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 + "]";
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getRender() {
		return render;
	}

	public void setRender(int render) {
		this.render = render;
	}

	public int getTongshai() {
		return tongshai;
	}

	public void setTongshai(int tongshai) {
		this.tongshai = tongshai;
	}

	public int getWuli() {
		return wuli;
	}

	public void setWuli(int wuli) {
		this.wuli = wuli;
	}

	public int getZhili() {
		return zhili;
	}

	public void setZhili(int zhili) {
		this.zhili = zhili;
	}

	public int getPolic() {
		return polic;
	}

	public void setPolic(int polic) {
		this.polic = polic;
	}

	public int getQiangbin() {
		return qiangbin;
	}

	public void setQiangbin(int qiangbin) {
		this.qiangbin = qiangbin;
	}

	public int getJibin() {
		return jibin;
	}

	public void setJibin(int jibin) {
		this.jibin = jibin;
	}

	public int getNubin() {
		return nubin;
	}

	public void setNubin(int nubin) {
		this.nubin = nubin;
	}

	public int getQibin() {
		return qibin;
	}

	public void setQibin(int qibin) {
		this.qibin = qibin;
	}

	public int getBinqi() {
		return binqi;
	}

	public void setBinqi(int binqi) {
		this.binqi = binqi;
	}

	public int getTongwu() {
		return tongwu;
	}

	public void setTongwu(int tongwu) {
		this.tongwu = tongwu;
	}

	public int getTongzhi() {
		return tongzhi;
	}

	public void setTongzhi(int tongzhi) {
		this.tongzhi = tongzhi;
	}

	public int getTongwuzhi() {
		return tongwuzhi;
	}

	public void setTongwuzhi(int tongwuzhi) {
		this.tongwuzhi = tongwuzhi;
	}

	public int getTongwuzhizheng() {
		return tongwuzhizheng;
	}

	public void setTongwuzhizheng(int tongwuzhizheng) {
		this.tongwuzhizheng = tongwuzhizheng;
	}

	public int getSalary() {
		return salary;
	}

	public void setSalary(int salary) {
		this.salary = salary;
	}

}

 

2,Distance.java

 

[java] view plaincopyprint?
  1.   






[java] view plaincopyprint?




    

  1. package kmeans;  
    2. 

  2. /** 
    3. 

  3.  * 这个类用于计算距离的。。 
    4. 

  4.  * 
    5. 

  5.  */  
    6. 

  6. publicclass Distance {  
    7. 

  7.     int dest;// 目的  
    8. 

  8.     int source;// 源  
    9. 

  9.     double dist;// 欧式距离  
    10. 

  10.   
    11. 

  11.     publicint getDest() {  
    12. 

  12.         return dest;  
    13. 

  13.     }  
    14. 

  14.   
    15. 

  15.     publicvoid setDest(int dest) {  
    16. 

  16.         this.dest = dest;  
    17. 

  17.     }  
    18. 

  18.   
    19. 

  19.     publicint getSource() {  
    20. 

  20.         return source;  
    21. 

  21.     }  
    22. 

  22.   
    23. 

  23.     publicvoid setSource(int source) {  
    24. 

  24.         this.source = source;  
    25. 

  25.     }  
    26. 

  26.   
    27. 

  27.     publicdouble getDist() {  
    28. 

  28.         return dist;  
    29. 

  29.     }  
    30. 

  30.   
    31. 

  31.     publicvoid setDist(double dist) {  
    32. 

  32.         this.dist = dist;  
    33. 

  33.     }  
    34. 

  34.     /** 
    35. 

  35.      * 计算源和目的的距离 
    36. 

  36.      * @param dest 目的武将 
    37. 

  37.      * @param source 源武将 
    38. 

  38.      * @param dist 两者间的距离 
    39. 

  39.      */  
    40. 

  40.     public Distance(int dest, int source, double dist) {  
    41. 

  41.         this.dest = dest;  
    42. 

  42.         this.source = source;  
    43. 

  43.         this.dist = dist;  
    44. 

  44.     }  
    45. 

  45.   
    46. 

  46.     public Distance() {  
    47. 

  47.     }  
    48. 

  48.   
    49. 

  49. }  
    50. 



package kmeans;
/**
 * 这个类用于计算距离的。。
 *
 */
public class Distance {
	int dest;// 目的
	int source;// 源
	double dist;// 欧式距离

	public int getDest() {
		return dest;
	}

	public void setDest(int dest) {
		this.dest = dest;
	}

	public int getSource() {
		return source;
	}

	public void setSource(int source) {
		this.source = source;
	}

	public double getDist() {
		return dist;
	}

	public void setDist(double dist) {
		this.dist = dist;
	}
	/**
	 * 计算源和目的的距离
	 * @param dest 目的武将
	 * @param source 源武将
	 * @param dist 两者间的距离
	 */
	public Distance(int dest, int source, double dist) {
		this.dest = dest;
		this.source = source;
		this.dist = dist;
	}

	public Distance() {
	}

}


3,Cluster.java

 


 






[java] view plaincopyprint?




    

  1.   
    2. 









[java] view plaincopyprint?




    

  1. package kmeans;  
    2. 

  2.   
    3. 

  3. import java.util.ArrayList;  
    4. 

  4.   
    5. 

  5. publicclass Cluster {  
    6. 

  6.     privateint center;// 聚类中心武将的id  
    7. 

  7.     private ArrayList<General> ofCluster = new ArrayList<General>();// 属于这个聚类的武将的集合  
    8. 

  8.   
    9. 

  9.     publicint getCenter() {  
    10. 

  10.         return center;  
    11. 

  11.     }  
    12. 

  12.   
    13. 

  13.     publicvoid setCenter(int center) {  
    14. 

  14.         this.center = center;  
    15. 

  15.     }  
    16. 

  16.   
    17. 

  17.     public ArrayList<General> getOfCluster() {  
    18. 

  18.         return ofCluster;  
    19. 

  19.     }  
    20. 

  20.   
    21. 

  21.     publicvoid setOfCluster(ArrayList<General> ofCluster) {  
    22. 

  22.         this.ofCluster = ofCluster;  
    23. 

  23.     }  
    24. 

  24.   
    25. 

  25.     publicvoid addGeneral(General general) {  
    26. 

  26.         if (!(this.ofCluster.contains(general)))  
    27. 

  27.             this.ofCluster.add(general);  
    28. 

  28.     }  
    29. 

  29. }  
    30. 



package kmeans;

import java.util.ArrayList;

public class Cluster {
	private int center;// 聚类中心武将的id
	private ArrayList<General> ofCluster = new ArrayList<General>();// 属于这个聚类的武将的集合

	public int getCenter() {
		return center;
	}

	public void setCenter(int center) {
		this.center = center;
	}

	public ArrayList<General> getOfCluster() {
		return ofCluster;
	}

	public void setOfCluster(ArrayList<General> ofCluster) {
		this.ofCluster = ofCluster;
	}

	public void addGeneral(General general) {
		if (!(this.ofCluster.contains(general)))
			this.ofCluster.add(general);
	}
}



 


4,Kmeans.java


 






[java] view plaincopyprint?




    

  1.   
    2. 









[java] view plaincopyprint?




    

  1.   
    2. 









[java] view plaincopyprint?




    

  1. package kmeans;  
    2. 

  2.   
    3. 

  3. import java.util.*;  
    4. 

  4.   
    5. 

  5. publicclass Kmeans {  
    6. 

  6.     public ArrayList<General> allGenerals = null;  
    7. 

  7.     publicint totalNumber = 0;// 得到所有的武将数目  
    8. 

  8.     publicint K = 0;// 假设K=10  
    9. 

  9.   
    10. 

  10.     public Kmeans() {  
    11. 

  11.         allGenerals = new DomParser().prepare();  
    12. 

  12.         totalNumber = allGenerals.size();  
    13. 

  13.         K = 3;  
    14. 

  14.     }  
    15. 

  15.   
    16. 

  16.     // 第一次随机选取聚类中心  
    17. 

  17.     public Set<Integer> firstRandom() {  
    18. 

  18.         Set<Integer> center = new HashSet<Integer>();// 聚类中心的点的id,采用set保证不会有重复id  
    19. 

  19.         Random ran = new Random();  
    20. 

  20.         int roll = ran.nextInt(totalNumber);  
    21. 

  21.         while (center.size() < K) {  
    22. 

  22.             roll = ran.nextInt(totalNumber);  
    23. 

  23.             center.add(roll);  
    24. 

  24.         }  
    25. 

  25.         return center;  
    26. 

  26.     }  
    27. 

  27.   
    28. 

  28.     // 根据聚类中心初始化聚类信息  
    29. 

  29.     public ArrayList<Cluster> init(Set<Integer> center) {  
    30. 

  30.         ArrayList<Cluster> cluster = new ArrayList<Cluster>();// 聚类 的数组  
    31. 

  31.         Iterator<Integer> it = center.iterator();  
    32. 

  32.         while (it.hasNext()) {  
    33. 

  33.             Cluster c = new Cluster();// 代表一个聚类  
    34. 

  34.             c.setCenter(it.next());  
    35. 

  35.             cluster.add(c);  
    36. 

  36.         }  
    37. 

  37.         return cluster;  
    38. 

  38.     }  
    39. 

  39.   
    40. 

  40.     /** 
    41. 

  41.      * 计算各个武将到各个聚类中心的距离，重新聚类 
    42. 

  42.      *  
    43. 

  43.      * @param cluster 
    44. 

  44.      *            聚类数组,用来聚类的，根据最近原则把武将聚类 
    45. 

  45.      * @param center 
    46. 

  46.      *            中心点id,用于计算各个武将到中心点的距离 return cluster 聚类后的所有聚类组成的数组 
    47. 

  47.      */  
    48. 

  48.     public ArrayList<Cluster> juLei(Set<Integer> center,  
    49. 

  49.             ArrayList<Cluster> cluster) {  
    50. 

  50.         ArrayList<Distance> distence = new ArrayList<Distance>();// 存放距离信息,表示每个点到各个中心点的距离组成的数组  
    51. 

  51.         General source = null;  
    52. 

  52.         General dest = null;  
    53. 

  53.         int id = 0;// 目的节点id  
    54. 

  54.         int id2 = 0;// 源节点id  
    55. 

  55.         Object[] p = center.toArray();// p 为聚类中心点id数组  
    56. 

  56.         boolean flag = false;  
    57. 

  57.         // 分别计算各个点到各个中心点的距离，并将距离最小的加入到各个聚类中，进行聚类  
    58. 

  58.         for (int i = 0; i < totalNumber; i++) {  
    59. 

  59.             // 每个点计算完,并聚类到距离最小的聚类中就清空距离数组  
    60. 

  60.             distence.clear();  
    61. 

  61.             // 计算到j个类中心点的距离,便利各个中心点  
    62. 

  62.             for (int j = 0; j < center.size(); j++) {  
    63. 

  63.                 // 如果该点不在中心点内 则计算距离  
    64. 

  64.                 if (!(center.contains(i))) {  
    65. 

  65.                     flag = true;  
    66. 

  66.                     // 计算距离  
    67. 

  67.                     source = allGenerals.get(i);// 某个点  
    68. 

  68.                     dest = allGenerals.get((Integer) p[j]);// 各个 中心点  
    69. 

  69.                     // 计算距离并存入数组  
    70. 

  70.                     distence.add(new Distance((Integer) p[j], i, Tool.juli(  
    71. 

  71.                             source, dest)));  
    72. 

  72.                 } else {  
    73. 

  73.                     flag = false;  
    74. 

  74.                 }  
    75. 

  75.             }  
    76. 

  76.             // 说明计算完某个武将到类中心的距离,开始比较  
    77. 

  77.             if (flag == true) {  
    78. 

  78.                 // 排序比较一个点到各个中心的距离的大小,找到距离最小的武将的 目的id,和源id,  
    79. 

  79.                 // 目的id即类中心点id，这个就归到这个中心点所在聚类中  
    80. 

  80.                 double min = distence.get(0).getDist();// 默认第一个distance距离是最小的  
    81. 

  81.                 // 从1开始遍历distance数组  
    82. 

  82.                 int minid = 0;  
    83. 

  83.                 for (int k = 1; k < distence.size(); k++) {  
    84. 

  84.                     if (min > distence.get(k).getDist()) {  
    85. 

  85.                         min = distence.get(k).getDist();  
    86. 

  86.                         id = distence.get(k).getDest();// 目的，即类中心点  
    87. 

  87.                         id2 = distence.get(k).getSource();// 某个武将  
    88. 

  88.                         minid = k;  
    89. 

  89.                     } else {  
    90. 

  90.                         id = distence.get(minid).getDest();  
    91. 

  91.                         id2 = distence.get(minid).getSource();  
    92. 

  92.                     }  
    93. 

  93.                 }  
    94. 

  94.                 // 遍历cluster聚类数组，找到类中心点id与最小距离目的武将id相同的聚类  
    95. 

  95.                 for (int n = 0; n < cluster.size(); n++) {  
    96. 

  96.                     // 如果和中心点的id相同 则setError  
    97. 

  97.                     if (cluster.get(n).getCenter() == id) {  
    98. 

  98.                         cluster.get(n).addGeneral(allGenerals.get(id2));// 将与该聚类中心距离最小的武将加入该聚类  
    99. 

  99.                         break;  
    100. 

  100.                     }  
    101. 

  101.                 }  
    102. 

  102.             }  
    103. 

  103.         }  
    104. 

  104.         return cluster;  
    105. 

  105.     }  
    106. 

  106.   
    107. 

  107.     // 产生新的聚类中心点数组  
    108. 

  108.     public Set<Integer> updateCenter() {  
    109. 

  109.         Set<Integer> center = new HashSet<Integer>();  
    110. 

  110.         for (int i = 0; i < K; i++) {  
    111. 

  111.             center.add(i);  
    112. 

  112.         }  
    113. 

  113.         return center;  
    114. 

  114.     }  
    115. 

  115.   
    116. 

  116.     // 更新聚类中心, 求平均值  
    117. 

  117.     public ArrayList<Cluster> updateCluster(ArrayList<Cluster> cluster) {  
    118. 

  118.         ArrayList<Cluster> result = new ArrayList<Cluster>();  
    119. 

  119.         // 重新产生的新的聚类中心组成的数组  
    120. 

  120.         // k个聚类进行更新聚类中心  
    121. 

  121.         for (int j = 0; j < K; j++) {  
    122. 

  122.             ArrayList<General> ps = cluster.get(j).getOfCluster();// 该聚类的所有 武将  
    123. 

  123.                                                                     // 组成的数组  
    124. 

  124.             ps.add(allGenerals.get(cluster.get(j).getCenter()));// 同时将该类中心对应的武将加入该武将数组  
    125. 

  125.             int size = ps.size();// 该聚类的长度大小  
    126. 

  126.             // 计算和，然后在计算平均值  
    127. 

  127.             int sumrender = 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;  
    128. 

  128.             for (int k1 = 0; k1 < size; k1++) {  
    129. 

  129.                 sumrender += ps.get(k1).getRender();  
    130. 

  130.                 sumtongshai += ps.get(k1).getRender();  
    131. 

  131.                 sumwuli += ps.get(k1).getWuli();  
    132. 

  132.                 sumzhili += ps.get(k1).getZhili();  
    133. 

  133.                 sumjibin += ps.get(k1).getJibin();  
    134. 

  134.                 sumnubin += ps.get(k1).getNubin();  
    135. 

  135.                 sumqibin += ps.get(k1).getQibin();  
    136. 

  136.                 sumpolic += ps.get(k1).getPolic();  
    137. 

  137.                 sumqiangbin += ps.get(k1).getQiangbin();  
    138. 

  138.                 sumbinqi += ps.get(k1).getBinqi();  
    139. 

  139.                 sumtongwu += ps.get(k1).getTongwu();  
    140. 

  140.                 sumtongzhi += ps.get(k1).getTongzhi();  
    141. 

  141.                 sumtongwuzhi += ps.get(k1).getTongwuzhi();  
    142. 

  142.                 sumtongwuzhizheng += ps.get(k1).getTongwuzhizheng();  
    143. 

  143.                 sumsalary += ps.get(k1).getSalary();  
    144. 

  144.             }  
    145. 

  145.             // 产生新的聚类，然后加入到聚类数组中  
    146. 

  146.             Cluster newCluster = new Cluster();  
    147. 

  147.             newCluster.setCenter(j);  
    148. 

  148.             // 计算平均值并构造新的武将对象  
    149. 

  149.             newCluster.addGeneral(new General(sumrender / size, sumtongshai  
    150. 

  150.                     / size, sumwuli / size, sumzhili / size, sumjibin / size,  
    151. 

  151.                     sumnubin / size, sumqibin / size, sumpolic = 0,  
    152. 

  152.                     sumqiangbin = 0, sumbinqi / size, sumtongwu / size,  
    153. 

  153.                     sumtongzhi / size, sumtongwuzhi / size, sumtongwuzhizheng  
    154. 

  154.                             / size, sumsalary / size));  
    155. 

  155.             result.add(newCluster);  
    156. 

  156.         }  
    157. 

  157.         return result;  
    158. 

  158.   
    159. 

  159.     }  
    160. 

  160.   
    161. 

  161.     /** 
    162. 

  162.      * 计算各个武将到各个更新后的聚类中心的距离，重新聚类 
    163. 

  163.      * @param update 更新后的聚类中心 
    164. 

  164.      * @param cluster 要存储的聚类中心 
    165. 

  165.      */  
    166. 

  166.     public ArrayList<Cluster> updateJuLei(ArrayList<Cluster> update,  
    167. 

  167.             ArrayList<Cluster> cluster) {  
    168. 

  168.         ArrayList<Distance> distence = new ArrayList<Distance>();// 存放距离信息,表示每个点到各个中心点的距离组成的数组  
    169. 

  169.         General source = null;  
    170. 

  170.         General dest = null;  
    171. 

  171.         int id = 0;// 目的节点id  
    172. 

  172.         int id2 = 0;// 源节点id  
    173. 

  173.         //Object[] p = center.toArray();// p 为聚类中心点id数组  
    174. 

  174.         boolean flag = false;  
    175. 

  175.         // 分别计算各个点到各个中心点的距离，并将距离最小的加入到各个聚类中，进行聚类  
    176. 

  176.         for (int i = 0; i < totalNumber; i++) {  
    177. 

  177.             // 每个点计算完,并聚类到距离最小的聚类中就清空距离数组  
    178. 

  178.             distence.clear();  
    179. 

  179.             // 计算到j个类中心点的距离,便利各个中心点  
    180. 

  180.             //for (int j = 0; j < center.size(); j++) {  
    181. 

  181.             for (int j = 0; j < update.size(); j++) {  
    182. 

  182.                 // 如果该点不在中心点内 则计算距离  
    183. 

  183.                 //if (!(center.contains(i))) {  
    184. 

  184.                     flag = true;  
    185. 

  185.                     // 计算距离  
    186. 

  186.                     source = allGenerals.get(i);// 某个点  
    187. 

  187.                     // dest = allGenerals.get((Integer) p[j]);// 各个 中心点  
    188. 

  188.                     dest = update.get(j).getOfCluster().get(0);// 各个 中心点  
    189. 

  189.                     // 计算距离并存入数组  
    190. 

  190.                     //distence.add(new Distance((Integer) p[j], i, Tool.juli(  
    191. 

  191.                     distence.add(new Distance(update.get(j).getCenter(), i, Tool.juli(  
    192. 

  192.                             source, dest)));  
    193. 

  193.                     /*} else { 
    194. 

  194.                     flag = false; 
    195. 

  195.                 }*/  
    196. 

  196.             }  
    197. 

  197.             // 说明计算完某个武将到类中心的距离,开始比较  
    198. 

  198.             if (flag == true) {  
    199. 

  199.                 // 排序比较一个点到各个中心的距离的大小,找到距离最小的武将的 目的id,和源id,  
    200. 

  200.                 // 目的id即类中心点id，这个就归到这个中心点所在聚类中  
    201. 

  201.                 double min = distence.get(0).getDist();// 默认第一个distance距离是最小的  
    202. 

  202.                 // 从1开始遍历distance数组  
    203. 

  203.                 int mid = 0;  
    204. 

  204.                 for (int k = 1; k < distence.size(); k++) {  
    205. 

  205.                     if (min > distence.get(k).getDist()) {  
    206. 

  206.                         min = distence.get(k).getDist();  
    207. 

  207.                         id = distence.get(k).getDest();// 目的，即类中心点  
    208. 

  208.                         id2 = distence.get(k).getSource();// 某个武将  
    209. 

  209.                         mid = k;  
    210. 

  210.                     } else {  
    211. 

  211.                         id = distence.get(mid).getDest();  
    212. 

  212.                         id2 = distence.get(mid).getSource();  
    213. 

  213.                     }  
    214. 

  214.                 }  
    215. 

  215.                 // 遍历cluster聚类数组，找到类中心点id与最小距离目的武将id相同的聚类  
    216. 

  216.                 for (int n = 0; n < cluster.size(); n++) {  
    217. 

  217.                     // 如果和中心点的id相同 则setError  
    218. 

  218.                     if (cluster.get(n).getCenter() == id) {  
    219. 

  219.                         cluster.get(n).addGeneral(allGenerals.get(id2));// 将与该聚类中心距离最小的武将加入该聚类  
    220. 

  220.                     }  
    221. 

  221.                 }  
    222. 

  222.             }  
    223. 

  223.         }  
    224. 

  224.         return cluster;  
    225. 

  225.     }  
    226. 

  226.   
    227. 

  227.     // 不断循环聚类直到各个聚类没有重新分配  
    228. 

  228.     public ArrayList<Cluster> getResult() {  
    229. 

  229.         ArrayList<Cluster> result = new ArrayList<Cluster>();  
    230. 

  230.         ArrayList<Cluster> temp = new ArrayList<Cluster>();  
    231. 

  231.         boolean flag = false;  
    232. 

  232.         // 得到随机中心点然后进行聚类  
    233. 

  233.         Set<Integer> center = firstRandom();  
    234. 

  234.         result = juLei(center, init(center));  
    235. 

  235.         print(result);  
    236. 

  236.         do {  
    237. 

  237.             // 重新聚类  
    238. 

  238.             ArrayList<Cluster> up = updateCluster(result);//新的聚类中心  
    239. 

  239.             ArrayList<Cluster> cluster = init(updateCenter()); // 得到更新后的中心点对应的聚类数组  
    240. 

  240.             temp = updateJuLei(up, cluster);  
    241. 

  241.             //print(temp);  
    242. 

  242.             flag = isEquals(temp, result);  
    243. 

  243.             result = temp;  
    244. 

  244.         } while (!flag);  
    245. 

  245.         return result;  
    246. 

  246.     }  
    247. 

  247.       
    248. 

  248.     publicboolean isEquals(ArrayList<Cluster> temp, ArrayList<Cluster> result){  
    249. 

  249.         boolean flag = false;  
    250. 

  250.         if(temp.size() != result.size()){  
    251. 

  251.             return flag;  
    252. 

  252.         }  
    253. 

  253.         for(Cluster tem : temp){  
    254. 

  254.             for(Cluster res : result){  
    255. 

  255.                 if(tem.getCenter() == res.getCenter()){  
    256. 

  256.                     flag = true;  
    257. 

  257.                 }  
    258. 

  258.             }  
    259. 

  259.             // 如果找了一轮没找到 则说明两个聚类  
    260. 

  260.             if(flag == false){  
    261. 

  261.                 returnfalse;  
    262. 

  262.             }else{// 如果找了一轮找到了，那么接着找  
    263. 

  263.                 flag = false;  
    264. 

  264.             }  
    265. 

  265.         }  
    266. 

  266.         //如果代码能进行到这边，说明是true  
    267. 

  267.         flag = true;  
    268. 

  268.         return flag;  
    269. 

  269.     }  
    270. 

  270.       
    271. 

  271.     //输出所有的聚类  
    272. 

  272.     publicvoid print(ArrayList<Cluster> cs) {  
    273. 

  273.         System.out.println("***************************************");  
    274. 

  274.         for (int i = 0; i < cs.size(); i++) {  
    275. 

  275.             Cluster c = cs.get(i);  
    276. 

  276.             System.out.println("-----------------------------------------------------");  
    277. 

  277.             System.out.println("center: " + allGenerals.get(c.getCenter()));  
    278. 

  278.             ArrayList<General> p = c.getOfCluster();  
    279. 

  279.             for (int j = 0; j < p.size(); j++) {  
    280. 

  280.                 System.out.println("general:"+p.get(j)+"\n");  
    281. 

  281.             }  
    282. 

  282.         }  
    283. 

  283.     }  
    284. 

  284.   
    285. 

  285. }  
    286. 



package kmeans;

import java.util.*;

public class Kmeans {
	public ArrayList<General> allGenerals = null;
	public int totalNumber = 0;// 得到所有的武将数目
	public int K = 0;// 假设K=10

	public Kmeans() {
		allGenerals = new DomParser().prepare();
		totalNumber = allGenerals.size();
		K = 3;
	}

	// 第一次随机选取聚类中心
	public Set<Integer> firstRandom() {
		Set<Integer> center = new HashSet<Integer>();// 聚类中心的点的id,采用set保证不会有重复id
		Random ran = new Random();
		int roll = ran.nextInt(totalNumber);
		while (center.size() < K) {
			roll = ran.nextInt(totalNumber);
			center.add(roll);
		}
		return center;
	}

	// 根据聚类中心初始化聚类信息
	public ArrayList<Cluster> init(Set<Integer> center) {
		ArrayList<Cluster> cluster = new ArrayList<Cluster>();// 聚类 的数组
		Iterator<Integer> it = center.iterator();
		while (it.hasNext()) {
			Cluster c = new Cluster();// 代表一个聚类
			c.setCenter(it.next());
			cluster.add(c);
		}
		return cluster;
	}

	/**
	 * 计算各个武将到各个聚类中心的距离，重新聚类
	 * 
	 * @param cluster
	 *            聚类数组,用来聚类的，根据最近原则把武将聚类
	 * @param center
	 *            中心点id,用于计算各个武将到中心点的距离 return cluster 聚类后的所有聚类组成的数组
	 */
	public ArrayList<Cluster> juLei(Set<Integer> center,
			ArrayList<Cluster> cluster) {
		ArrayList<Distance> distence = new ArrayList<Distance>();// 存放距离信息,表示每个点到各个中心点的距离组成的数组
		General source = null;
		General dest = null;
		int id = 0;// 目的节点id
		int id2 = 0;// 源节点id
		Object[] p = center.toArray();// p 为聚类中心点id数组
		boolean flag = false;
		// 分别计算各个点到各个中心点的距离，并将距离最小的加入到各个聚类中，进行聚类
		for (int i = 0; i < totalNumber; i++) {
			// 每个点计算完,并聚类到距离最小的聚类中就清空距离数组
			distence.clear();
			// 计算到j个类中心点的距离,便利各个中心点
			for (int j = 0; j < center.size(); j++) {
				// 如果该点不在中心点内 则计算距离
				if (!(center.contains(i))) {
					flag = true;
					// 计算距离
					source = allGenerals.get(i);// 某个点
					dest = allGenerals.get((Integer) p[j]);// 各个 中心点
					// 计算距离并存入数组
					distence.add(new Distance((Integer) p[j], i, Tool.juli(
							source, dest)));
				} else {
					flag = false;
				}
			}
			// 说明计算完某个武将到类中心的距离,开始比较
			if (flag == true) {
				// 排序比较一个点到各个中心的距离的大小,找到距离最小的武将的 目的id,和源id,
				// 目的id即类中心点id，这个就归到这个中心点所在聚类中
				double min = distence.get(0).getDist();// 默认第一个distance距离是最小的
				// 从1开始遍历distance数组
				int minid = 0;
				for (int k = 1; k < distence.size(); 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 (int n = 0; n < cluster.size(); n++) {
					// 如果和中心点的id相同 则setError
					if (cluster.get(n).getCenter() == id) {
						cluster.get(n).addGeneral(allGenerals.get(id2));// 将与该聚类中心距离最小的武将加入该聚类
						break;
					}
				}
			}
		}
		return cluster;
	}

	// 产生新的聚类中心点数组
	public Set<Integer> updateCenter() {
		Set<Integer> center = new HashSet<Integer>();
		for (int i = 0; i < K; i++) {
			center.add(i);
		}
		return center;
	}

	// 更新聚类中心, 求平均值
	public ArrayList<Cluster> updateCluster(ArrayList<Cluster> cluster) {
		ArrayList<Cluster> result = new ArrayList<Cluster>();
		// 重新产生的新的聚类中心组成的数组
		// k个聚类进行更新聚类中心
		for (int j = 0; j < K; j++) {
			ArrayList<General> ps = cluster.get(j).getOfCluster();// 该聚类的所有 武将
																	// 组成的数组
			ps.add(allGenerals.get(cluster.get(j).getCenter()));// 同时将该类中心对应的武将加入该武将数组
			int size = ps.size();// 该聚类的长度大小
			// 计算和，然后在计算平均值
			int sumrender = 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 (int k1 = 0; k1 < size; 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 = new Cluster();
			newCluster.setCenter(j);
			// 计算平均值并构造新的武将对象
			newCluster.addGeneral(new General(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);
		}
		return result;

	}

	/**
	 * 计算各个武将到各个更新后的聚类中心的距离，重新聚类
	 * @param update 更新后的聚类中心
	 * @param cluster 要存储的聚类中心
	 */
	public ArrayList<Cluster> updateJuLei(ArrayList<Cluster> update,
			ArrayList<Cluster> cluster) {
		ArrayList<Distance> distence = new ArrayList<Distance>();// 存放距离信息,表示每个点到各个中心点的距离组成的数组
		General source = null;
		General dest = null;
		int id = 0;// 目的节点id
		int id2 = 0;// 源节点id
		//Object[] p = center.toArray();// p 为聚类中心点id数组
		boolean flag = false;
		// 分别计算各个点到各个中心点的距离，并将距离最小的加入到各个聚类中，进行聚类
		for (int i = 0; i < totalNumber; i++) {
			// 每个点计算完,并聚类到距离最小的聚类中就清空距离数组
			distence.clear();
			// 计算到j个类中心点的距离,便利各个中心点
			//for (int j = 0; j < center.size(); j++) {
			for (int j = 0; j < update.size(); 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(new Distance(update.get(j).getCenter(), i, Tool.juli(
							source, dest)));
					/*} else {
					flag = false;
				}*/
			}
			// 说明计算完某个武将到类中心的距离,开始比较
			if (flag == true) {
				// 排序比较一个点到各个中心的距离的大小,找到距离最小的武将的 目的id,和源id,
				// 目的id即类中心点id，这个就归到这个中心点所在聚类中
				double min = distence.get(0).getDist();// 默认第一个distance距离是最小的
				// 从1开始遍历distance数组
				int mid = 0;
				for (int k = 1; k < distence.size(); 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 (int n = 0; n < cluster.size(); n++) {
					// 如果和中心点的id相同 则setError
					if (cluster.get(n).getCenter() == id) {
						cluster.get(n).addGeneral(allGenerals.get(id2));// 将与该聚类中心距离最小的武将加入该聚类
					}
				}
			}
		}
		return cluster;
	}

	// 不断循环聚类直到各个聚类没有重新分配
	public ArrayList<Cluster> getResult() {
		ArrayList<Cluster> result = new ArrayList<Cluster>();
		ArrayList<Cluster> temp = new ArrayList<Cluster>();
		boolean flag = false;
		// 得到随机中心点然后进行聚类
		Set<Integer> center = firstRandom();
		result = juLei(center, init(center));
		print(result);
		do {
			// 重新聚类
			ArrayList<Cluster> up = updateCluster(result);//新的聚类中心
			ArrayList<Cluster> cluster = init(updateCenter()); // 得到更新后的中心点对应的聚类数组
			temp = updateJuLei(up, cluster);
			//print(temp);
			flag = isEquals(temp, result);
			result = temp;
		} while (!flag);
		return result;
	}
	
	public boolean isEquals(ArrayList<Cluster> temp, ArrayList<Cluster> result){
		boolean flag = false;
		if(temp.size() != result.size()){
			return flag;
		}
		for(Cluster tem : temp){
			for(Cluster res : result){
				if(tem.getCenter() == res.getCenter()){
					flag = true;
				}
			}
			// 如果找了一轮没找到 则说明两个聚类
			if(flag == false){
				return false;
			}else{// 如果找了一轮找到了，那么接着找
				flag = false;
			}
		}
		//如果代码能进行到这边，说明是true
		flag = true;
		return flag;
	}
	
	//输出所有的聚类
	public void print(ArrayList<Cluster> cs) {
		System.out.println("***************************************");
		for (int i = 0; i < cs.size(); i++) {
			Cluster c = cs.get(i);
			System.out.println("-----------------------------------------------------");
			System.out.println("center: " + allGenerals.get(c.getCenter()));
			ArrayList<General> p = c.getOfCluster();
			for (int j = 0; j < p.size(); j++) {
				System.out.println("general:"+p.get(j)+"\n");
			}
		}
	}

}



 


5,Tool.java


 






[java] view plaincopyprint?




    

  1.   
    2. 









[java] view plaincopyprint?




    

  1. package kmeans;  
    2. 

  2.   
    3. 

  3. publicclass Tool {  
    4. 

  4.     //将各种武器的精通程度转为数字  
    5. 

  5.     publicstaticint change(String str) {  
    6. 

  6.         int result = str.equals("精") ? 4 : (str.equals("神") ? 3 : (str  
    7. 

  7.                 .equals("通") ? 2 : 1));  
    8. 

  8.         return result;  
    9. 

  9.     }  
    10. 

  10.     //将星级转为数字  
    11. 

  11.     publicstaticint xingji(String str) {  
    12. 

  12.         int result = str.equals("★★★★★") ? 5 : (str.equals("★★★★") ? 4 : (str  
    13. 

  13.                 .equals("★★★") ? 3 : (str.equals("★★") ? 2 : 1)));  
    14. 

  14.         return result;  
    15. 

  15.     }  
    16. 

  16.     //反转 将各种武器的数字转为精通程度  
    17. 

  17.     publicstatic String dchange(int str) {  
    18. 

  18.         String result = str== 4 ? "精" : (str== 3 ? "神" : (str== 2 ? "通" : "疏"));  
    19. 

  19.         return result;  
    20. 

  20.     }  
    21. 

  21.     //反转 将数字转为星级  
    22. 

  22.     publicstatic String dxingji(int str) {  
    23. 

  23.         String result = str== 5 ? "★★★★★" : (str== 4 ? "★★★★" : (str== 3 ? "★★★" : (str == 2 ? "★★" : "★")));  
    24. 

  24.         return result;  
    25. 

  25.     }  
    26. 

  26.     //计算欧式距离 传入两个将军对象。。  
    27. 

  27.     publicstaticdouble juli(General g1, General g2) {  
    28. 

  28.         double result = (Double) Math.sqrt(StrictMath.pow(g1.getRender() - g2.getRender(), 2)  
    29. 

  29.                 + StrictMath.pow(g1.getTongshai() - g2.getTongshai(), 2)  
    30. 

  30.                 + StrictMath.pow(g1.getWuli() - g2.getWuli(), 2)  
    31. 

  31.                 + StrictMath.pow(g1.getZhili() - g2.getZhili(), 2)  
    32. 

  32.                 + StrictMath.pow(g1.getPolic() - g2.getPolic(), 2)  
    33. 

  33.                 + StrictMath.pow(g1.getQiangbin() - g2.getQiangbin(), 2)  
    34. 

  34.                 + StrictMath.pow(g1.getQibin() - g2.getQibin(), 2)  
    35. 

  35.                 + StrictMath.pow(g1.getJibin() - g2.getJibin(), 2)  
    36. 

  36.                 + StrictMath.pow(g1.getNubin() - g2.getNubin(), 2)  
    37. 

  37.                 + StrictMath.pow(g1.getBinqi() - g2.getBinqi(), 2)  
    38. 

  38.                 + StrictMath.pow(g1.getTongwu() - g2.getTongwu(), 2)  
    39. 

  39.                 + StrictMath.pow(g1.getTongzhi() - g2.getTongzhi(), 2)  
    40. 

  40.                 + StrictMath.pow(g1.getTongwuzhizheng() - g2.getTongwuzhizheng(), 2)  
    41. 

  41.                 + StrictMath.pow(g1.getTongwuzhi() - g2.getTongwuzhi(), 2)  
    42. 

  42.                 + StrictMath.pow(g1.getSalary() - g2.getSalary(), 2)  
    43. 

  43.                 );  
    44. 

  44.         return result;  
    45. 

  45.     }  
    46. 

  46. }  
    47. 



package kmeans;

public class Tool {
	//将各种武器的精通程度转为数字
	public static int change(String str) {
		int result = str.equals("精") ? 4 : (str.equals("神") ? 3 : (str
				.equals("通") ? 2 : 1));
		return result;
	}
	//将星级转为数字
	public static int xingji(String str) {
		int result = str.equals("★★★★★") ? 5 : (str.equals("★★★★") ? 4 : (str
				.equals("★★★") ? 3 : (str.equals("★★") ? 2 : 1)));
		return result;
	}
	//反转 将各种武器的数字转为精通程度
	public static String dchange(int str) {
		String result = str== 4 ? "精" : (str== 3 ? "神" : (str== 2 ? "通" : "疏"));
		return result;
	}
	//反转 将数字转为星级
	public static String dxingji(int str) {
		String result = str== 5 ? "★★★★★" : (str== 4 ? "★★★★" : (str== 3 ? "★★★" : (str == 2 ? "★★" : "★")));
		return result;
	}
	//计算欧式距离 传入两个将军对象。。
	public static double juli(General g1, General g2) {
		double result = (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)
				);
		return result;
	}
}



6,DomParser.java


 






[java] view plaincopyprint?




    

  1.   
    2. 









[java] view plaincopyprint?




    

  1. package kmeans;  
    2. 

  2.   
    3. 

  3. import javax.xml.parsers.*;  
    4. 

  4.   
    5. 

  5. import java.io.*;  
    6. 

  6. import java.util.ArrayList;  
    7. 

  7.   
    8. 

  8. import org.w3c.dom.*;  
    9. 

  9. import org.xml.sax.SAXException;  
    10. 

  10.   
    11. 

  11. publicclass DomParser {  
    12. 

  12.   
    13. 

  13.     private ArrayList<General> generals = new ArrayList<General>();  
    14. 

  14.   
    15. 

  15.     public ArrayList<General> prepare(){  
    16. 

  16.         // get dom解析器工厂  
    17. 

  17.         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();  
    18. 

  18.         factory.setIgnoringElementContentWhitespace(true);  
    19. 

  19.         // get dom 解析器  
    20. 

  20.         DocumentBuilder builder = null;  
    21. 

  21.         try {  
    22. 

  22.             builder = factory.newDocumentBuilder();  
    23. 

  23.         } catch (ParserConfigurationException e) {  
    24. 

  24.             e.printStackTrace();  
    25. 

  25.         }  
    26. 

  26.         // 解析文档  
    27. 

  27.         Document doc = null;  
    28. 

  28.         try {  
    29. 

  29.             doc = builder.parse(new File("general.xml"));  
    30. 

  30.         } catch (SAXException e) {  
    31. 

  31.             e.printStackTrace();  
    32. 

  32.         } catch (IOException e) {  
    33. 

  33.             e.printStackTrace();  
    34. 

  34.         }  
    35. 

  35.         // 取得根节点  
    36. 

  36.         Element generalList = doc.getDocumentElement();  
    37. 

  37.         // 得到所有row节点  
    38. 

  38.         NodeList nodeList = generalList.getElementsByTagName("Row");  
    39. 

  39.         // 便利所有row节点  
    40. 

  40.         for (int i = 1; i < nodeList.getLength(); i++) {  
    41. 

  41.               
    42. 

  42.             System.out.println("------------the " + i  
    43. 

  43.                     + " element--------------");  
    44. 

  44.               
    45. 

  45.             Node row = nodeList.item(i);  
    46. 

  46.             // 取得所有Data数据  
    47. 

  47.             NodeList attList = row.getChildNodes();  
    48. 

  48.             // 取得数据中的各个部分, 并加入ArrayList中  
    49. 

  49.             generals.add(new General(Tool.xingji(attList.item(1)  
    50. 

  50.                     .getTextContent()), attList.item(3).getTextContent(),  
    51. 

  51.                     Integer.parseInt(attList.item(5).getTextContent()),   
    52. 

  52.                     Integer.parseInt(attList.item(7).getTextContent()),  
    53. 

  53.                     Integer.parseInt(attList.item(9).getTextContent()),   
    54. 

  54.                     Integer.parseInt(attList.item(11).getTextContent()),   
    55. 

  55.                     Tool.change(attList.item(13).getTextContent()),  
    56. 

  56.                     Tool.change(attList.item(15).getTextContent()),   
    57. 

  57.                     Tool.change(attList.item(17).getTextContent()),   
    58. 

  58.                     Tool.change(attList.item(19).getTextContent()),   
    59. 

  59.                     Tool.change(attList.item(21).getTextContent()),   
    60. 

  60.                     Integer.parseInt(attList.item(23).getTextContent()),  
    61. 

  61.                     Integer.parseInt(attList.item(25).getTextContent()),  
    62. 

  62.                     Integer.parseInt(attList.item(27).getTextContent()),  
    63. 

  63.                     Integer.parseInt(attList.item(29).getTextContent()),  
    64. 

  64.                     Integer.parseInt(attList.item(31).getTextContent())));  
    65. 

  65.               
    66. 

  66.             System.out.println(" 星级:"  
    67. 

  67.                     + Tool.xingji(attList.item(1).getTextContent()) + " 姓名:"  
    68. 

  68.                     + attList.item(3).getTextContent() + " 统率:"  
    69. 

  69.                     + attList.item(5).getTextContent() + " 武力:"  
    70. 

  70.                     + attList.item(7).getTextContent() + " 智力:"  
    71. 

  71.                     + attList.item(9).getTextContent() + " 政治:"  
    72. 

  72.                     + attList.item(11).getTextContent() + "枪兵:"  
    73. 

  73.                     + Tool.change(attList.item(13).getTextContent()) + " 戟兵:"  
    74. 

  74.                     + Tool.change(attList.item(15).getTextContent()) + " 弩兵:"  
    75. 

  75.                     + Tool.change(attList.item(17).getTextContent()) + " 骑兵:"  
    76. 

  76.                     + Tool.change(attList.item(19).getTextContent()) + " 兵器:"  
    77. 

  77.                     + Tool.change(attList.item(21).getTextContent()) + " 统武:"  
    78. 

  78.                     + attList.item(23).getTextContent() + " 统智:"  
    79. 

  79.                     + attList.item(25).getTextContent() + " 统武智:"  
    80. 

  80.                     + attList.item(27).getTextContent() + " 统武智政:"  
    81. 

  81.                     + attList.item(29).getTextContent() + " 50级工资:"  
    82. 

  82.                     + attList.item(31).getTextContent() + " ");  
    83. 

  83.             /* 
    84. 

  84.              * for (int j = 0; j < attList.getLength(); j++) { 
    85. 

  85.              * System.out.println(attList.item(j).getTextContent()); } 
    86. 

  86.              */  
    87. 

  87.         }  
    88. 

  88.         return generals;  
    89. 

  89.   
    90. 

  90.     }  
    91. 

  91. }  
    92. 



package kmeans;

import javax.xml.parsers.*;

import java.io.*;
import java.util.ArrayList;

import org.w3c.dom.*;
import org.xml.sax.SAXException;

public class DomParser {

	private ArrayList<General> generals = new ArrayList<General>();

	public ArrayList<General> 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(new File("general.xml"));
		} catch (SAXException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		// 取得根节点
		Element generalList = doc.getDocumentElement();
		// 得到所有row节点
		NodeList nodeList = generalList.getElementsByTagName("Row");
		// 便利所有row节点
		for (int i = 1; i < nodeList.getLength(); i++) {
			
			System.out.println("------------the " + i
					+ " element--------------");
			
			Node row = nodeList.item(i);
			// 取得所有Data数据
			NodeList attList = row.getChildNodes();
			// 取得数据中的各个部分, 并加入ArrayList中
			generals.add(new General(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 < attList.getLength(); j++) {
			 * System.out.println(attList.item(j).getTextContent()); }
			 */
		}
		return generals;

	}
}


 


7,TestKmeans.java　


 






[java] view plaincopyprint?




    

  1. package kmeans;  
    2. 

  2.   
    3. 

  3. publicclass TestKmeans {  
    4. 

  4.   
    5. 

  5.     publicstaticvoid main(String[] args) {  
    6. 

  6.         Kmeans kmeans = new Kmeans();  
    7. 

  7.         kmeans.print(kmeans.getResult());  
    8. 

  8.     }  
    9. 

  9.   
    10. 

  10. }  
    11. 



package kmeans;

public class TestKmeans {

	public static void main(String[] args) {
		Kmeans kmeans = new Kmeans();
		kmeans.print(kmeans.getResult());
	}

}



 


附部分general.xml：


 






[html] view plaincopyprint?




    

  1. <?xmlversion="1.0"?>  
    2. 

  2. <?mso-applicationprogid="Excel.Sheet"?>  
    3. 

  3. <Workbookxmlns="urn:schemas-microsoft-com:office:spreadsheet"  
    4. 

  4.  xmlns:o="urn:schemas-microsoft-com:office:office"  
    5. 

  5.  xmlns:x="urn:schemas-microsoft-com:office:excel"  
    6. 

  6.  xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet"  
    7. 

  7.  xmlns:html="http://www.w3.org/TR/REC-html40">  
    8. 

  8.  <DocumentPropertiesxmlns="urn:schemas-microsoft-com:office:office">  
    9. 

  9.   <Created>2006-09-13T11:21:51Z</Created>  
    10. 

  10.   <LastSaved>2012-04-26T13:39:57Z</LastSaved>  
    11. 

  11.   <Version>14.00</Version>  
    12. 

  12.  </DocumentProperties>  
    13. 

  13.  <OfficeDocumentSettingsxmlns="urn:schemas-microsoft-com:office:office">  
    14. 

  14.   <AllowPNG/>  
    15. 

  15.   <RemovePersonalInformation/>  
    16. 

  16.  </OfficeDocumentSettings>  
    17. 

  17.  <ExcelWorkbookxmlns="urn:schemas-microsoft-com:office:excel">  
    18. 

  18.   <WindowHeight>5850</WindowHeight>  
    19. 

  19.   <WindowWidth>11070</WindowWidth>  
    20. 

  20.   <WindowTopX>0</WindowTopX>  
    21. 

  21.   <WindowTopY>90</WindowTopY>  
    22. 

  22.   <ProtectStructure>False</ProtectStructure>  
    23. 

  23.   <ProtectWindows>False</ProtectWindows>  
    24. 

  24.  </ExcelWorkbook>  
    25. 

  25.  <Styles>  
    26. 

  26.   <Styless:ID="Default"ss:Name="Normal">  
    27. 

  27.    <Alignmentss:Vertical="Center"/>  
    28. 

  28.    <Borders/>  
    29. 

  29.    <Fontss:FontName="宋体"x:CharSet="134"ss:Size="11"ss:Color="#000000"/>  
    30. 

  30.    <Interior/>  
    31. 

  31.    <NumberFormat/>  
    32. 

  32.    <Protection/>  
    33. 

  33.   </Style>  
    34. 

  34.   <Styless:ID="s16">  
    35. 

  35.    <Alignmentss:Horizontal="Left"ss:Vertical="Center"ss:WrapText="1"/>  
    36. 

  36.    <Fontss:FontName="宋体"x:CharSet="134"ss:Bold="1"/>  
    37. 

  37.   </Style>  
    38. 

  38.   <Styless:ID="s17">  
    39. 

  39.    <Alignmentss:Horizontal="Center"ss:Vertical="Center"ss:WrapText="1"/>  
    40. 

  40.    <Fontss:FontName="宋体"x:CharSet="134"ss:Size="12"ss:Bold="1"/>  
    41. 

  41.   </Style>  
    42. 

  42.   <Styless:ID="s18">  
    43. 

  43.    <Alignmentss:Horizontal="Left"ss:Vertical="Center"ss:WrapText="1"/>  
    44. 

  44.    <Fontss:FontName="宋体"x:CharSet="134"/>  
    45. 

  45.   </Style>  
    46. 

  46.   <Styless:ID="s19">  
    47. 

  47.    <Alignmentss:Horizontal="Center"ss:Vertical="Center"ss:WrapText="1"/>  
    48. 

  48.   </Style>  
    49. 

  49.  </Styles>  
    50. 

  50.  <Worksheetss:Name="三国数据">  
    51. 

  51.   <Tabless:ExpandedColumnCount="16"ss:ExpandedRowCount="682"x:FullColumns="1"  
    52. 

  52.    x:FullRows="1"ss:DefaultColumnWidth="54"ss:DefaultRowHeight="13.5">  
    53. 

  53.    <Rowss:Height="28.5">  
    54. 

  54.     <Cellss:StyleID="s16"><Datass:Type="String">星级</Data></Cell>  
    55. 

  55.     <Cellss:StyleID="s17"><Datass:Type="String">姓名</Data></Cell>  
    56. 

  56.     <Cellss:StyleID="s17"><Datass:Type="String">统率</Data></Cell>  
    57. 

  57.     <Cellss:StyleID="s17"><Datass:Type="String">武力</Data></Cell>  
    58. 

  58.     <Cellss:StyleID="s17"><Datass:Type="String">智力</Data></Cell>  
    59. 

  59.     <Cellss:StyleID="s17"><Datass:Type="String">政治</Data></Cell>  
    60. 

  60.     <Cellss:StyleID="s17"><Datass:Type="String">枪兵</Data></Cell>  
    61. 

  61.     <Cellss:StyleID="s17"><Datass:Type="String">戟兵</Data></Cell>  
    62. 

  62.     <Cellss:StyleID="s17"><Datass:Type="String">弩兵</Data></Cell>  
    63. 

  63.     <Cellss:StyleID="s17"><Datass:Type="String">骑兵</Data></Cell>  
    64. 

  64.     <Cellss:StyleID="s17"><Datass:Type="String">兵器</Data></Cell>  
    65. 

  65.     <Cellss:StyleID="s17"><Datass:Type="String">统武</Data></Cell>  
    66. 

  66.     <Cellss:StyleID="s17"><Datass:Type="String">统智</Data></Cell>  
    67. 

  67.     <Cellss:StyleID="s17"><Datass:Type="String">统武智 </Data></Cell>  
    68. 

  68.     <Cellss:StyleID="s17"><Datass:Type="String">统武智政</Data></Cell>  
    69. 

  69.     <Cellss:StyleID="s17"><Datass:Type="String">50级工资 </Data></Cell>  
    70. 

  70.    </Row>  
    71. 

  71.    <Row>  
    72. 

  72.     <Cellss:StyleID="s18"><Datass:Type="String">★★★★★</Data></Cell>  
    73. 

  73.     <Cellss:StyleID="s19"><Datass:Type="String">吕布</Data></Cell>  
    74. 

  74.     <Cellss:StyleID="s19"><Datass:Type="Number">87</Data></Cell>  
    75. 

  75.     <Cellss:StyleID="s19"><Datass:Type="Number">100</Data></Cell>  
    76. 

  76.     <Cellss:StyleID="s19"><Datass:Type="Number">26</Data></Cell>  
    77. 

  77.     <Cellss:StyleID="s19"><Datass:Type="Number">13</Data></Cell>  
    78. 

  78.     <Cellss:StyleID="s19"><Datass:Type="String">精</Data></Cell>  
    79. 

  79.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    80. 

  80.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    81. 

  81.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    82. 

  82.     <Cellss:StyleID="s19"><Datass:Type="String">疏</Data></Cell>  
    83. 

  83.     <Cellss:StyleID="s19"><Datass:Type="Number">161</Data></Cell>  
    84. 

  84.     <Cellss:StyleID="s19"><Datass:Type="Number">194</Data></Cell>  
    85. 

  85.     <Cellss:StyleID="s19"><Datass:Type="Number">257</Data></Cell>  
    86. 

  86.     <Cellss:StyleID="s19"><Datass:Type="Number">350</Data></Cell>  
    87. 

  87.     <Cellss:StyleID="s19"><Datass:Type="Number">19250</Data></Cell>  
    88. 

  88.    </Row>  
    89. 

  89.    <Row>  
    90. 

  90.     <Cellss:StyleID="s18"><Datass:Type="String">★★★★★</Data></Cell>  
    91. 

  91.     <Cellss:StyleID="s19"><Datass:Type="String">张飞</Data></Cell>  
    92. 

  92.     <Cellss:StyleID="s19"><Datass:Type="Number">85</Data></Cell>  
    93. 

  93.     <Cellss:StyleID="s19"><Datass:Type="Number">98</Data></Cell>  
    94. 

  94.     <Cellss:StyleID="s19"><Datass:Type="Number">30</Data></Cell>  
    95. 

  95.     <Cellss:StyleID="s19"><Datass:Type="Number">22</Data></Cell>  
    96. 

  96.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    97. 

  97.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    98. 

  98.     <Cellss:StyleID="s19"><Datass:Type="String">疏</Data></Cell>  
    99. 

  99.     <Cellss:StyleID="s19"><Datass:Type="String">精</Data></Cell>  
    100. 

  100.     <Cellss:StyleID="s19"><Datass:Type="String">疏</Data></Cell>  
    101. 

  101.     <Cellss:StyleID="s19"><Datass:Type="Number">168</Data></Cell>  
    102. 

  102.     <Cellss:StyleID="s19"><Datass:Type="Number">193</Data></Cell>  
    103. 

  103.     <Cellss:StyleID="s19"><Datass:Type="Number">264</Data></Cell>  
    104. 

  104.     <Cellss:StyleID="s19"><Datass:Type="Number">350</Data></Cell>  
    105. 

  105.     <Cellss:StyleID="s19"><Datass:Type="Number">19250</Data></Cell>  
    106. 

  106.    </Row>  
    107. 

  107.    <Row>  
    108. 

  108.     <Cellss:StyleID="s18"><Datass:Type="String">★★★★★</Data></Cell>  
    109. 

  109.     <Cellss:StyleID="s19"><Datass:Type="String">関羽</Data></Cell>  
    110. 

  110.     <Cellss:StyleID="s19"><Datass:Type="Number">95</Data></Cell>  
    111. 

  111.     <Cellss:StyleID="s19"><Datass:Type="Number">97</Data></Cell>  
    112. 

  112.     <Cellss:StyleID="s19"><Datass:Type="Number">75</Data></Cell>  
    113. 

  113.     <Cellss:StyleID="s19"><Datass:Type="Number">62</Data></Cell>  
    114. 

  114.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    115. 

  115.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    116. 

  116.     <Cellss:StyleID="s19"><Datass:Type="String">通</Data></Cell>  
    117. 

  117.     <Cellss:StyleID="s19"><Datass:Type="String">精</Data></Cell>  
    118. 

  118.     <Cellss:StyleID="s19"><Datass:Type="String">疏</Data></Cell>  
    119. 

  119.     <Cellss:StyleID="s19"><Datass:Type="Number">165</Data></Cell>  
    120. 

  120.     <Cellss:StyleID="s19"><Datass:Type="Number">191</Data></Cell>  
    121. 

  121.     <Cellss:StyleID="s19"><Datass:Type="Number">260</Data></Cell>  
    122. 

  122.     <Cellss:StyleID="s19"><Datass:Type="Number">347</Data></Cell>  
    123. 

  123.     <Cellss:StyleID="s19"><Datass:Type="Number">19085</Data></Cell>  
    124. 

  124.    </Row>  
    125. 

  125.    <Row>  
    126. 

  126.     <Cellss:StyleID="s18"><Datass:Type="String">★★★★★</Data></Cell>  
    127. 

  127.     <Cellss:StyleID="s19"><Datass:Type="String">马超</Data></Cell>  
    128. 

  128.     <Cellss:StyleID="s19"><Datass:Type="Number">88</Data></Cell>  
    129. 

  129.     <Cellss:StyleID="s19"><Datass:Type="Number">97</Data></Cell>  
    130. 

  130.     <Cellss:StyleID="s19"><Datass:Type="Number">44</Data></Cell>  
    131. 

  131.     <Cellss:StyleID="s19"><Datass:Type="Number">26</Data></Cell>  
    132. 

  132.     <Cellss:StyleID="s19"><Datass:Type="String">精</Data></Cell>  
    133. 

  133.     <Cellss:StyleID="s19"><Datass:Type="String">通</Data></Cell>  
    134. 

  134.     <Cellss:StyleID="s19"><Datass:Type="String">疏</Data></Cell>  
    135. 

  135.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    136. 

  136.     <Cellss:StyleID="s19"><Datass:Type="String">通</Data></Cell>  
    137. 

  137.     <Cellss:StyleID="s19"><Datass:Type="Number">168</Data></Cell>  
    138. 

  138.     <Cellss:StyleID="s19"><Datass:Type="Number">187</Data></Cell>  
    139. 

  139.     <Cellss:StyleID="s19"><Datass:Type="Number">259</Data></Cell>  
    140. 

  140.     <Cellss:StyleID="s19"><Datass:Type="Number">353</Data></Cell>  
    141. 

  141.     <Cellss:StyleID="s19"><Datass:Type="Number">19415</Data></Cell>  
    142. 

  142.    </Row>  
    143. 

  143.    <Row>  
    144. 

  144.     <Cellss:StyleID="s18"><Datass:Type="String">★★★★★</Data></Cell>  
    145. 

  145.     <Cellss:StyleID="s19"><Datass:Type="String">赵雲</Data></Cell>  
    146. 

  146.     <Cellss:StyleID="s19"><Datass:Type="Number">91</Data></Cell>  
    147. 

  147.     <Cellss:StyleID="s19"><Datass:Type="Number">96</Data></Cell>  
    148. 

  148.     <Cellss:StyleID="s19"><Datass:Type="Number">76</Data></Cell>  
    149. 

  149.     <Cellss:StyleID="s19"><Datass:Type="Number">65</Data></Cell>  
    150. 

  150.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    151. 

  151.     <Cellss:StyleID="s19"><Datass:Type="String">通</Data></Cell>  
    152. 

  152.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    153. 

  153.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    154. 

  154.     <Cellss:StyleID="s19"><Datass:Type="String">疏</Data></Cell>  
    155. 

  155.     <Cellss:StyleID="s19"><Datass:Type="Number">192</Data></Cell>  
    156. 

  156.     <Cellss:StyleID="s19"><Datass:Type="Number">170</Data></Cell>  
    157. 

  157.     <Cellss:StyleID="s19"><Datass:Type="Number">267</Data></Cell>  
    158. 

  158.     <Cellss:StyleID="s19"><Datass:Type="Number">329</Data></Cell>  
    159. 

  159.     <Cellss:StyleID="s19"><Datass:Type="Number">18095</Data></Cell>  
    160. 

  160.    </Row>  
    161. 

  161.    <Row>  
    162. 

  162.     <Cellss:StyleID="s18"><Datass:Type="String">★★★★★</Data></Cell>  
    163. 

  163.     <Cellss:StyleID="s19"><Datass:Type="String">许褚</Data></Cell>  
    164. 

  164.     <Cellss:StyleID="s19"><Datass:Type="Number">65</Data></Cell>  
    165. 

  165.     <Cellss:StyleID="s19"><Datass:Type="Number">96</Data></Cell>  
    166. 

  166.     <Cellss:StyleID="s19"><Datass:Type="Number">36</Data></Cell>  
    167. 

  167.     <Cellss:StyleID="s19"><Datass:Type="Number">20</Data></Cell>  
    168. 

  168.     <Cellss:StyleID="s19"><Datass:Type="String">精</Data></Cell>  
    169. 

  169.     <Cellss:StyleID="s19"><Datass:Type="String">通</Data></Cell>  
    170. 

  170.     <Cellss:StyleID="s19"><Datass:Type="String">疏</Data></Cell>  
    171. 

  171.     <Cellss:StyleID="s19"><Datass:Type="String">通</Data></Cell>  
    172. 

  172.     <Cellss:StyleID="s19"><Datass:Type="String">疏</Data></Cell>  
    173. 

  173.     <Cellss:StyleID="s19"><Datass:Type="Number">161</Data></Cell>  
    174. 

  174.     <Cellss:StyleID="s19"><Datass:Type="Number">101</Data></Cell>  
    175. 

  175.     <Cellss:StyleID="s19"><Datass:Type="Number">197</Data></Cell>  
    176. 

  176.     <Cellss:StyleID="s19"><Datass:Type="Number">217</Data></Cell>  
    177. 

  177.     <Cellss:StyleID="s19"><Datass:Type="Number">11935</Data></Cell>  
    178. 

  178.    </Row>  
    179. 

  179.    <Row>  
    180. 

  180.     <Cellss:StyleID="s18"><Datass:Type="String">★★★★★</Data></Cell>  
    181. 

  181.     <Cellss:StyleID="s19"><Datass:Type="String">典韦</Data></Cell>  
    182. 

  182.     <Cellss:StyleID="s19"><Datass:Type="Number">56</Data></Cell>  
    183. 

  183.     <Cellss:StyleID="s19"><Datass:Type="Number">95</Data></Cell>  
    184. 

  184.     <Cellss:StyleID="s19"><Datass:Type="Number">35</Data></Cell>  
    185. 

  185.     <Cellss:StyleID="s19"><Datass:Type="Number">29</Data></Cell>  
    186. 

  186.     <Cellss:StyleID="s19"><Datass:Type="String">通</Data></Cell>  
    187. 

  187.     <Cellss:StyleID="s19"><Datass:Type="String">精</Data></Cell>  
    188. 

  188.     <Cellss:StyleID="s19"><Datass:Type="String">疏</Data></Cell>  
    189. 

  189.     <Cellss:StyleID="s19"><Datass:Type="String">疏</Data></Cell>  
    190. 

  190.     <Cellss:StyleID="s19"><Datass:Type="String">疏</Data></Cell>  
    191. 

  191.     <Cellss:StyleID="s19"><Datass:Type="Number">151</Data></Cell>  
    192. 

  192.     <Cellss:StyleID="s19"><Datass:Type="Number">91</Data></Cell>  
    193. 

  193.     <Cellss:StyleID="s19"><Datass:Type="Number">186</Data></Cell>  
    194. 

  194.     <Cellss:StyleID="s19"><Datass:Type="Number">215</Data></Cell>  
    195. 

  195.     <Cellss:StyleID="s19"><Datass:Type="Number">11825</Data></Cell>  
    196. 

  196.    </Row>  
    197. 

  197.    <Row>  
    198. 

  198.     <Cellss:StyleID="s18"><Datass:Type="String">★★★★★</Data></Cell>  
    199. 

  199.     <Cellss:StyleID="s19"><Datass:Type="String">甘宁</Data></Cell>  
    200. 

  200.     <Cellss:StyleID="s19"><Datass:Type="Number">86</Data></Cell>  
    201. 

  201.     <Cellss:StyleID="s19"><Datass:Type="Number">94</Data></Cell>  
    202. 

  202.     <Cellss:StyleID="s19"><Datass:Type="Number">76</Data></Cell>  
    203. 

  203.     <Cellss:StyleID="s19"><Datass:Type="Number">18</Data></Cell>  
    204. 

  204.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    205. 

  205.     <Cellss:StyleID="s19"><Datass:Type="String">精</Data></Cell>  
    206. 

  206.     <Cellss:StyleID="s19"><Datass:Type="String">精</Data></Cell>  
    207. 

  207.     <Cellss:StyleID="s19"><Datass:Type="String">精</Data></Cell>  
    208. 

  208.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    209. 

  209.     <Cellss:StyleID="s19"><Datass:Type="Number">181</Data></Cell>  
    210. 

  210.     <Cellss:StyleID="s19"><Datass:Type="Number">183</Data></Cell>  
    211. 

  211.     <Cellss:StyleID="s19"><Datass:Type="Number">270</Data></Cell>  
    212. 

  212.     <Cellss:StyleID="s19"><Datass:Type="Number">351</Data></Cell>  
    213. 

  213.     <Cellss:StyleID="s19"><Datass:Type="Number">19305</Data></Cell>  
    214. 

  214.    </Row>  
    215. 

  215.    <Row>  
    216. 

  216.     <Cellss:StyleID="s18"><Datass:Type="String">★★★★★</Data></Cell>  
    217. 

  217.     <Cellss:StyleID="s19"><Datass:Type="String">庞德</Data></Cell>  
    218. 

  218.     <Cellss:StyleID="s19"><Datass:Type="Number">80</Data></Cell>  
    219. 

  219.     <Cellss:StyleID="s19"><Datass:Type="Number">94</Data></Cell>  
    220. 

  220.     <Cellss:StyleID="s19"><Datass:Type="Number">70</Data></Cell>  
    221. 

  221.     <Cellss:StyleID="s19"><Datass:Type="Number">44</Data></Cell>  
    222. 

  222.     <Cellss:StyleID="s19"><Datass:Type="String">通</Data></Cell>  
    223. 

  223.     <Cellss:StyleID="s19"><Datass:Type="String">精</Data></Cell>  
    224. 

  224.     <Cellss:StyleID="s19"><Datass:Type="String">精</Data></Cell>  
    225. 

  225.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    226. 

  226.     <Cellss:StyleID="s19"><Datass:Type="String">通</Data></Cell>  
    227. 

  227.     <Cellss:StyleID="s19"><Datass:Type="Number">174</Data></Cell>  
    228. 

  228.     <Cellss:StyleID="s19"><Datass:Type="Number">150</Data></Cell>  
    229. 

  229.     <Cellss:StyleID="s19"><Datass:Type="Number">244</Data></Cell>  
    230. 

  230.     <Cellss:StyleID="s19"><Datass:Type="Number">288</Data></Cell>  
    231. 

  231.     <Cellss:StyleID="s19"><Datass:Type="Number">15840</Data></Cell>  
    232. 

  232.    </Row>  
    233. 

  233.    <Row>  
    234. 

  234.     <Cellss:StyleID="s18"><Datass:Type="String">★★★★★</Data></Cell>  
    235. 

  235.     <Cellss:StyleID="s19"><Datass:Type="String">文醜</Data></Cell>  
    236. 

  236.     <Cellss:StyleID="s19"><Datass:Type="Number">78</Data></Cell>  
    237. 

  237.     <Cellss:StyleID="s19"><Datass:Type="Number">94</Data></Cell>  
    238. 

  238.     <Cellss:StyleID="s19"><Datass:Type="Number">25</Data></Cell>  
    239. 

  239.     <Cellss:StyleID="s19"><Datass:Type="Number">25</Data></Cell>  
    240. 

  240.     <Cellss:StyleID="s19"><Datass:Type="String">精</Data></Cell>  
    241. 

  241.     <Cellss:StyleID="s19"><Datass:Type="String">通</Data></Cell>  
    242. 

  242.     <Cellss:StyleID="s19"><Datass:Type="String">精</Data></Cell>  
    243. 

  243.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    244. 

  244.     <Cellss:StyleID="s19"><Datass:Type="String">疏</Data></Cell>  
    245. 

  245.     <Cellss:StyleID="s19"><Datass:Type="Number">172</Data></Cell>  
    246. 

  246.     <Cellss:StyleID="s19"><Datass:Type="Number">103</Data></Cell>  
    247. 

  247.     <Cellss:StyleID="s19"><Datass:Type="Number">197</Data></Cell>  
    248. 

  248.     <Cellss:StyleID="s19"><Datass:Type="Number">222</Data></Cell>  
    249. 

  249.     <Cellss:StyleID="s19"><Datass:Type="Number">12210</Data></Cell>  
    250. 

  250.    </Row>  
    251. 

  251.    <Row>  
    252. 

  252.     <Cellss:StyleID="s18"><Datass:Type="String">★★★★★</Data></Cell>  
    253. 

  253.     <Cellss:StyleID="s19"><Datass:Type="String">黄忠</Data></Cell>  
    254. 

  254.     <Cellss:StyleID="s19"><Datass:Type="Number">86</Data></Cell>  
    255. 

  255.     <Cellss:StyleID="s19"><Datass:Type="Number">93</Data></Cell>  
    256. 

  256.     <Cellss:StyleID="s19"><Datass:Type="Number">60</Data></Cell>  
    257. 

  257.     <Cellss:StyleID="s19"><Datass:Type="Number">52</Data></Cell>  
    258. 

  258.     <Cellss:StyleID="s19"><Datass:Type="String">通</Data></Cell>  
    259. 

  259.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    260. 

  260.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    261. 

  261.     <Cellss:StyleID="s19"><Datass:Type="String">精</Data></Cell>  
    262. 

  262.     <Cellss:StyleID="s19"><Datass:Type="String">疏</Data></Cell>  
    263. 

  263.     <Cellss:StyleID="s19"><Datass:Type="Number">185</Data></Cell>  
    264. 

  264.     <Cellss:StyleID="s19"><Datass:Type="Number">171</Data></Cell>  
    265. 

  265.     <Cellss:StyleID="s19"><Datass:Type="Number">263</Data></Cell>  
    266. 

  266.     <Cellss:StyleID="s19"><Datass:Type="Number">321</Data></Cell>  
    267. 

  267.     <Cellss:StyleID="s19"><Datass:Type="Number">17655</Data></Cell>  
    268. 

  268.    </Row>  
    269. 

  269.    <Row>  
    270. 

  270.     <Cellss:StyleID="s18"><Datass:Type="String">★★★★★</Data></Cell>  
    271. 

  271.     <Cellss:StyleID="s19"><Datass:Type="String">太史慈</Data></Cell>  
    272. 

  272.     <Cellss:StyleID="s19"><Datass:Type="Number">82</Data></Cell>  
    273. 

  273.     <Cellss:StyleID="s19"><Datass:Type="Number">93</Data></Cell>  
    274. 

  274.     <Cellss:StyleID="s19"><Datass:Type="Number">66</Data></Cell>  
    275. 

  275.     <Cellss:StyleID="s19"><Datass:Type="Number">58</Data></Cell>  
    276. 

  276.     <Cellss:StyleID="s19"><Datass:Type="String">精</Data></Cell>  
    277. 

  277.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    278. 

  278.     <Cellss:StyleID="s19"><Datass:Type="String">疏</Data></Cell>  
    279. 

  279.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    280. 

  280.     <Cellss:StyleID="s19"><Datass:Type="String">疏</Data></Cell>  
    281. 

  281.     <Cellss:StyleID="s19"><Datass:Type="Number">175</Data></Cell>  
    282. 

  282.     <Cellss:StyleID="s19"><Datass:Type="Number">148</Data></Cell>  
    283. 

  283.     <Cellss:StyleID="s19"><Datass:Type="Number">241</Data></Cell>  
    284. 

  284.     <Cellss:StyleID="s19"><Datass:Type="Number">299</Data></Cell>  
    285. 

  285.     <Cellss:StyleID="s19"><Datass:Type="Number">16445</Data></Cell>  
    286. 

  286.    </Row>  
    287. 

  287.    <Row>  
    288. 

  288.     <Cellss:StyleID="s18"><Datass:Type="String">★★★★★</Data></Cell>  
    289. 

  289.     <Cellss:StyleID="s19"><Datass:Type="String">颜良</Data></Cell>  
    290. 

  290.     <Cellss:StyleID="s19"><Datass:Type="Number">79</Data></Cell>  
    291. 

  291.     <Cellss:StyleID="s19"><Datass:Type="Number">93</Data></Cell>  
    292. 

  292.     <Cellss:StyleID="s19"><Datass:Type="Number">42</Data></Cell>  
    293. 

  293.     <Cellss:StyleID="s19"><Datass:Type="Number">32</Data></Cell>  
    294. 

  294.     <Cellss:StyleID="s19"><Datass:Type="String">精</Data></Cell>  
    295. 

  295.     <Cellss:StyleID="s19"><Datass:Type="String">精</Data></Cell>  
    296. 

  296.     <Cellss:StyleID="s19"><Datass:Type="String">疏</Data></Cell>  
    297. 

  297.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    298. 

  298.     <Cellss:StyleID="s19"><Datass:Type="String">疏</Data></Cell>  
    299. 

  299.     <Cellss:StyleID="s19"><Datass:Type="Number">172</Data></Cell>  
    300. 

  300.     <Cellss:StyleID="s19"><Datass:Type="Number">121</Data></Cell>  
    301. 

  301.     <Cellss:StyleID="s19"><Datass:Type="Number">214</Data></Cell>  
    302. 

  302.     <Cellss:StyleID="s19"><Datass:Type="Number">246</Data></Cell>  
    303. 

  303.     <Cellss:StyleID="s19"><Datass:Type="Number">13530</Data></Cell>  
    304. 

  304.    </Row>  
    305. 

  305.    <Row>  
    306. 

  306.     <Cellss:StyleID="s18"><Datass:Type="String">★★★★★</Data></Cell>  
    307. 

  307.     <Cellss:StyleID="s19"><Datass:Type="String">张辽</Data></Cell>  
    308. 

  308.     <Cellss:StyleID="s19"><Datass:Type="Number">93</Data></Cell>  
    309. 

  309.     <Cellss:StyleID="s19"><Datass:Type="Number">92</Data></Cell>  
    310. 

  310.     <Cellss:StyleID="s19"><Datass:Type="Number">78</Data></Cell>  
    311. 

  311.     <Cellss:StyleID="s19"><Datass:Type="Number">58</Data></Cell>  
    312. 

  312.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    313. 

  313.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    314. 

  314.     <Cellss:StyleID="s19"><Datass:Type="String">通</Data></Cell>  
    315. 

  315.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    316. 

  316.     <Cellss:StyleID="s19"><Datass:Type="String">通</Data></Cell>  
    317. 

  317.     <Cellss:StyleID="s19"><Datass:Type="Number">183</Data></Cell>  
    318. 

  318.     <Cellss:StyleID="s19"><Datass:Type="Number">167</Data></Cell>  
    319. 

  319.     <Cellss:StyleID="s19"><Datass:Type="Number">257</Data></Cell>  
    320. 

  320.     <Cellss:StyleID="s19"><Datass:Type="Number">330</Data></Cell>  
    321. 

  321.     <Cellss:StyleID="s19"><Datass:Type="Number">18150</Data></Cell>  
    322. 

  322.    </Row>  
    323. 

  323.    <Row>  
    324. 

  324.     <Cellss:StyleID="s18"><Datass:Type="String">★★★★★</Data></Cell>  
    325. 

  325.     <Cellss:StyleID="s19"><Datass:Type="String">孙策</Data></Cell>  
    326. 

  326.     <Cellss:StyleID="s19"><Datass:Type="Number">92</Data></Cell>  
    327. 

  327.     <Cellss:StyleID="s19"><Datass:Type="Number">92</Data></Cell>  
    328. 

  328.     <Cellss:StyleID="s19"><Datass:Type="Number">69</Data></Cell>  
    329. 

  329.     <Cellss:StyleID="s19"><Datass:Type="Number">70</Data></Cell>  
    330. 

  330.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    331. 

  331.     <Cellss:StyleID="s19"><Datass:Type="String">精</Data></Cell>  
    332. 

  332.     <Cellss:StyleID="s19"><Datass:Type="String">通</Data></Cell>  
    333. 

  333.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    334. 

  334.     <Cellss:StyleID="s19"><Datass:Type="String">精</Data></Cell>  
    335. 

  335.     <Cellss:StyleID="s19"><Datass:Type="Number">130</Data></Cell>  
    336. 

  336.     <Cellss:StyleID="s19"><Datass:Type="Number">192</Data></Cell>  
    337. 

  337.     <Cellss:StyleID="s19"><Datass:Type="Number">230</Data></Cell>  
    338. 

  338.     <Cellss:StyleID="s19"><Datass:Type="Number">325</Data></Cell>  
    339. 

  339.     <Cellss:StyleID="s19"><Datass:Type="Number">17875</Data></Cell>  
    340. 

  340.    </Row>  
    341. 

  341.    <Row>  
    342. 

  342.     <Cellss:StyleID="s18"><Datass:Type="String">★★★★★</Data></Cell>  
    343. 

  343.     <Cellss:StyleID="s19"><Datass:Type="String">魏延</Data></Cell>  
    344. 

  344.     <Cellss:StyleID="s19"><Datass:Type="Number">81</Data></Cell>  
    345. 

  345.     <Cellss:StyleID="s19"><Datass:Type="Number">92</Data></Cell>  
    346. 

  346.     <Cellss:StyleID="s19"><Datass:Type="Number">69</Data></Cell>  
    347. 

  347.     <Cellss:StyleID="s19"><Datass:Type="Number">49</Data></Cell>  
    348. 

  348.     <Cellss:StyleID="s19"><Datass:Type="String">精</Data></Cell>  
    349. 

  349.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    350. 

  350.     <Cellss:StyleID="s19"><Datass:Type="String">通</Data></Cell>  
    351. 

  351.     <Cellss:StyleID="s19"><Datass:Type="String">精</Data></Cell>  
    352. 

  352.     <Cellss:StyleID="s19"><Datass:Type="String">疏</Data></Cell>  
    353. 

  353.     <Cellss:StyleID="s19"><Datass:Type="Number">173</Data></Cell>  
    354. 

  354.     <Cellss:StyleID="s19"><Datass:Type="Number">150</Data></Cell>  
    355. 

  355.     <Cellss:StyleID="s19"><Datass:Type="Number">242</Data></Cell>  
    356. 

  356.     <Cellss:StyleID="s19"><Datass:Type="Number">291</Data></Cell>  
    357. 

  357.     <Cellss:StyleID="s19"><Datass:Type="Number">16005</Data></Cell>  
    358. 

  358.    </Row>  
    359. 

  359.    <Row>  
    360. 

  360.     <Cellss:StyleID="s18"><Datass:Type="String">★★★★★</Data></Cell>  
    361. 

  361.     <Cellss:StyleID="s19"><Datass:Type="String">华雄</Data></Cell>  
    362. 

  362.     <Cellss:StyleID="s19"><Datass:Type="Number">81</Data></Cell>  
    363. 

  363.     <Cellss:StyleID="s19"><Datass:Type="Number">92</Data></Cell>  
    364. 

  364.     <Cellss:StyleID="s19"><Datass:Type="Number">56</Data></Cell>  
    365. 

  365.     <Cellss:StyleID="s19"><Datass:Type="Number">40</Data></Cell>  
    366. 

  366.     <Cellss:StyleID="s19"><Datass:Type="String">通</Data></Cell>  
    367. 

  367.     <Cellss:StyleID="s19"><Datass:Type="String">通</Data></Cell>  
    368. 

  368.     <Cellss:StyleID="s19"><Datass:Type="String">疏</Data></Cell>  
    369. 

  369.     <Cellss:StyleID="s19"><Datass:Type="String">神</Data></Cell>  
    370. 

  370.     <Cellss:StyleID="s19"><Datass:Type="String">疏</Data></Cell>  
    371. 

  371.     <Cellss:StyleID="s19"><Datass:Type="Number">173</Data></Cell>  
    372. 

  372.     <Cellss:StyleID="s19"><Datass:Type="Number">137</Data></Cell>  
    373. 

  373.     <Cellss:StyleID="s19"><Datass:Type="Number">229</Data></Cell>  
    374. 

  374.     <Cellss:StyleID="s19"><Datass:Type="Number">269</Data></Cell>  
    375. 

  375.     <Cellss:StyleID="s19"><Datass:Type="Number">14795</Data></Cell>  
    376. 

  376.    </Row>  
    377. 



<?xml version="1.0"?>
<?mso-application progid="Excel.Sheet"?>
<Workbook xmlns="urn:schemas-microsoft-com:office:spreadsheet"
 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">
 <DocumentProperties xmlns="urn:schemas-microsoft-com:office:office">
  <Created>2006-09-13T11:21:51Z</Created>
  <LastSaved>2012-04-26T13:39:57Z</LastSaved>
  <Version>14.00</Version>
 </DocumentProperties>
 <OfficeDocumentSettings xmlns="urn:schemas-microsoft-com:office:office">
  <AllowPNG/>
  <RemovePersonalInformation/>
 </OfficeDocumentSettings>
 <ExcelWorkbook xmlns="urn:schemas-microsoft-com:office:excel">
  <WindowHeight>5850</WindowHeight>
  <WindowWidth>11070</WindowWidth>
  <WindowTopX>0</WindowTopX>
  <WindowTopY>90</WindowTopY>
  <ProtectStructure>False</ProtectStructure>
  <ProtectWindows>False</ProtectWindows>
 </ExcelWorkbook>
 <Styles>
  <Style ss:ID="Default" ss:Name="Normal">
   <Alignment ss:Vertical="Center"/>
   <Borders/>
   <Font ss:FontName="宋体" x:CharSet="134" ss:Size="11" ss:Color="#000000"/>
   <Interior/>
   <NumberFormat/>
   <Protection/>
  </Style>
  <Style ss:ID="s16">
   <Alignment ss:Horizontal="Left" ss:Vertical="Center" ss:WrapText="1"/>
   <Font ss:FontName="宋体" x:CharSet="134" ss:Bold="1"/>
  </Style>
  <Style ss:ID="s17">
   <Alignment ss:Horizontal="Center" ss:Vertical="Center" ss:WrapText="1"/>
   <Font ss:FontName="宋体" x:CharSet="134" ss:Size="12" ss:Bold="1"/>
  </Style>
  <Style ss:ID="s18">
   <Alignment ss:Horizontal="Left" ss:Vertical="Center" ss:WrapText="1"/>
   <Font ss:FontName="宋体" x:CharSet="134"/>
  </Style>
  <Style ss:ID="s19">
   <Alignment ss:Horizontal="Center" ss:Vertical="Center" ss:WrapText="1"/>
  </Style>
 </Styles>
 <Worksheet ss:Name="三国数据">
  <Table ss:ExpandedColumnCount="16" ss:ExpandedRowCount="682" x:FullColumns="1"
   x:FullRows="1" ss:DefaultColumnWidth="54" ss:DefaultRowHeight="13.5">
   <Row ss:Height="28.5">
    <Cell ss:StyleID="s16"><Data ss:Type="String">星级</Data></Cell>
    <Cell ss:StyleID="s17"><Data ss:Type="String">姓名</Data></Cell>
    <Cell ss:StyleID="s17"><Data ss:Type="String">统率</Data></Cell>
    <Cell ss:StyleID="s17"><Data ss:Type="String">武力</Data></Cell>
    <Cell ss:StyleID="s17"><Data ss:Type="String">智力</Data></Cell>
    <Cell ss:StyleID="s17"><Data ss:Type="String">政治</Data></Cell>
    <Cell ss:StyleID="s17"><Data ss:Type="String">枪兵</Data></Cell>
    <Cell ss:StyleID="s17"><Data ss:Type="String">戟兵</Data></Cell>
    <Cell ss:StyleID="s17"><Data ss:Type="String">弩兵</Data></Cell>
    <Cell ss:StyleID="s17"><Data ss:Type="String">骑兵</Data></Cell>
    <Cell ss:StyleID="s17"><Data ss:Type="String">兵器</Data></Cell>
    <Cell ss:StyleID="s17"><Data ss:Type="String">统武</Data></Cell>
    <Cell ss:StyleID="s17"><Data ss:Type="String">统智</Data></Cell>
    <Cell ss:StyleID="s17"><Data ss:Type="String">统武智 </Data></Cell>
    <Cell ss:StyleID="s17"><Data ss:Type="String">统武智政</Data></Cell>
    <Cell ss:StyleID="s17"><Data ss:Type="String">50级工资 </Data></Cell>
   </Row>
   <Row>
    <Cell ss:StyleID="s18"><Data ss:Type="String">★★★★★</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">吕布</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">87</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">100</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">26</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">13</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">精</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">疏</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">161</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">194</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">257</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">350</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">19250</Data></Cell>
   </Row>
   <Row>
    <Cell ss:StyleID="s18"><Data ss:Type="String">★★★★★</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">张飞</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">85</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">98</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">30</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">22</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">疏</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">精</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">疏</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">168</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">193</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">264</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">350</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">19250</Data></Cell>
   </Row>
   <Row>
    <Cell ss:StyleID="s18"><Data ss:Type="String">★★★★★</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">関羽</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">95</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">97</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">75</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">62</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">通</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">精</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">疏</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">165</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">191</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">260</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">347</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">19085</Data></Cell>
   </Row>
   <Row>
    <Cell ss:StyleID="s18"><Data ss:Type="String">★★★★★</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">马超</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">88</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">97</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">44</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">26</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">精</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">通</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">疏</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">通</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">168</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">187</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">259</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">353</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">19415</Data></Cell>
   </Row>
   <Row>
    <Cell ss:StyleID="s18"><Data ss:Type="String">★★★★★</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">赵雲</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">91</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">96</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">76</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">65</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">通</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">疏</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">192</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">170</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">267</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">329</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">18095</Data></Cell>
   </Row>
   <Row>
    <Cell ss:StyleID="s18"><Data ss:Type="String">★★★★★</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">许褚</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">65</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">96</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">36</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">20</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">精</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">通</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">疏</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">通</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">疏</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">161</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">101</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">197</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">217</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">11935</Data></Cell>
   </Row>
   <Row>
    <Cell ss:StyleID="s18"><Data ss:Type="String">★★★★★</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">典韦</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">56</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">95</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">35</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">29</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">通</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">精</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">疏</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">疏</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">疏</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">151</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">91</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">186</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">215</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">11825</Data></Cell>
   </Row>
   <Row>
    <Cell ss:StyleID="s18"><Data ss:Type="String">★★★★★</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">甘宁</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">86</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">94</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">76</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">18</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">精</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">精</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">精</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">181</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">183</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">270</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">351</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">19305</Data></Cell>
   </Row>
   <Row>
    <Cell ss:StyleID="s18"><Data ss:Type="String">★★★★★</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">庞德</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">80</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">94</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">70</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">44</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">通</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">精</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">精</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">通</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">174</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">150</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">244</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">288</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">15840</Data></Cell>
   </Row>
   <Row>
    <Cell ss:StyleID="s18"><Data ss:Type="String">★★★★★</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">文醜</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">78</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">94</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">25</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">25</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">精</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">通</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">精</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">疏</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">172</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">103</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">197</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">222</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">12210</Data></Cell>
   </Row>
   <Row>
    <Cell ss:StyleID="s18"><Data ss:Type="String">★★★★★</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">黄忠</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">86</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">93</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">60</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">52</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">通</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">精</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">疏</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">185</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">171</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">263</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">321</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">17655</Data></Cell>
   </Row>
   <Row>
    <Cell ss:StyleID="s18"><Data ss:Type="String">★★★★★</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">太史慈</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">82</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">93</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">66</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">58</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">精</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">疏</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">疏</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">175</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">148</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">241</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">299</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">16445</Data></Cell>
   </Row>
   <Row>
    <Cell ss:StyleID="s18"><Data ss:Type="String">★★★★★</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">颜良</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">79</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">93</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">42</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">32</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">精</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">精</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">疏</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">疏</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">172</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">121</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">214</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">246</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">13530</Data></Cell>
   </Row>
   <Row>
    <Cell ss:StyleID="s18"><Data ss:Type="String">★★★★★</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">张辽</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">93</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">92</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">78</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">58</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">通</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">通</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">183</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">167</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">257</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">330</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">18150</Data></Cell>
   </Row>
   <Row>
    <Cell ss:StyleID="s18"><Data ss:Type="String">★★★★★</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">孙策</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">92</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">92</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">69</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">70</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">精</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">通</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">精</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">130</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">192</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">230</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">325</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">17875</Data></Cell>
   </Row>
   <Row>
    <Cell ss:StyleID="s18"><Data ss:Type="String">★★★★★</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">魏延</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">81</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">92</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">69</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">49</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">精</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">通</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">精</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">疏</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">173</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">150</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">242</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">291</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">16005</Data></Cell>
   </Row>
   <Row>
    <Cell ss:StyleID="s18"><Data ss:Type="String">★★★★★</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">华雄</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">81</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">92</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">56</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">40</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">通</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">通</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">疏</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">神</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="String">疏</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">173</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">137</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">229</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">269</Data></Cell>
    <Cell ss:StyleID="s19"><Data ss:Type="Number">14795</Data></Cell>
   </Row>


 


最终运行结果截图如下：


读取到得武将数据如图，




运行后的部分截图：




转自：http://blog.csdn.net/lufeng20/article/details/7542955









        

        

            posted on 
2013-03-09 21:26 
kalor 
阅读(393) 
评论(0) 
编辑 
收藏 
举报

        

    











    
    

    
    

    

        

    

        

            
                
                
            
        

    

        

            
                
            
        

    

    

    





        

             

    

    

	Powered by: 
	

	
	博客园
	

	Copyright © 2024 kalor

Powered by .NET 9.0 on Kubernetes