面向对象技术与方法（JAVA）
关键词：面向对象JAVA、机器学习、聚类算法、K近邻算法、手写数字识别
背景信息
这是2022年春季学期，北京理工大学，计算机学院，软件工程，开设的一门必修课程，为期八周，共32课时，难度较大，教师课件使用英文讲授，自学的收获更多。
成绩主要分为三部分，作业、实验、考试。本篇内容为实验题，共六个大题，其中两道难度非常高，以当时的水平写出来实属不易。其他题目更多的是了解面向对象语言的特点和语法。
本篇内容是实验题中的难题。
2022面向对象JAVA实验
目录
(点击跳转)
- K近邻算法与手写数字识别
- K-means聚类算法
一、K近邻算法与手写数字识别
K近邻算法是分类数据最简单有效的算法，它采用基于实例的学习方法。简单地说，它采用测量不同样本之间距离的方法进行分类。它的工作原理是：存在一个样本数据集合，也称为训练样本集，并且样本集中的每个数据都有标签，即我们知道每个数据所属的分类。输入没有标签的新数据之后，将新数据的每个特征与样本集中数据的对应特征进行比较，然后算法提取样本集中特征最相似数据（最近邻）的分类标签。一般来说，我们只选择样本数据集中前K个最相似的数据，这就是K近邻算法中K的出处。最后，选择K个最相似数据中出现次数最多的分类。
要求设计和实现类KnnNumber，构造一个使用K近邻分类器的手写识别系统，该系统可以识别数字0到9.需要识别的数字已经处理成具有相同的色彩和大小：使用文本格式表示的32像素*32像素黑白图像（0/1二值图像）。
数据集在digits.zip中。其中目录trainingDigits包含了训练样本集，其中包含了大约2000个样本数据，每个数据的文件名表明了它的标签（0~9的某个数字），每个数字大约有200个样本数据；目录testDigits中包含了大约900个测试数据。请合理设计KnnNumber的数据成员和成员方法，以实现算法的各个步骤。将K取值为[3,9]之间的一个整数，找出分类准确率最高的K值。
。
思路
根据要求，我们首先要实现两个文件夹所有数据的读取，训练数据与测试数据使用两个Digits类来读取与储存，其中Digits包含File[]的列表与 Unit列表，分别用于读取与存储。
首先我们在主函数中建立两个文件标签sa1 sa2分别指向两个文件夹，继而建立对应的Digits成员，并调用构造器完成文件的读取。每个文件夹中包含0~9十种txt文本，每种数量不定，但是拥有共同特征，如0都包含“0_”这样的字段，通过.contain（）方法筛选出所有0的文本文件，存入列表files中的一个文件数组中，重复十次，为了简化代码，获取文件目录的时候还使用了lambda表达式。读取文本文件使用了FileReader类并用Bufferedreader类包装，逐行读取字符串。
train与test的数据都读取完毕后，从test中逐个地全部遍历train文件中所有的txt文件，遍历过程中对train中每个txt文件的rank成员赋值，即两个图片的欧氏距离，由于开方运算并不会影响距离的大小排序，故省去了开方这一步，也可以说这是汉明距离，对最终的结果不会影响。对test中的一个txt文件，train的每个txt文件已经得到rank值，对train中所有数据进行升序排序，选取K值，得到前K个文件，按照标签出现的频次决定test对象的标签，将此过程执行于所有的test对象，与实际的标签对比，计算出正确率；改变K值，找出最高正确率的K值。
收获
该题目考察了文件目录的获取，文件的筛选，文件的读取，大量数据的存储与计算，以及K近邻算法的应用。
首先使用两个Digits类来读取与储存训练数据和测试数据，Digits类的数据成员有包含File[]的列表与 Unit列表，分别用于读取与存储。继而在主函数中建立两个sa1 sa2（sample的前两个字母）对象分别指向两个目标文件夹，然后建立对应的Digits成员，并调用构造器完成文件的读取。
两个文件夹中各包含0~9十种txt文本，数量不定，但是拥有共同特征，如0文件都包含 “0_” 这样的字段，通过使用字符串调用.contain（）方法筛选出所有0的文本文件，存入列表files中的同一个文件数组中，重复十次，代码中还使用lambda表达式简化代码。
读取文本文件使用了Bufferedreader类，逐行读取字符串。
train与test的数据都读取完毕后，从test中逐个地全部遍历train文件中所有的txt文件，遍历过程中对train中每个txt文件的rank成员赋值，即两个图片的欧氏距离，由于开方运算并不会影响距离的大小排序，故省去了开方这一步，也可以说这是汉明距离，对最终的结果不会影响。
对test中的一个txt文件，train的每个txt文件已经得到rank值，对train中所有数据进行升序排序，选取K值，得到前K个文件，按照标签出现的频次决定test对象的标签，将此过程执行于所有的test对象，与实际的标签对比，计算出正确率；改变K值，找出最高正确率的K值。
源码
package java_exp2022;
import java.util.*;
import java.io.*;
/*由于欧氏距离的开平方计算并不会影响大小顺序，故本算法忽略*/
class Unit{
//这是将每个数字文本文件（如 0_12.txt ）转化为一个类Unit
int label = -1;//标签初始化为-1，防止出错
Integer temp_rank = 0;//这里是排序依据，根据题目需要，这里可以赋值欧氏距离
ArrayList<String> line32 = new ArrayList<String>();
/*建立一个列表容纳三十二行01数据，存储为String类*/
Unit(int digit, ArrayList<String> lines){
//使用构造器赋值
label = digit ;
for(String s : lines)
line32.add(s);
}/*每个单元存入 数字 + 32行 */
}
class KnnCompare{//K近邻算法的计数单元
int label = -1;
Integer counter = 0;
//使用对象类型便于调用.compareTo方法
KnnCompare(int i){//构造器赋值
label = i;
}
}
class KnnNumber{
ArrayList<KnnCompare> K_count = new ArrayList<KnnCompare>();
//建立一个列表，方便对于K个数目的预测目标计数与排序
boolean check(int label,Digits train) {
K_count.add(new KnnCompare(0));
K_count.add(new KnnCompare(1));
K_count.add(new KnnCompare(2));
K_count.add(new KnnCompare(3));
K_count.add(new KnnCompare(4));
K_count.add(new KnnCompare(5));
K_count.add(new KnnCompare(6));
K_count.add(new KnnCompare(7));
K_count.add(new KnnCompare(8));
K_count.add(new KnnCompare(9));
//将对象添加入列表
int outcome = -2;//最终输出的标签，初始化以防出错
int K_value = 3;//K值
for(int i = 0; i < K_value ;i++)
K_count.get(train.ulist.get(i).label).counter++;
//对前K个标签预测进行计数
K_count.sort((KnnCompare k1,KnnCompare k2) -> k2.counter.compareTo(k1.counter) );
//对列表进行降序排列，此处使用了lambda表达式
outcome = K_count.get(0).label;//结果赋值
System.out.println(" 预测数字 "+outcome+" (K_value = "+K_value+")");
//打印预测结果
K_count.clear();//释放列表
return label == outcome;//返回布尔类型，真--标签正确，假-标签错误
}
}
class Digits{
//数据处理类
ArrayList<File[]> files = new ArrayList<File[]>();
ArrayList<Unit> ulist = new ArrayList<Unit>();
//便于处理文件的阅读、文件信息的储存
Digits(File c){
files.add(c.listFiles((f,name) -> name.contains("0_")));
files.add(c.listFiles((f,name) -> name.contains("1_")));
files.add(c.listFiles((f,name) -> name.contains("2_")));
files.add(c.listFiles((f,name) -> name.contains("3_")));
files.add(c.listFiles((f,name) -> name.contains("4_")));
files.add(c.listFiles((f,name) -> name.contains("5_")));
files.add(c.listFiles((f,name) -> name.contains("6_")));
files.add(c.listFiles((f,name) -> name.contains("7_")));
files.add(c.listFiles((f,name) -> name.contains("8_")));
files.add(c.listFiles((f,name) -> name.contains("9_")));
//使用lambda表达式，获取文件夹内部含有特定字段的文件，并放入同一个文件类数组中
read();//调用方法
}
void read() {
for(int num = 0; num <= 9; num++) {/*循环10个数字*/
for(int i = 0; i < files.get(num).length ; i++) {/*i循环每个数字的约200个文件*/
try {
BufferedReader br = new BufferedReader(new FileReader(files.get(num)[i]));
ArrayList<String> temp = new ArrayList<String>();
//32行暂持存储与temp
for(int j = 0; j < 32 ; j++) {/*j循环每个文件的32行*/
String read = null;//非空则写入
while( (read = br.readLine()) != null)
temp.add(read);
}
ulist.add(new Unit(num,temp));
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
public class Project4 {
public static void main(String[] args) {
File sa1 = new File("D:\\javatest\\trainingDigits");
Digits train = new Digits(sa1);
//建立训练类，下为测试类
File sa2 = new File("D:\\javatest\\testDigits");
Digits test = new Digits(sa2);
KnnNumber K = new KnnNumber();
int counter = 0;//计算正确标签数目
for(int test_target = 0 ; test_target < test.ulist.size() ;test_target++) {
/*遍历所有 测试用例*/
for(int i = 0; i < train.ulist.size();i++) {
/*遍历所有 训练数据*/
int sum = 0;//欧氏距离
int j = 0;//用于对测试用例行的循环计数
for(String a : train.ulist.get(i).line32) {
for(int l=0;l<32;l++) //l循环的是单行字符
if(a.toCharArray()[l] != test.ulist.get(test_target).line32.get(j).toCharArray()[l] )sum++;
j++;
}
train.ulist.get(i).temp_rank = sum;//距离赋值便于排序
}
train.ulist.sort((Unit u1,Unit u2) -> u1.temp_rank.compareTo(u2.temp_rank) );
/*排序并传递*/
System.out.print("测试用例 "+test_target+", 实际数字 "+test.ulist.get(test_target).label);
if( K.check(test.ulist.get(test_target).label, train) )counter++;
}
double successRate = (double)counter/test.ulist.size()*100;//计算正确率
System.out.println("counter = "+counter+" 数字识别正确率 = "+successRate+"%");
}
}
/*OutPut
测试用例 0, 实际数字 0 预测数字 0 (K_value = 3)
测试用例 1, 实际数字 0 预测数字 0 (K_value = 3)
……
……
……
测试用例 944, 实际数字 9 预测数字 9 (K_value = 3)
测试用例 945, 实际数字 9 预测数字 9 (K_value = 3)
counter = 934 数字识别正确率 = 98.73150105708245%
*/附件(百度云)
DigitsForTestAndTrain.zip 提取码：LINK
二、K-means聚类算法
K-means算法是经典的聚类算法，其基本思想是：以空间中k个点为中心进行聚类，对最靠近他们的对象归类。通过迭代的方法，逐次更新各聚类中心的值，直至得到最好的聚类结果。假设要把样本集分为K个类别，算法描述如下：
（1）适当选择k个类的初始中心
（2）在第I次迭代中，对任意一个样本，求其到K个中心的距离，将该样本归到距离最短的中心所在的类
（3）利用均值方式更新该类的中心值
（4）对于所有的K个聚类中心，如果利用（2）（3）的迭代法更新后，值保持基本不变，则迭代结束，否则继续迭代。
要求用java编写K-means算法（k值可以自己设定），根据花的属性对数据集Iris Data Set进行聚类，并将聚类结果（sepal length，sepal width，petal length，petal width ，cluster label）打印至cluster.txt文件。iris数据包括四个属性：sepal length花萼长度，sepal width花萼宽度，petal length花瓣长度，petal width花瓣宽度。其中第五个值表示该样本属于哪一个类。Iris.data 可以用写字板打开。
注意：样本点间的距离直接用向量的欧氏距离。
思路
该题目考察了文件的读取，写入，double类型的计算，以及K-means聚类算法。
先从data文件中使用Bufferedreader类逐行读取数据，获得花朵的四个特征值，并且记录花朵的真实种类，使用1，2，3值代替名字，存储于Flower类的一个对象中，类的成员还包括sortkind表示使用K-means算法所分的类。使用ArrayList容纳。
进而计算距离既定的三个中心的距离，进行排序，就近决定类别，最后调用Update方法进行中心的更新。
运行结果出来后，有约25个错误，适当修改后余下13个错误分类，尝试数次始终不能低于13个，但是13个错误都出现在第三类，所以考虑增加一个聚类中心。
最终，在四个聚类中心的分类下，仅仅只有一个分类错误，分类效果非常好。
源码
package java_exp2022;
import java.io.*;
import java.util.*;
class Flower{
double sepal_length = 0; //花萼长度
double sepal_width = 0; //花萼宽度
double petal_length = 0; //花瓣长度
double petal_width = 0; //花瓣宽度
int realkind = -1;
int sortkind = -1;
Flower(String s){
char[] a = s.toCharArray();
sepal_length = (double)(a[0]-'0') +(double)(a[2]-'0')/10.0;
sepal_width = (double)(a[4]-'0') +(double)(a[6]-'0')/10.0;
petal_length = (double)(a[8]-'0') +(double)(a[10]-'0')/10.0;
petal_width = (double)(a[12]-'0') +(double)(a[14]-'0')/10.0;
if(s.contains("Iris-setosa"))realkind = 1;
if(s.contains("Iris-versicolor"))realkind = 2;
if(s.contains("Iris-virginica"))realkind = 3;
}
double Distance(Flower r1) {
double d = 0;
d = (r1.petal_length-this.petal_length)*(r1.petal_length-this.petal_length)
+(r1.petal_width-this.petal_width)*(r1.petal_width-this.petal_width)
+(r1.sepal_length-this.sepal_length)*(r1.sepal_length-this.sepal_length)
+(r1.sepal_width-this.sepal_width)*(r1.sepal_width-this.sepal_width);
return Math.sqrt(d);
}
int FlowerSort(ArrayList<Flower> K_means) {
int sortkind = -1;
double d1=this.Distance(K_means.get(0));
double d2=this.Distance(K_means.get(1));
double d3=this.Distance(K_means.get(2));
double d4=this.Distance(K_means.get(3));
if (d1<=d2 && d1<=d3 && d1<=d4)sortkind = 1;
else if(d2< d1 && d2<=d3 && d2<=d4)sortkind = 2;
else if(d3< d1 && d3< d2 && d3<=d4)sortkind = 3;
else if(d4< d1 && d4< d2 && d4< d3)sortkind = 4;
return sortkind;
}
void Update(ArrayList<Flower> K_means,int sortkind) {
double[] feature = {0,0,0,0};
int counter = 0;
for(Flower a : K_means) {
if(a.sortkind==sortkind) {
counter++;
feature[0] += a.petal_length;
feature[1] += a.petal_width;
feature[2] += a.sepal_length;
feature[3] += a.sepal_width;
}
}
K_means.get(sortkind-1).petal_length=feature[0]/counter;
K_means.get(sortkind-1).petal_width=feature[1]/counter;
K_means.get(sortkind-1).sepal_length=feature[2]/counter;
K_means.get(sortkind-1).sepal_width=feature[3]/counter;
}
}
public class Project5 {
public static void main(String[] args) {
File read = new File("D:\\javatest\\iris.data");
File write = new File("D:\\javatest\\cluster.txt");
try {
write.createNewFile();
} catch (IOException e1) {
e1.printStackTrace();
}
ArrayList<Flower> vase = new ArrayList<Flower>();
String temp = null;
try {
BufferedReader br = new BufferedReader(new FileReader(read));
while( ( temp = br.readLine()).contains("Iris") ) {
vase.add(new Flower(temp));
}
br.close();
} catch (IOException e) {
e.printStackTrace();
}
/*预置中心*/
ArrayList<Flower> K_means = new ArrayList<Flower>();
K_means.add(new Flower("5.0,3.4,1.5,0.2"));
K_means.get(0).sortkind=1;
K_means.add(new Flower("5.9,2.7,4.3,1.3"));
K_means.get(1).sortkind=2;
K_means.add(new Flower("6.0,3.1,6.0,2.1"));
K_means.get(2).sortkind=3;
K_means.add(new Flower("6.2,2.8,6.0,2.0"));
K_means.get(3).sortkind=4;
System.out.println("初始中心");
for(Flower a : K_means) {
System.out.print(a.sepal_length+",");
System.out.print(a.sepal_width+",");
System.out.print(a.petal_length+",");
System.out.print(a.petal_width+", kind = ");
System.out.print(a.sortkind+"\n");
}
int wrong = 0;//java中传递列表、数组给方法（函数）效果和C大致相同
int o = 0;
System.out.println("开始迭代\n");
String s = null;
for(Flower a : vase) {
a.sortkind = a.FlowerSort(K_means);
K_means.add(a);
a.Update(K_means, a.sortkind);
if(o==7) {
s="\n";
o-=7;
}
else {
s=" ";
o++;
}
System.out.print(a.realkind+"--"+a.sortkind+s);
if(a.realkind!=a.sortkind)wrong++;
if(a.realkind==3 && a.sortkind==4)wrong--;
}
System.out.println("Wrong times = "+wrong);
try {
FileWriter wr = new FileWriter(write);
for(int i = 0;i < 4 ;i ++) {
Flower a = K_means.get(i);
if(i==0)wr.write("Iris-setosa ");
if(i==1)wr.write("Iris-versicolor ");
if(i==2)wr.write("Iris-virginica-I ");
if(i==3)wr.write("Iris-virginica-II ");
String f1 = String.format("%.2f", a.sepal_length);
a.sepal_length = Double.parseDouble(f1);
wr.write("("+a.sepal_length);
String f2 = String.format("%.2f", a.sepal_width);
a.sepal_width = Double.parseDouble(f2);
wr.write(", "+a.sepal_width);
String f3 = String.format("%.2f", a.petal_length);
a.petal_length = Double.parseDouble(f3);
wr.write(", "+a.petal_length);
String f4 = String.format("%.2f", a.petal_width);
a.petal_width = Double.parseDouble(f4);
wr.write(", "+a.petal_width+")\n");
}
wr.close();
} catch (IOException e) {
e.printStackTrace();
}
System.out.print("\n结果文件在 D:\\javatest\\cluster.txt ");
}
}
/*OutPut
初始中心
5.0,3.4,1.5,0.2, kind = 1
5.9,2.7,4.3,1.3, kind = 2
6.0,3.1,6.0,2.1, kind = 3
6.2,2.8,6.0,2.0, kind = 4
开始迭代
1--1 1--1 1--1 1--1 1--1 1--1 1--1 1--1
1--1 1--1 1--1 1--1 1--1 1--1 1--1 1--1
1--1 1--1 1--1 1--1 1--1 1--1 1--1 1--1
1--1 1--1 1--1 1--1 1--1 1--1 1--1 1--1
1--1 1--1 1--1 1--1 1--1 1--1 1--1 1--1
1--1 1--1 1--1 1--1 1--1 1--1 1--1 1--1
1--1 1--1 2--2 2--2 2--2 2--2 2--2 2--2
2--2 2--2 2--2 2--2 2--2 2--2 2--2 2--2
2--2 2--2 2--2 2--2 2--2 2--2 2--2 2--2
2--2 2--2 2--2 2--2 2--2 2--2 2--2 2--2
2--2 2--2 2--2 2--2 2--2 2--2 2--2 2--2
2--2 2--2 2--2 2--2 2--2 2--2 2--2 2--2
2--2 2--2 2--2 2--2 3--3 3--4 3--3 3--4
3--3 3--3 3--2 3--3 3--3 3--3 3--4 3--4
3--3 3--4 3--4 3--4 3--4 3--3 3--3 3--4
3--3 3--4 3--3 3--4 3--3 3--3 3--4 3--4
3--4 3--3 3--3 3--3 3--4 3--4 3--4 3--3
3--4 3--4 3--4 3--3 3--3 3--4 3--4 3--3
3--3 3--4 3--4 3--4 3--4 3--4 Wrong times = 1
结果文件在 D:\javatest\cluster.txt
*/附件(百度云)
iris.data 提取码：LINK
