JAVA-考试复习
记录对于本学期选修课Java程序设计的有关复习
思维难度肯定不大 重点就是能熟练掌握各种操作 文件I/O 序列化/ 类继承/重写/... 异常抛出以及自定义处理 等
RP++
数组
创建
int[] a = new int[10];
Integer[] a = new Integer[10];
Arrays
用Arrays有时能比较方便的直接sort/二分查找
用法:
String str = Arrays.toString(a); // 输出 [1,2,3,...]
Arrays.sort(a); // 默认按升序排列
int pos = Arrays.binarySearch(a,5); // 排序好后可以直接调用二分查找
当然也可以用Arrays来实现自定义排序 和以前用的Collection一样 自定义一个继承实现
具体实现:
自定义排序
其实把Arrays.sort() 改为 Collections.sort()更好 更兼容
注意！！！
return 1/-1 !!!
md ...
Integer
class MyCompare implements Comparator<Integer>{
@Override
public int compare(Integer o1, Integer o2) {
if(o1>o2) return -1;
return 1;
}
}
由于这里的接口写的Integer 所以a数组也要定义成Integer 而且Comparator里面是没有int类型的 必须用Integer!
Integer[] a = new Integer[10];
for(int i=0;i<10;i++) {
a[i] = 10-i;
}
a[9] = 11;
System.out.println(a[2]);
String str = Arrays.toString(a);
System.out.println(str);
Arrays.sort(a,new MyCompare());
这样就实现了降序排列 (具体返回-1/1 多试试就行了)
补: 返回1 表示我想要调整顺序 -1表示我不想调整顺序
if(o1.dis(o)>o2.dis(o))return 1;
代表这种情况我想要交换o1,o2 所以是按照到o的距离从小到大排序
其他带字符串的 或者其他特殊比较规则的也同理
String
这里的>改为String 的 compareto就行了
例如字母降序排列
class MyCompare implements Comparator<String>{
@Override
public int compare(String o1, String o2) {
if(o1.compareTo(o2)>0) return -1;
return 0;
}
}
String[] s = new String[10];
for(int i=0;i<10;i++) {
s[i] = Character.toString((char) (i+65));
}
Arrays.sort(s,new MyCompare());
I/O
这部分是重中之重 也是最繁琐的地方...
把大部分模板/用法记下来 考试直接用即可
普通I/O
Scanner
这部分应该不会过多考察 最多用一个 hasnextxxx来判断接下来的输入类型 抛出个异常啥的
Scanner sc = new Scanner(System.in);
sc.hasNextInt();
sc.hasNextFloat();
...
文件I/O
主要从文件类型来分别给出模板 (都使用try-with-resource来操作文件)
注意！br开了后面一定要br.close()!!!!
csv文件
这也是最常考的文件类型
重点掌握从.csv文件读取行/列 (感觉应该不会要求写入csv文件吧... 肯定不可能考的...)
以模拟题为例 要读取iris.csv所有列的数据
是这种格式:
5.1 3.5 1.4 0.2 setosa
我们就将每行每列都当作字符串读取 然后用parsedouble把前几个转为double类型
这里统一用bufferreader类和filereader组合来读取
这里用List将lines存起来 由于每个line是csv也就是逗号隔开 所以用一个split清洗数据
写出来最初框架: 遇到这种要从.csv文件提取数据的都可以这么写
try {
BufferedReader br = new BufferedReader(new FileReader("D:\\浏览器下载\\iris.csv"));
List<String> lines = new ArrayList<String>();
String line;
while((line = br.readLine()) != null) {
lines.add(line);
}
boolean FirstLine=true;
for(String line1:lines) {
if(FirstLine==true) {
FirstLine = false;
continue;
}
String[] values = line1.split(",");
double a = Double.parseDouble(values[0]);
double b = Double.parseDouble(values[1]);
double c = Double.parseDouble(values[2]);
double d = Double.parseDouble(values[3]);
String e = values[4];
Flower tmpFlower = new Flower(a, b, c, d, e);
flower[flower_cnt] = tmpFlower;
flower_cnt++;
}
for(Flower i:flower) {
if(i!=null)
System.out.println(i);
}
} catch (Exception e) {
System.out.println(e);
}
txt文件
要掌握.txt文件的读取和写入
大致写下就是这种:
感觉都统一BufferReader+FileReader+List(ArrayList)真香!
try {
BufferedReader br = new BufferedReader(new FileReader("D:\\浏览器下载\\test.txt"));
List<String> lines = new ArrayList<String>();
String line;
int line_cnt = 0;
while((line = br.readLine())!=null) {
lines.add(line);
line_cnt++;
}
for(String line1:lines) {
System.out.println(line1);
}
} catch (Exception e) {
System.out.println(e);
}
读写一起大致就是这样 写的时候都xxx.toString转一下
一定要close()!!! 不然写入不了！！！
//txt文件读取
System.out.println("[+] txt ");
try {
BufferedReader br = new BufferedReader(new FileReader("D:\\浏览器下载\\test.txt"));
List<String> lines = new ArrayList<String>();
String line;
int line_cnt = 0;
while((line = br.readLine())!=null) {
lines.add(line);
line_cnt++;
}
for(String line1:lines) {
System.out.println(line1);
}
//txt文件写入
try {
System.out.println("[+] txt-out");
BufferedWriter br2 = new BufferedWriter(new FileWriter("D:\\浏览器下载\\test_out.txt"));
for(String line2:lines) {
int out = Integer.parseInt(line2);
out += 2;
br2.write(Integer.toString(out));
br2.newLine();
}
br2.close(); //!!!!!!!!!!!!!!!!!!
} catch (Exception e) {
System.out.println(e);
}
br.close(); //!!!!!!!!!!!!!!!!!!!!!
} catch (Exception e) {
System.out.println(e);
}
文件I/O大致就这两类 其他的类型应该是不会考的
熟练掌握运用 文件I/O+类初始定义 就能把题目大致框架搭好 剩下的逐步填充完善就行了(面向对象自顶向下的编程思想)
异常处理
使用try catch 块 (考试时的文件I/O操作强制要求)
自定义异常
extends Exception 即可 (有时考试要求必须要继承某个类 这就直接继承了...)
这里放一个最简单实现的模板 (只是为了应付考试的强制要求自定义异常)
class MyException extends Exception{
private static final long serialVersionUID = 114514L;
public MyException() {
super();
}
public MyException(String msg) {
super(msg);
}
public MyException(String msg,Exception cause) {
super(msg,cause);
}
}
然后在函数后throw
比如:
public static void main(String[] args) throws MyException{
...
if(ai<0) {
throw new MyException("Cannot be negative!!!");
}
}
这样虽然啥也没处理 但是能自定义抛出异常的输出语句 足以应付考试
Java数据结构
记录下常用的ArrayList/Hashmap等 考试用着更加方便
ArrayList
只需要知道add方法就够用了
List<String> lines = new ArrayList<String>();
...
lines.add(line);
自定义排序都用List<>+Collections.sort()
Collections.sort(lines,new MyCompare());
Hashmap
着重了解一下Hashmap的用法
在考试有关排序后统计字符串次数/取最大等很好用
HashMap<Integer, String> Sites = new HashMap<Integer, String>();
Sites.put(1,"233");
String str = Sites.get(1); // 获取key对应的value
int size = Sites.size(); // 获取hashmap中键值对个数
重点 : 需要统计个数 并记录对应映射
Sites.put(k.getE(), Sites.getOrDefault(k.getE(), 0)+1);
取最大值:
int maxx=0;String aString="";
for(String string : Sites.keySet()) {
if(Sites.get(string) != null) {
if(Sites.get(string)>maxx) {
maxx = Sites.get(string);
aString = string;
}
}
}
Java序列化
Java一个类要能序列化 要 implements Serializable
序列化对象用到的I/O操作均为字节流
ObjectOutputStream ser = new ObjectOutputStream(new FileOutputStream("D:\\浏览器下载\\answer_3.ser"));
然后用 ser.writeObject() 写入
具体来说就是这种
class xxx implements Serializable{
...
}
try {
System.out.println("[+] 4.");
ObjectOutputStream ser = new ObjectOutputStream(new FileOutputStream("D:\\浏览器下载\\answer_3.ser"));
Flower[] sorted_fower = new Flower[1005];
flower_cnt = 0;
for(Flower i:flowerList) {
sorted_fower[flower_cnt] = i;
flower_cnt++;
}
for(int i=flower_cnt-10;i<flower_cnt;i++) {
ser.writeObject(sorted_fower[i]);
}
ser.close();
System.out.println("[+] 4. end");
} catch (Exception e) {
e.printStackTrace();
}
模拟题
最后贴一个模拟题的完整代码 写麻了...
大致照着这个搞 考试没多大问题 打不了写的麻烦一点罢了...
模拟题目:
文件iris.csv中每行是一朵鸢尾花的花萼长度、花萼宽度、花瓣长度、花瓣宽度、种类，在IDE中设计一个Java工程（工程名为iris，保存到D盘根目录，包名为sbschoold.姓名拼音，如bsbschool.sbdesu，工程中只包含一个iris.java，2-5题要求在main函数中完成，必须使用try-with-resource操作文件）：
1. 设计iris类，实例变量包括iris.csv中的所有列，注意选择合适的数据类型。要求所有变量均定义为私有变量，所有对变量的访问必须通过类的公开方法进行。覆盖继承自Object的某一方法，按iris.csv表格中从左至右的顺序print对象的各个属性，输出形如：“[5.1, 3.5, 1.4, 0.2]: setosa”(不包含引号，注意空格)。该方法将作为后续文本输出的默认方式。（15分）
2. 从iris.csv中逐行读入所有数据，用构造函数初始化iris对象，将其存入一个集合中（可选择合适的数据结构）并记录输入顺序。在输入顺序的第71个位置之前插入一个新的对象：“[6.7, 3.3, 5.7, 2.5]: virginica”。对该集合进行遍历，将集合中的对象数量写入文本文件answer_1.txt中；再按输入顺序，将花萼长度在(6.0,6.9)区间内的对象接着输出至answer_1.txt。所输出的数量单独占一行，每个对象占一行。（20分）
3. 升级iris类，添加一个方法，使之能够计算两个iris对象之间的欧氏距离（即：将iris.csv表格中每一行的前四列数字视作一个四维向量，两个向量的对应分量相减后得到一个差向量，求该差向量的模长即为欧氏距离）。取一个假想对象“[1, 2, 3, 4]: whatever”，以到这个对象的欧式距离从小到大为排序规则，对集合中所有的对象进行排序，将排序结果输出至文本文件answer_2.txt。每个对象单独占一行。（20分）
4. 升级iris类，使其支持序列化。按第3题中的排序规则，将最后10个iris对象序列化到文件answer_3.ser（20分）
5. 将第2题读入的iris.csv中的对象称为训练集；读入test.csv中的对象存入另一个集合，称为测试集（这些对象的种类是“未知”）。对测试集中的每一个对象，请使用第3题中的方法计算训练集中各对象和它之间的欧氏距离，并记录其中和它距离最小的8个。将这8个训练对象中出现次数最多的种类作为测试对象的预测种类并修改其“种类”属性（若这8个中出现数量相同的种类，则以相对距离由小到大排序时先出现的种类优先）。将修改完成之后的各测试集对象按原输入顺序输出至文本文件answer_4.txt。每个对象占一行。（10分）
6. 对第5问的程序，自定义异常，并自行设计测试案例抛出并捕获该异常（10分）
7. 为所编写的程序添加规范的注释。（5分）
8. 提交时请将整个工程打包为“考场号-学号-姓名.zip”，如“01-xxx-22222222.zip”，提交至指定云盘链接。
我的丑陋代码实现:
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.ObjectOutputStream;
import java.io.OutputStreamWriter;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
class Flower implements Serializable{
private double a,b,c,d;
private String e;
public Flower(double a,double b,double c,double d,String e) {
this.a = a;this.b = b;this.c = c;this.d = d;this.e = e;
}
public void ModifyE(String e) {
this.e = e;
}
public double geta() {
return this.a;
}
public double getb() {
return this.b;
}
public double getc() {
return this.c;
}
public double getd() {
return this.d;
}
public String gete() {
return this.e;
}
public String toString() {
String s = "";
s = "["+Double.toString(this.a)+","+Double.toString(this.b)+","+Double.toString(this.c)+","+Double.toString(this.d);
s = s+"]:";
s = s + this.e;
return s;
}
public double dis(Flower o) {
double aa = this.a - o.a;
double bb = this.b - o.b;
double cc = this.c - o.c;
double dd = this.d - o.d;
return Math.sqrt(aa*aa+bb*bb+cc*cc+dd*dd);
}
}
class MyCompare1 implements Comparator<Flower>{
@Override
public int compare(Flower o1, Flower o2) {
Flower cFlower = new Flower(1, 2, 3, 4, "whatever");
if(o1.dis(cFlower)>o2.dis(cFlower))return 1;
return -1;
}
}
public class Iris {
static Flower compareoFlower;
static class MyCompare2 implements Comparator<Flower>{
public MyCompare2(Flower o) {
// TODO Auto-generated constructor stub
}
@Override
public int compare(Flower o1, Flower o2) {
if(o1.dis(compareoFlower)>o2.dis(compareoFlower)) return 1;
return -1;
}
}
public static void main(String[] args){
System.out.printf("%s\n", "[+] START ");
Flower[] flower = new Flower[1005];
int flower_cnt=0;
// 1.
try {
System.out.println("[+] 1.");
BufferedReader br = new BufferedReader(new FileReader("D:\\浏览器下载\\iris.csv"));
List<String> lines = new ArrayList<String>();
String line;
while((line = br.readLine()) != null) {
lines.add(line);
}
boolean FirstLine=true;
for(String line1:lines) {
if(FirstLine==true) {
FirstLine = false;
continue;
}
String[] values = line1.split(",");
double a = Double.parseDouble(values[0]);
double b = Double.parseDouble(values[1]);
double c = Double.parseDouble(values[2]);
double d = Double.parseDouble(values[3]);
String e = values[4];
Flower tmpFlower = new Flower(a, b, c, d, e);
flower[flower_cnt] = tmpFlower;
flower_cnt++;
}
for(Flower i:flower) {
if(i!=null)
System.out.println(i);
}
System.out.println("[+] 1. end");
br.close();
} catch (Exception e) {
System.out.println(e);
}
// 2.
try {
System.out.println("[+] 2.");
flower_cnt = 0;
BufferedReader br = new BufferedReader(new FileReader("D:\\浏览器下载\\iris.csv"));
List<String> lines = new ArrayList<String>();
String line;
while((line = br.readLine()) != null) {
lines.add(line);
}
boolean FirstLine=true;
for(String line1:lines) {
if(FirstLine==true) {
FirstLine = false;
continue;
}
String[] values = line1.split(",");
double a = Double.parseDouble(values[0]);
double b = Double.parseDouble(values[1]);
double c = Double.parseDouble(values[2]);
double d = Double.parseDouble(values[3]);
String e = values[4];
Flower tmpFlower = new Flower(a, b, c, d, e);
flower[flower_cnt] = tmpFlower;
flower_cnt++;
}
flower_cnt++;
Flower[] tmp_flower = new Flower[1005];
for(int i=0;i<70;i++)
tmp_flower[i] = flower[i];
tmp_flower[70] = new Flower(6.7, 3.3, 5.7, 2.5, "virginica");
for(int i=71;i<flower_cnt;i++)
tmp_flower[i] = flower[i-1];
try {
BufferedWriter br2 = new BufferedWriter(new FileWriter("D:\\浏览器下载\\answer_1.txt"));
br2.write(Integer.toString(flower_cnt));
br2.newLine();
for(Flower i:tmp_flower) {
if(i==null)continue;
double l = i.geta();
if(l>6.0&&l<6.9) {
br2.write(i.toString());
br2.newLine();
}
}
br2.close();
System.out.println("[+] 2. end");
// 3.
System.out.println("[+] 3.");
List<Flower> flowerList = new ArrayList<Flower>();
for(int i=0;i<flower_cnt;i++)
flowerList.add(tmp_flower[i]);
Collections.sort(flowerList,new MyCompare1());
for(Flower c:flowerList) {
// System.out.println(c.dis(new Flower(1, 2, 3, 4, "WOw!")));
}
// System.out.println("---------------");
try {
BufferedWriter br3 = new BufferedWriter(new FileWriter("D:\\浏览器下载\\answer_2.txt"));
for(Flower ifFlower:flowerList) {
if(ifFlower==null)continue;
br3.write(ifFlower.toString());
br3.newLine();
}
br3.close();
System.out.println("[+] 3. end");
} catch (Exception e) {
System.out.println(e);
}
// 4.
try {
System.out.println("[+] 4.");
ObjectOutputStream ser = new ObjectOutputStream(new FileOutputStream("D:\\浏览器下载\\answer_3.ser"));
Flower[] sorted_fower = new Flower[1005];
flower_cnt = 0;
for(Flower i:flowerList) {
sorted_fower[flower_cnt] = i;
flower_cnt++;
}
for(int i=flower_cnt-10;i<flower_cnt;i++) {
ser.writeObject(sorted_fower[i]);
}
ser.close();
System.out.println("[+] 4. end");
// 5.
System.out.println("[+] 5.");
int test_flower_cnt = 0;
Flower[] testFlowers = new Flower[1005];
List<String> test_flower = new ArrayList<String>();
try {
BufferedReader br4 = new BufferedReader(new FileReader("D:\\浏览器下载\\test.csv"));
String line1;
while((line1 = br4.readLine()) != null) {
test_flower.add(line1);
}
boolean FirstLine1=true;
for(String line11:test_flower) {
if(FirstLine1==true) {
FirstLine1 = false;
continue;
}
String[] values = line11.split(",");
double a = Double.parseDouble(values[0]);
double b = Double.parseDouble(values[1]);
double c = Double.parseDouble(values[2]);
double d = Double.parseDouble(values[3]);
String e = values[4];
Flower tmpFlower = new Flower(a, b, c, d, e);
testFlowers[test_flower_cnt] = tmpFlower;
test_flower_cnt++;
}
for(Flower dFlower:testFlowers) {
if(dFlower==null)continue;
// System.out.println(dFlower);
}
// System.out.println(test_flower_cnt);
for(int i=0;i<test_flower_cnt;i++) {
Flower test = testFlowers[i];
List<Flower> trainingList = new ArrayList<Flower>();
for(int j=0;j<flower_cnt;j++) {
trainingList.add(tmp_flower[j]);
}
compareoFlower = test;
Collections.sort(trainingList, new MyCompare2(test));
for(Flower c:trainingList) {
if(c==null)continue;
// System.out.println(c.dis(test));
}
int ccc=0;
HashMap<String, Integer> map = new HashMap<String, Integer>();
for(Flower iFlower:trainingList) {
ccc++;
if(ccc>8)break;
map.put(iFlower.gete(), map.getOrDefault(iFlower.gete(), 0)+1); // 建立映射关系并且更新++
}
System.out.println(map);
int maxx=0;String aString = "";
for(String string:map.keySet()) {
if(map.get(string)>maxx) {
maxx = map.get(string);
aString = string;
}
}
System.out.println(aString);
testFlowers[i].ModifyE(aString);
// System.out.println(testFlowers[i]);
System.out.println("-----------------------");
}
try {
BufferedWriter br5 = new BufferedWriter(new FileWriter("D:\\浏览器下载\\answer_4.txt"));
for(Flower cString:testFlowers) {
if(cString==null)continue;
System.out.println(cString);
br5.write(cString.toString());
br5.newLine();
}
br5.close();
}
catch (Exception e) {
// TODO: handle exception
}
br4.close();
System.out.println("[+] 5. end");
} catch (Exception e) {
e.printStackTrace();
}
} catch (Exception e) {
e.printStackTrace();
}
} catch (Exception e) {
System.out.println(e);
}
br.close();
} catch (Exception e) {
System.out.println(e);
}
System.out.println("[+] END ");
}
}
