一. 前言
三周的时间转瞬即过，我们也成功完成了总计三次大作业的代码编程，或多多少提升了自己的代码编程能力，同时三次大作业的最后一题对我们半学期来对java已学知识点的总体掌握情况进行了一定的综合考验。在此进行一定总结：
1.知识点
- 我们程序设计基础的代码的基本逻辑结构包括选择结构循环结构的使用，方法的创建；
- 类与对象包括类与对象的关系，类与类之间的关系，类内设计的规范及职责单一原则，类的分类及MVC模式；
- 一些与C语言截然不同但很有用的东西如List，java内各种各样为你定制好的函数；
- 一个很重要的东西-正则表达式；
2.题量
说实话题量并没有很多，挤出一个下午加上一个晚上肯定是能完成代码的基本构建的，其后的改错调试可以使用自己的间隙时间来进行，因此一个星期的时间肯定是足够的。
3.难度
三次大作业大约三分之一的同学都能拿到90分以上的好成绩，对于大部分难度属于中等，对于我也差不多，只是在修改测试点的时候非常的痛苦，因为在符合自我逻辑的改完后若还有测试点未过那么之后的查改就是在迷雾天里找路一样了。
二. 设计与分析
1.第一次大作业最后一题
import java.util.*;
import java.text.*;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
sc.nextLine();
int i=0;
Question[] q=new Question[n];
Paper x=new Paper(n);
for(i=0;i<n;i++) {
String example=sc.nextLine();
q[i]=new Question();
q[i].setExample(example);
}
x.setQuestionList(q);
String aL=sc.nextLine();
sc.nextLine();
AnswerPaper ax=new AnswerPaper(n,aL,x);
String[] result=ax.getResult();
for(int j=0;j<n;j++) {
System.out.println(x.getQuestion(j)+"~"+ax.getAnswer(j));
}
for(int j=0;j<n-1;j++) {
System.out.print(result[j]+" ");
}
System.out.print(result[n-1]);
}
}
class Question{
private int num=1;
private String include=null;
private String answer=null;
private String[] a;
public Question() {
}
public void setExample(String example) {
a=example.split("#");
num=Integer.parseInt(a[1].substring(2).trim());
include=a[2].substring(2).trim();
answer=a[3].substring(2).trim();
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String getInclude() {
return include;
}
public void setInclude(String include) {
this.include = include;
}
public String getAnswer() {
return answer;
}
public void setAnswer(String answer) {
this.answer = answer;
}
}
class Paper{
private int num;
private Question[] questionList;
public Paper(){
}
public Paper(int num){
this.num=num;
questionList=new Question[num];
}
public Question[] getQuestionList() {
return questionList;
}
public String getQuestion(int i) {
return questionList[i].getInclude();
}
public void setQuestionList(Question[] q) {
questionList= q;
Question t=new Question();
for(int i=0;i<num-1;i++) {
for(int j=i+1;j<num;j++) {
if(questionList[i].getNum()>questionList[j].getNum()) {
t=questionList[i];
questionList[i]=questionList[j];
questionList[j]=t;
}
}
}
}
public String judgeAnswer(int n,String anwser1) {
if(questionList[n].getAnswer().equals(anwser1)) {
return "true";
}
else {
return "false";
}
}
}
class AnswerPaper{
private int num;
private Paper model;
private String[] answerList;
private String[] result;
public AnswerPaper(){
}
public AnswerPaper(int num,String aL,Paper model){``
this.num=num;
answerList=new String[num];
this.model=model;
result=new String[num];
String[] aLL=aL.split("#");
for(int i=0;i<num;i++) {
answerList[i]=aLL[i+1].substring(2).trim();
}
}
public String getAnswer(int i) {
return answerList[i];
}
public String[] getResult() {
for(int i=0;i<num;i++) {
result[i]=model.judgeAnswer(i,answerList[i]);
}
return result;
}
}
- 第一次大作业的最后一题总体不算难，在分析完后为使代码显的清晰明了，我选择创建问题答卷试卷三个类来解决这些问题，题目类内存放题目号，题目，题目答案，试卷内放题目数和题目组，答卷内放对应的题目数，样卷，答题组及最终结果组，再由答卷自我输出评判结果。虽然这题难度不大但这题的训练对于我对java中自带函数的多样有了认知及字符串分割的使用有了明显的提升，例如“#N:1 #Q:1+1= #A:2”型的我便可以使用java内split函数进行空格分割，这是C语言所不具备的。
- 踩坑的话写这道题时印象很深的便是没看到最后的end的停止，以为是不输入了就是停止而疯狂去找有没有这样输入的方法导致浪费了大量时间o(╥﹏╥)o，第二就是nextInt输入好像不会自己加回车（？），导致我的输入有点问题，后面加了个空字符串输入解决的，但好像还是不太明白什么原理（？）。
2.第二次大作业最后一题
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String a="";
ArrayList<Question> qD=new ArrayList<>();
ArrayList<Paper> pD=new ArrayList<>();
ArrayList<AnswerPaper> aP=new ArrayList<>();
ArrayList<String> p=new ArrayList<>();
ArrayList<String> aw=new ArrayList<>();
while(!a.equals("end")){
a=sc.nextLine();
if(a.charAt(1)=='N'){
Question e=new Question();
e.setExample(a);
qD.add(e);
}else if(a.charAt(1)=='T'){
p.add(a);
}else if(a.charAt(1)=='S') {
aw.add(a);
}
}
QuestionData questionData=new QuestionData(qD);
int i,j;
for(i=0;i<p.size();i++){
Paper pa=new Paper(questionData);
pa.setExample(p.get(i));
pD.add(pa);
}
PaperData paperData=new PaperData(pD);
for(i=0;i< aw.size();i++){
AnswerPaper An=new AnswerPaper(aw.get(i),paperData);
aP.add(An);
}
for(i=0;i< aP.size();i++){
if(aP.get(i).exit==true) {
String[] result = aP.get(i).getResult();
for (j = 0; j < aP.get(i).getModel().getQuestionList().size(); j++) {
System.out.println(result[j]);
}
System.out.println(aP.get(i).getGrade());
}else{
System.out.println("The test paper number does not exist");
}
}
}
}
class Question{
private int num=1;
private String include=null;
private String answer=null;
private String[] a;
public Question() {
}
public void setExample(String example) {
a=example.split("#");
num=Integer.parseInt(a[1].substring(2).trim());
include=a[2].substring(2).trim();
answer=a[3].substring(2).trim();
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String getInclude() {
return include;
}
public void setInclude(String include) {
this.include = include;
}
public String getAnswer() {
return answer;
}
public void setAnswer(String answer) {
this.answer = answer;
}
}
class QuestionData{
ArrayList<Question> questionData= new ArrayList<>();
public Question getQuestion(int n){
for(int i=0;i<questionData.size();i++) {
if (questionData.get(i).getNum() == n) {
return questionData.get(i);
}
}
return null;
}
public QuestionData(ArrayList<Question> questionData) {
this.questionData = questionData;
int i=0,j=0;
Question t=new Question();
for(i=0;i<questionData.size()-1;i++){
for(j=i+1;j<questionData.size();j++){
if(questionData.get(i).getNum()>questionData.get(j).getNum()){
t=questionData.get(i);
questionData.set(i,questionData.get(j));
questionData.set(j,t);
}
}
}
}
}
class PaperData{
ArrayList<Paper> paperData=new ArrayList<>();
public Paper getPaper(int n){
for(int i=0;i<paperData.size();i++) {
if (paperData.get(i).getNum() == n) {
return paperData.get(i);
}
}
return null;
}
public PaperData(ArrayList<Paper> paperData) {
this.paperData = paperData;
int i=0,j=0;
Paper t=new Paper();
for(i=0;i<paperData.size()-1;i++){
for(j=i+1;j<paperData.size();j++){
if(paperData.get(i).getNum()>paperData.get(j).getNum()){
t=paperData.get(i);
paperData.set(i,paperData.get(j));
paperData.set(j,t);
}
}
}
}
}
class Paper{
private int num;
private ArrayList<Question> questionList=new ArrayList<>();
private ArrayList<Integer> grade=new ArrayList<>();
private String[] a;
private QuestionData questionData;
public int getNum() {
return num;
}
public Paper() {
}
public Paper(QuestionData questionData){
this.questionData=questionData;
}
public ArrayList<Question> getQuestionList() {
return questionList;
}
public ArrayList<Integer> getGrade() {
return grade;
}
public String getQuestion(int i) {
return questionList.get(i).getInclude();
}
public void setExample(String example){
a=example.split("[ -]");
int len=a.length;
num=Integer.parseInt(a[0].substring(3).trim());
for(int i=1;i<len;i=i+2) {
questionList.add(questionData.getQuestion(Integer.parseInt(a[i].trim())));
grade.add(Integer.parseInt(a[i+1].trim()));
}
int sum=0;
for(int i=0;i<grade.size();i++){
sum=sum+grade.get(i);
}
if(sum!=100){
System.out.println("alert: full score of test paper"+num+" is not 100 points");
}
}
public String judgeAnswer(int n,String anwser1) {
if(questionList.get(n).getAnswer().equals(anwser1)) {
return "true";
}
else {
return "false";
}
}
}
class AnswerPaper{
private int num;
private Paper model;
private ArrayList<String> answerList=new ArrayList<>();
private String[] result;
private int[] grade;
boolean exit=true;
public ArrayList<String> getAnswerList() {
return answerList;
}
public AnswerPaper(){
}
public AnswerPaper(String example,PaperData paperData){
String[] aLL=example.split("#");
int len=aLL.length;
num=Integer.parseInt(aLL[1].substring(2).trim());
model=paperData.getPaper(num);
if(model==null){
exit=false;
}
else {
result = new String[model.getQuestionList().size()];
grade = new int[model.getQuestionList().size()];
for (int i = 1; i < len - 1; i++) {
answerList.add(aLL[i + 1].substring(2).trim());
}
}
}
public Paper getModel() {
return model;
}
public String getAnswer(int i) {
return answerList.get(i);
}
public String[] getResult() {
for(int j=0;j<model.getQuestionList().size();j++){
result[j]="answer is null";
grade[j]=0;
}
for(int i=0;i<answerList.size();i++) {
result[i]= model.getQuestion(i)+"~"+answerList.get(i)+"~"+model.judgeAnswer(i, answerList.get(i));
if(model.judgeAnswer(i, answerList.get(i)).equals("true")){
grade[i]=model.getGrade().get(i);
}
}
return result;
}
public String getGrade() {
int sum=0;
StringBuilder gradere=new StringBuilder();
for(int j=0;j<model.getQuestionList().size();j++){
gradere.append(grade[j]+" ");
sum=sum+grade[j];
}
return gradere.toString().trim()+"~"+sum;
}
}
- 改动分析：第二次作业相较于第一次大作业添加了许多新要求包括多试卷多答卷的形式以及打分结果，因此我存放这些东西的容器也由数组改为了List，使其能动态存储防止数组大小设置拿不准，输入判断时不进行处理只进行判断是哪类的输入并传入相应类中进行相应的处理。
- 我在第一题的基础上加上了答卷库与试卷库的类用于应对多答卷多试卷的情况，同时加入了题目库类使代码看起来更加的好懂清晰。
- 题目类处理由#分割将三部分分别存入题号题目答案；
- 试卷类里面的题目数改为试卷号，加入题号及分数List，处理根据“ -”分割将题号及对应分数封开存储，同时根据题号索引从题目库里取题目放进题目组内，同时判断试卷总分是否到达100进行提示判断。
- 答卷类里加入所对应样卷号，以及样卷作为判分标准，加入成绩数组存储成绩，加入结果数组判定试卷结果，加入boolean型的exit判断此答卷是否非法，处理时根据“#”分割，先由获得的试卷号进行样卷索引，若失败将exit改为false表示答卷非法，否则进行下步对答卷答案的处理存贮，最后使用类内获得结果函数对试卷进行批判返回结果；
- 对于函数的复杂度总体来说在正常范围内，但主函数还是有些冗杂，目前没有想到什么好的办法。
- 心得：这里学到的最大的便是类与类之间的关系，如果类的设计设计的好的号后期的代码实现是明显会事半功倍的，初始我认为类就是强化版的C语言的结构体
可在实操后发现并非如此，类与类之间巧妙地关联是java的语言变得十分明了清洗，同样的，这对于代码的维护与修改肯定也是帮助十分大的，同时在了解java语言时API文档的初次接触对于我代码编程的帮助是十分大的，期内的函数库让我对java的理解更上了一层楼。 - 踩坑：在此踩的最大的坑就是就是空格了
，也是我思维严谨性的问题，开头没有意识到问题的严重性发现总有几个测试点过不去，然后疯狂的检查代码想在代码里找出自己的逻辑错误，然后发现了如果题目在试卷后输入就索引不到了，然后开心的开改，改完后发现测试点是一个都没加
（谢谢你），然后和同学进行了些（友好）交流后，我才意识到问题的严重性：题目和答案里都可以存在空格o(╥﹏╥)o，随后我一刀直接劈向我的问题类，才解决这个问题。
3.第三次大作业最后一题
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String a = "";
HashMap<Integer, Question> qD = new HashMap<>();
ArrayList<Paper> pD = new ArrayList<>();
ArrayList<AnswerPaper> aP = new ArrayList<>();
ArrayList<Student> stud = new ArrayList<>();
ArrayList<String> p = new ArrayList<>();
ArrayList<String> app = new ArrayList<>();
ArrayList<String> del = new ArrayList<>();
String[] stu;
int i, j;
int check = 0;
while (true) {
a = sc.nextLine();
if(a.equals("end")){
break;
}
if (a.matches("#N:.+#Q:.+#A:.*")) {
Question e = new Question();
e.setExample(a);
qD.put(Integer.parseInt(String.valueOf(a.charAt(3))), e);
} else if (a.matches("#T:\\d+\\s?(\\d+-\\d+\\s)*(\\d+-\\d+)?")) {
p.add(a);
} else if (a.matches("#S:\\d+ \\d+( #A:\\d+-.*)*")) {
app.add(a);
} else if (a.matches("#D:N-\\d+")) {
del.add(a);
if(qD.get(Integer.parseInt(a.substring(5)))==null){
continue;
}else {
qD.get(Integer.parseInt(a.substring(5))).setDel(true);
}
} else if (a.matches("#X:.+")) {
stu = a.split("-|:");
if(stu.length!=1){
for (i = 1; i < stu.length; i++) {
Student s = new Student();
s.setExample(stu[i]);
stud.add(s);
}
}
}else{
System.out.println("wrong format:"+a);
}
}
StudentData studd=new StudentData(stud);
QuestionData questionData = new QuestionData(qD);
for (i = 0; i < p.size(); i++) {
Paper pa = new Paper(questionData);
pa.setExample(p.get(i));
pD.add(pa);
}
PaperData paperData = new PaperData(pD);
for (i = 0; i < app.size(); i++) {
AnswerPaper An = new AnswerPaper(app.get(i), paperData,studd);
aP.add(An);
}
for (i = 0; i < aP.size(); i++) {
if (aP.get(i).exsit == true) {
String[] result = aP.get(i).getResult();
for (j = 0; j < aP.get(i).getModel().getQuestionList().size(); j++) {
System.out.println(result[j]);
}
System.out.println(aP.get(i).getGrade());
} else {
System.out.println("The test paper number does not exist");
}
}
}
}
class Student {
private String ID;
private String name;
public void setExample(String x) {
String a[]=x.split(" ");
this.ID=a[0];
this.name=a[1];
}
public String getID() {
return ID;
}
public String getName() {
return name;
}
}
class StudentData {
ArrayList<Student> student;
public StudentData(ArrayList<Student> student) {
this.student = student;
}
public String getName(String ID){
for (int i = 0; i < student.size(); i++) {
if(student.get(i).getID().equals(ID)){
return student.get(i).getName();
}
}
return null;
}
}
class Question {
private int num = 1;
private String include = null;
private String answer = null;
private String[] a;
private boolean exist = true;
private boolean del=false;
public Question() {
}
public Question(boolean x) {
this.exist = x;
}
public void setDel(boolean del) {
this.del = del;
}
public boolean isExist() {
return exist;
}
public boolean isDel() {
return del;
}
public void setExample(String example) {
a = example.split("#");
num = Integer.parseInt(a[1].substring(2).trim());
include = a[2].substring(2,a[2].length()-1);
answer = a[3].substring(2).trim();
}
public String getInclude() {
return include;
}
public String getAnswer() {
return answer;
}
}
class QuestionData {
HashMap<Integer, Question> questionData = new HashMap<>();
public Question getQuestion(int n) {
return questionData.get(n);
}
public QuestionData(HashMap<Integer, Question> questionData) {
this.questionData = questionData;
}
}
class PaperData {
ArrayList<Paper> paperData = new ArrayList<>();
public Paper getPaper(int n) {
for (int i = 0; i < paperData.size(); i++) {
if (paperData.get(i).getNum() == n) {
return paperData.get(i);
}
}
return null;
}
public PaperData(ArrayList<Paper> paperData) {
this.paperData = paperData;
}
}
class Paper {
private int num;
private ArrayList<Question> questionList = new ArrayList<>();
private ArrayList<Integer> grade = new ArrayList<>();
private String[] a;
private QuestionData questionData;
public int getNum() {
return num;
}
public Paper() {
}
public Paper(QuestionData questionData) {
this.questionData = questionData;
}
public ArrayList<Question> getQuestionList() {
return questionList;
}
public ArrayList<Integer> getGrade() {
return grade;
}
public String getQuestion(int i) {
return questionList.get(i).getInclude();
}
public void setExample(String example) {
a = example.split("[ |-]");
int len = a.length;
num = Integer.parseInt(a[0].substring(3).trim());
int sum = 0;
if(len!=1) {
for (int i = 1; i < len; i = i + 2) {
if(questionData.getQuestion(Integer.parseInt(a[i].trim()))!=null) {
questionList.add(questionData.getQuestion(Integer.parseInt(a[i].trim())));
}else{
questionList.add(new Question(false));
}
grade.add(Integer.parseInt(a[i + 1].trim()));
}
for (int i = 0; i < grade.size(); i++) {
sum = sum + grade.get(i);
}
}
if (sum != 100) {
System.out.println("alert: full score of test paper" + num + " is not 100 points");
}
}
public String judgeAnswer(int n, String anwser1) {
if (questionList.get(n).getAnswer().equals(anwser1)) {
return "true";
} else {
return "false";
}
}
}
class AnswerPaper {
private int num;
private String ID;
private String name;
private Paper model;
private ArrayList<Integer> numList= new ArrayList<>();
private ArrayList<String> answerList = new ArrayList<>();
private String[] result;
private int[] grade;
boolean exsit = true;
public ArrayList<String> getAnswerList() {
return answerList;
}
public AnswerPaper() {
}
public AnswerPaper(String example, PaperData paperData,StudentData studentData) {
String[] aLL = example.split("#");
int len = aLL.length;
String[] aLLL = aLL[1].split(" ");
ID = aLLL[1].trim();
name=studentData.getName(ID);
num = Integer.parseInt(aLLL[0].substring(2).trim());
model = paperData.getPaper(num);
String[] x;
if (model == null) {
exsit = false;
} else {
result = new String[model.getQuestionList().size()];
grade = new int[model.getQuestionList().size()];
for (int i = 1; i < len - 1; i++) {
x=aLL[i+1].split("-");
numList.add(Integer.parseInt(x[0].substring(2).trim()));
if(x.length==2) {
answerList.add(x[1].replaceAll("\\s+$", ""));
}else{
answerList.add("");
}
}
}
}
public Paper getModel() {
return model;
}
public String getAnswer(int i) {
return answerList.get(i);
}
public String[] getResult() {
for (int j = 0; j < model.getQuestionList().size(); j++) {
result[j] = "answer is null";
grade[j] = 0;
}
for (int i = 0; i < answerList.size(); i++) {
if(numList.get(i)>model.getQuestionList().size()){
continue;
}
if(model.getQuestionList().get((numList.get(i))-1).isExist()&&model.getQuestionList().get((numList.get(i))-1).isDel()==false) {
result[(numList.get(i)) - 1] = model.getQuestion((numList.get(i)) - 1) + "~" + answerList.get(i) + "~" + model.judgeAnswer((numList.get(i)) - 1, answerList.get(i));
if (model.judgeAnswer((numList.get(i)) - 1, answerList.get(i)).equals("true")) {
grade[(numList.get(i)) - 1] = model.getGrade().get((numList.get(i)) - 1);
}
}else if(model.getQuestionList().get((numList.get(i))-1).isExist()&&model.getQuestionList().get((numList.get(i))-1).isDel()==true){
result[(numList.get(i)) - 1]="the question "+(numList.get(i))+" invalid~0";
}else if(model.getQuestionList().get((numList.get(i))-1).isExist()==false){
result[(numList.get(i)) - 1]="non-existent question~0";
}
}
return result;
}
public String getGrade() {
int sum = 0;
StringBuilder gradere = new StringBuilder();
for (int j = 0; j < model.getQuestionList().size(); j++) {
gradere.append(grade[j] + " ");
sum = sum + grade[j];
}
if(name==null) {
return ID+" not found";
}else{
return ID + " " + name + ": " + gradere.toString().trim() + "~" + sum;
}
}
}
- 改动分析：至这题题目的难度又上涨了一个档次，加入了带有学号的学生以及可以对题目进行删除，并且输入的合法判定严格了很多，导致这题我花费的时间甚至超过了前两题的总和。这里我开始使用正则表达式然后发现是真的好用啊（真香），以往对于是否合规的捞长的代码这里一行就能搞定。这里我也兴致勃勃的加了学生类和学生库类处理学生（虽然被告知所有测试点答卷内只有一个学生o(╥﹏╥)o），同时因为元素的增多会出现好多种情况，有且不限于题目不存在，题目被删除，答卷不存在，学生不存在，学生少答，学生多答等等等等。（most复杂o(╥﹏╥)o）
- 各类处理差别不大，就不多赘述了；
- 加入学生类，存放学号学生姓名；
- 加入学生库存放所有学生；
- 题目加入delete和exit状态，分别表示是否被删除和是否存在；
- 答卷判断时先根据样卷的题目数创建结果数组，并且先全部放“anwser is null”（最高级），后根据答卷给的题号索引题目判断，后面在根据题目的状态判断覆盖不存在还是非法或者合法打分返回结果；
- 心得：这题考察了思维的严谨性，题目的空格也是题目的一部分，答案要按照写的一一对应等；还有灵活的思维，题目的删除如果直接去删除必定十分复杂，而直接去改变其的状态则会简单很多；当然，这里最主要的收货便是对正则表达式的使用更加的熟练灵活了；
- 踩坑：这里踩的坑可就太多了
- 首先便是忘记考虑答卷题目数大于试卷题目数的情况，导致索引大于题目数时超出结果数组上限导致代码崩溃；
- 而后便是空格问题（没错又是空格问题）包括且不限于题目内容空格不能删，题目答案首尾空格得删除，答卷答案首尾空格得删除等等，还有题目的答案居然能为空（根本想不到好吧！谁家标准答案会是一片空白啊）；
- 还有删除题目问题，因为未来确保乱序输入导致的问题，我都是在输入完之后进行统一处理的，但是我删除题目放在存放问题之后，所以如果出现先存再删再存的情况就会出问题，随后进行了修改（但是没有，好像没有这个测试点o(╥﹏╥)o）
但是这个题目最后还是有两个测试点过不了，试了各种输入都明明输出咩问题（悲）
三.改进
对于自我代码的改进我想进行总述
- 首先便是类的单一职责和MVC，在和同学交谈前，我认为答卷的评判结果由答卷输出是合理的，毕竟那些都是答卷有关的，但交谈后发现我的想法有点简单，答卷不就应该交给老师来批改，老师来打分吗
，但这也延伸出了一些问题，包括试卷的题目索引我是否还需要创建一个出卷人的类呢，这还需要我的进一步思考； - 还有就是思维的严谨性，有时候敲代码时会忘记一个个小点，导致我后面发现需要修改的时候就会比较麻烦，还要一个个的去查漏补缺。
- 类的设计不可缺，听到有人主函数有两百多行我都很难想到时候代码的维护和修改会有多麻烦，只有正确类的创建才能在加功能的时候游刃有余；
四.总结
- 三次大作业使我收获颇多，学到最大的便是代码的严谨性，类与类之间的设计；合理类的设计与一个严谨的思维在日后的代码编程中是不可或缺的（当然还有代码的基本编程素质），同时要合理的运用java为我们提供的各类函数，能使我们的代码更加的严谨简介明了，合理的询问API文档等。同样的，正则表达式也是重中之重，是必须掌握精进的。还有代码编程时最好的办法就是可以写写画画，把大问题先分割成为小问题，并给每个小问题标上其中的要点，之后的代码编程时一个小问题一个小问题的进行突破，最后你会发现大问题也被突破了，这样比看了题目就去写思路会清晰很多，编程肯定也会更快滴！(▽)
- 还有就是以后题目测试点能不能人性化一点（小声bb）（谁想的到题目的标准答案可以没有啊，连个掠都没有o(╥﹏╥)o）还有希望在题目结束后能给一些差一点拿满分的同学给点测试点提示（小声bb）能让他们知道自己错哪了不是更能提升他们吗
