前言：
题目集 1~3 的知识点、题量、难度等情况如下：
-
知识点：JAVA基础，基础算法，面向对象程序设计
-
题量：共计 3 道题目
-
难度：题目从易到难，逐层递进，分别为考察Java容器的理解、掌握与运用。
设计与分析：
1 import java.util.*;
2 import java.util.regex.Pattern;
3 import java.text.Collator;
4 import java.util.Locale;
5
6 public class Main {
7 public static void main(String[] args) {
8 Scanner in = new Scanner(System.in);
9 String get=in.nextLine() ;
10 int i=0;
11 Student[] students=new Student[20] ;
12 for (int j = 0; j < students.length; j++) {
13 students[j]=new Student();
14 }
15 int j=0;
16 Lesson[] lessons=new Lesson[20];
17 for (int i1 = 0; i1 < lessons.length; i1++) {
18 lessons[i1]=new Lesson();
19 }
20
21 for(;!get.equals("end");){
22 StringTokenizer st = new StringTokenizer(get," ");
23 String first= st.nextToken();
24 boolean congfu=false;
25 int time=0;
26 if(isNumber(first)){
27 if(first.length()!=8){
28 System.out.println("wrong format");
29 }
30 for (int k = 0; k <i; k++) {
31 if(students[k].getID().equals(first)) {
32 time=k;
33 congfu = true;
34 break;
35 }
36 }
37 if(congfu){
38 String two=st.nextToken();
39 Lesson temp = new Lesson();
40 temp.setName(st.nextToken());
41 if (st.countTokens() == 1) {
42 String end=st.nextToken();
43 if(Integer.parseInt(end)>-1&&Integer.parseInt(end)<101) {
44 temp.setEnd(Integer.parseInt(end));
45 students[time].setLessons(temp);
46 }
47 }
48 if (st.countTokens() == 2) {
49 String normal =st.nextToken();
50 String end=st.nextToken();
51 if(Integer.parseInt(end)>-1&&Integer.parseInt(end)<101&&Integer.parseInt(normal)>-1&&Integer.parseInt(normal)<101) {
52 temp.setNormal(Integer.parseInt(normal));
53 temp.setEnd(Integer.parseInt(end));
54 students[time].setLessons(temp);
55 }
56 }
57 }
58 else {
59 String two=st.nextToken();
60 Lesson temp = new Lesson();
61 temp.setName(st.nextToken());
62 if (st.countTokens() == 1) {
63 String end=st.nextToken();
64 if(Integer.parseInt(end)>-1&&Integer.parseInt(end)<101) {
65 temp.setEnd(Integer.parseInt(end));
66 students[i].setID(first);
67 students[i].setName(two);
68 students[i].setLessons(temp);
69 i++;
70 }
71 else
72 System.out.println("wrong format");
73 }
74 if (st.countTokens() == 2) {
75 String normal =st.nextToken();
76 String end=st.nextToken();
77 if(Integer.parseInt(end)>-1&&Integer.parseInt(end)<101&&Integer.parseInt(normal)>-1&&Integer.parseInt(normal)<101) {
78 temp.setNormal(Integer.parseInt(normal));
79 temp.setEnd(Integer.parseInt(end));
80 students[i].setID(first);
81 students[i].setName(two);
82 students[i].setLessons(temp);
83 i++;
84 }
85 else
86 System.out.println("wrong format");
87 }
88 }
89 }
90 else if(first.matches("[\\S]{1,10}")){
91 String nature=st.nextToken();
92 String method="";
93 if(st.countTokens()==1)
94 method=st.nextToken();
95 else if(st.countTokens()==0)
96 method="考试";
97 if(nature.equals("必修")){
98 if(method.equals("考试")){
99 lessons[j].setName(first);
100 lessons[j].setNature(nature);
101 lessons[j].setMethod(method);
102 j++;
103 }
104 else{
105 System.out.println(first+ " : course type & access mode mismatch");
106 System.out.println(first+" does not exist");
107 }
108 }
109 if(nature.equals("选修")){
110 if(method.equals("")){
111 System.out.println("wrong format");
112 break;
113 }
114 else {
115 lessons[j].setName(first);
116 lessons[j].setNature(nature);
117 lessons[j].setMethod(method);
118 j++;
119 }
120 }
121 }
122 get=in.nextLine() ;
123 }
124
125
126 List<String> list1 = new ArrayList<>();
127 for (int i1 = 0; !students[i1].getID().equals(""); i1++) {
128 list1.add(students[i1].getID());
129 }
130 Collections.sort(list1, new Comparator<String>() {
131 @Override
132 public int compare(String s1, String s2) {
133 return s1.compareTo(s2);
134 }
135 });
136 for (String str : list1) {
137 for (int i1 = 0;!students[i1].getID().equals("") ; i1++) {
138 if(students[i1].getID().equals(str)){
139 students[i1].indGrades(lessons);
140 }
141 }
142 }
143
144 Arrays.sort(lessons,0,j);
145 for (int i1 = 0; i1<j; i1++) {
146 double normal=0;
147 double fina=0;
148 int count=0;
149 if(lessons[i1].getMethod().equals("考试")) {
150 for (int k = 0; k < i; k++) {
151 for (int l = 0; !students[k].getLessons()[l].getName().equals(""); l++) {
152 if (lessons[i1].getName().equals(students[k].getLessons()[l].getName())) {
153 if(students[k].getLessons()[l].getNormal() != -1) {
154 normal += students[k].getLessons()[l].getNormal();
155 fina += students[k].getLessons()[l].getEnd();
156 count++;
157 }
158 }
159 }
160 }
161 if(count!=0)
162 System.out.println(lessons[i1].getName()+ " "+(int)Math.floor(normal/count)+" "
163 +(int)Math.floor(fina/count)+" "+(int) Math.floor(normal/count*0.3+fina/count*0.7) );
164 }
165 if(lessons[i1].getMethod().equals("考察")){
166 for (int k = 0; k < i; k++) {
167 for (int l = 0; !students[k].getLessons()[l].getName().equals(""); l++) {
168 if (lessons[i1].getName().equals(students[k].getLessons()[l].getName())) {
169 if (students[k].getLessons()[l].getEnd() != -1) {
170 fina += students[k].getLessons()[l].getEnd();
171 count++;
172 }
173 }
174 }
175 }
176 if(count!=0)
177 System.out.println(lessons[i1].getName()+ " "+(int)Math.floor(fina/count)+" "+(int)Math.floor(fina/count));
178 }
179 if(count==0)
180 System.out.println(lessons[i1].getName()+" has no grades yet");
181 }
182
183 List <String> list2=new ArrayList<>();
184 for (int k = 0; k < i; k++) {
185 boolean setTo=true;
186 String temp =students[k].getID().substring(0,6);
187 for (String str : list2) {
188 if(str.equals(temp)){
189 setTo=false;
190 break;
191 }
192 }
193 if(setTo){
194 list2.add(temp);
195 }
196 }
197 Collections.sort(list2, new Comparator<String>() {
198 @Override
199 public int compare(String s1, String s2) {
200 return s1.compareTo(s2);
201 }
202 });
203 for (String str : list2) {
204 int count=0;
205 double sum=0;
206 for (int k = 0; k < i; k++) {
207 if(str.equals(students[k].getID().substring(0,6))){
208 if(students[k].getLast()!=-1) {
209 sum += students[k].getLast();
210 count++;
211 }
212 }
213 }
214 if(count==0){
215 System.out.println(str+" has no grades yet");
216 }
217 if(count!=0){
218 System.out.println(str+" "+(int)Math.floor(sum/count) );
219 }
220 }
221 }
222 public static boolean isNumber(String str) {
223 if (str == null || str.trim().length() == 0) {
224 return false;
225 }
226 Pattern pattern = Pattern.compile("^\\d+$");
227 return pattern.matcher(str).matches();
228 }
229 }
230
231 class Student {
232 private String ID="";
233 private String name;
234 private Lesson[] lessons;
235
236 private int last=-1;
237
238 public Student( ) {
239 lessons =new Lesson[20];
240 for (int i = 0; i < lessons.length; i++) {
241 lessons[i]=new Lesson();
242 }
243 }
244 public Student(String ID, String name, Lesson[] lessons) {
245 this.ID = ID;
246 this.name = name;
247 this.lessons = lessons;
248 }
249 public Student(String ID, String name, Lesson[] lessons, int last) {
250 this.ID = ID;
251 this.name = name;
252 this.lessons = lessons;
253 this.last = last;
254 }
255 public String getID() {
256 return ID;
257 }
258
259 public void setID(String ID) {
260 this.ID = ID;
261 }
262 public String getName() {
263 return name;
264 }
265 public void setName(String name) {
266 if(name.length()<10)
267 this.name = name;
268 else
269 System.out.println("wrong format");
270 }
271 public Lesson[] getLessons() {
272 return lessons;
273 }
274 public void setLessons(Lesson lesson) {
275 for (int i = 0; i < lessons.length; i++) {
276 if(lessons[i].getName().equals("")){
277 lessons[i]=lesson;
278 break;
279 }
280 }
281 }
282 public int getLast() {
283 return last;
284 }
285 public void setLast(int last) {
286 this.last = last;
287 }
288 public void indGrades(Lesson[] lessons2){
289 double sum=0;
290 boolean judge=false;
291 int count=0;
292 for (int i = 0;!lessons[i].getName().equals(""); i++) {
293 for (int i1 = 0;!lessons2[i1].getName().equals(""); i1++) {
294 if(lessons[i].getName().equals(lessons2[i1].getName())){
295 if(lessons[i].getNormal()!=-1&&lessons2[i1].getMethod().equals("考察")){
296 System.out.println(ID+" "+name+" "+": access mode mismatch");
297 }
298 if (lessons[i].getNormal()==-1&&lessons2[i1].getMethod().equals("考试")) {
299 System.out.println(ID+" "+name+" "+": access mode mismatch");
300 }
301 if (lessons[i].getNormal()==-1&&lessons[i].getEnd()!=-1&& lessons2[i1].getMethod().equals("考察")) {
302 sum+=lessons[i].getEnd();
303 count++;
304 }
305 if (lessons[i].getNormal()==-1&&lessons[i].getEnd()==-1&& lessons2[i1].getMethod().equals("考察")){
306 count=-1;
307 }
308 if(lessons[i].getNormal()!=-1&&lessons2[i1].getMethod().equals("考试")){
309 sum+=lessons[i].getNormal()*0.3+lessons[i].getEnd()*0.7;
310 count++;
311 }
312 break;
313 }
314 if(lessons2[i1+1].getName().equals(""))
315 judge=true;
316 }
317 if(judge)
318 System.out.println(ID + " " + name + " :" + lessons[i].getName() + " does not exist");
319 judge=false;
320 }
321 if (count==0){
322 System.out.println(ID + " " + name +" did not take any exams");
323 }
324 else if(count>0){
325 this.last=(int)Math.floor(sum/count);
326 System.out.println(ID + " " + name +" "+(int)Math.floor(sum/count));
327 }
328 }
329 }
330 class Lesson implements Comparable<Lesson> {
331 private String name="";
332 private String nature="";//课程性质
333 private String method="";//考察方式
334 private int normal=-1;
335 private int end=-1;
336
337 public Lesson() {
338 }
339 public Lesson(String name, String nature, String method, int normal, int end) {
340 this.name = name;
341 this.nature = nature;
342 this.method = method;
343 this.normal = normal;
344 this.end = end;
345 }
346
347 public String getName() {
348 return name;
349 }
350
351 public void setName(String name) {
352 if(name.length()<10)
353 this.name = name;
354 }
355
356 public String getNature() {
357 return nature;
358 }
359
360 public void setNature(String nature) {
361 this.nature = nature;
362 }
363
364 public String getMethod() {
365 return method;
366 }
367
368 public void setMethod(String method) {
369 this.method = method;
370 }
371
372 public int getNormal() {
373 return normal;
374 }
375 public void setNormal(int normal) {
376 if(normal>=0&&normal<101)
377 this.normal = normal;
378 else
379 System.out.println("wrong format");
380 }
381
382 public int getEnd() {
383 return end;
384 }
385
386 public void setEnd(int end) {
387 if(end>=0&&end<101)
388 this.end = end;
389 else
390 System.out.println("wrong format");
391 }
392 @Override
393 public int compareTo(Lesson o) {
394 Collator cmp = Collator.getInstance(Locale.CHINA);
395 return cmp.compare(this.name, o.getName());
396 }
397 }
View Code
该部分为PTA6-1的代码显示，主要通过Arraylist容器对所需数据进行存储。随后对目标进行整理与 计算。 （注意：其中对Arraylist容器进行处理时要熟悉Arraylist类的相关方法，以便我们进行操作）
1 import java.util.ArrayList;
2 import java.util.List;
3 import java.util.Scanner;
4 import java.util.StringTokenizer;
5
6 public class Main {
7 public static void main(String[] args) {
8 Scanner in = new Scanner(System.in);
9 List<Student> list1 = new ArrayList<>();
10 String get = in.nextLine();
11 int time = 0;
12 while (!get.equals("end")) {
13 Student temp=new Student();
14 StringTokenizer st = new StringTokenizer(get, " ");
15 String first = st.nextToken();
16 String twice = st.nextToken();
17 int three = Integer.parseInt(st.nextToken());
18 temp.setID(first);
19 temp.setName(twice);
20 temp.setGrade(three);
21 list1.add(temp);
22 get=in.nextLine();
23 }
24 get = in.nextLine();
25 for (Student stu : list1) {
26 if (stu.getID().equals(get)) {
27 System.out.println(stu.getID() + " " + stu.getName() + " " + stu.getGrade());
28 time=1;
29 break;
30 }
31 }
32 if (time == 0)
33 System.out.println("The student "+get + " does not exist");
34 }
35 }
36 class Student{
37 String ID;
38 String name;
39 int grade;
40
41 public Student() {
42 }
43
44 public Student(String ID, String name, int grade) {
45 this.ID = ID;
46 this.name = name;
47 this.grade = grade;
48 }
49
50
51 public String getID() {
52 return ID;
53 }
54
55 public void setID(String ID) {
56 this.ID = ID;
57 }
58
59 public String getName() {
60 return name;
61 }
62
63 public void setName(String name) {
64 this.name = name;
65 }
66
67 public int getGrade() {
68 return grade;
69 }
70 public void setGrade(int grade) {
71 this.grade = grade;
72 }
73 }
第7次PTA主要考察的是HasMap容器的运用与处理。与之前不同的是需要注意HasMap的特定方法与之不同在实现过程中，需要区分菜单信息和订单信息格式上的不同，以免发生方法调用上的错误。在7-1的基础上，需要在设计方法来输入获取菜价信息和选取份额，因此可以构造一个新的类来实现这些方法。
class Lesson {
String name;
String nature;
String method;
int time;
ArrayList<Integer>grade ;
ArrayList<Double>value;
public Lesson() {
grade=new ArrayList<>();
value=new ArrayList<>();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getNature() {
return nature;
}
public void setNature(String nature) {
this.nature = nature;
}
public String getMethod() {
return method;
}
public void setMethod(String method) {
this.method = method;
}
public ArrayList<Integer> getGrade() {
return grade;
}
public void setGrade(int grade) {
this.grade.add(grade);
}
public int getTime() {
return time;
}
public void setTime(int time) {
this.time = time;
}
public ArrayList<Double> getValue() {
return value;
}
public void setValue(ArrayList<Double> value) {
this.value = value;
}
}
第8次PTA再次考察学生对容器的掌握与运用，总的来说只需对原有的类进行成员变动就能
其实无压力的应对了。
采坑心得:
作为新手，在编写代码的过程中终会遇到许许多多的问题，而我们能做的就是做好总结并且理解并改正。
对格式错误的数据的处理问题：在读入并判断输入数据格式时，要注意对错误格式的信息进行忽略并报错，否则会导致程序崩溃。
数组下标越界问题：在删除订单信息时，要注意数组下标是否越界，否则会导致程序崩溃。
对不同格式信息的区分问题：在读入数据后，格式的判断一定要严谨，否则会导致数据的丢失。
类的结构过于混乱：在编写程序时一定要注意程序的结构是否可拓展和可读，避免后期维护产生问题。
在解题过程中，我遇到了以下主要困难:
对时间类的使用不够熟练：在解决储存每桌对应的时间时，我发现测试样例中时间的格式不统一，时而是单数时而是双数，
导致使用的时候出现报错。
-
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH/mm/ss"); Date date = new Date(); date= sdf.parse(time); -
- 算法的实现不够高效：对于多桌菜的情况，处理大量数据时因为循环结构过多导致耗时很长，无法达到预期结果。
- 编码能力有待提高：在解题过程中，我发现自己编码能力还有待提高，主要体现在代码的可读性和可维护性上，难以在原有的结构基础上拓展新的功能。因此，需要加强对编码技巧的掌握，提高代码的可读性和可维护性。
改进建议:
- 其实对于时间类需要充足的时间理解和练习，在寻找上述中提到的时间格式问题的解决方法时，我在网络上领教到了一种较为方便的解决方法：
-
可以将data类转化为Instant类，再由时区转换为LocalDateTime类，这样就可以避免因为输入格式的不统一造成的错误了。仍未解决的问题：
1 Date date = new Date(); 2 date= sdf.parse(time); 3 Instant instant = date.toInstant(); 4 ZoneId zone = ZoneId.systemDefault(); 5 tables[table_count].time= LocalDateTime.ofInstant(instant, zone);
- 对于提高代码可拓展性上，我将原本的很多功能重构成了方法，也增加了类的使用频率，让代码整体的结构更加紧密和可拓展。
- 对于格式的判断，我率先想到的就是判断数据的某个元素是否可以转化为数字，以将不同的数据分割开处理，因此，我构造了isNumeric方法来判断是否可以转化成数字。
public static boolean isNumeric (String string) { int intValue; try { intValue = Integer.parseInt (string); return true; } catch (NumberFormatException e) { return false; } }
-
但是，这个方法并不是很好，一方面每个数据都要判断一遍导致运行速度大大降低，另一方面可扩展性不高，后期添加新的功能时需要大量改动原有代码。
- 针对删除订单信息的方法中出现的数组越界问题，我引用了新的计数变量count，来记录数组的长度，从而防止数组下标越界的问题
- 其实可以直接调用数组的lenth方法。
-
boolean delARecordByOrderNum(int orderNum,int count){ int i=0,j=0,flag=0; for(i=0;i<count;i++){ if(records[i].orderNum==orderNum){ for(j=i;j<count-1;j++){ records[j]=records[j+1]; } flag++; } } if(flag==0){System.out.println("delete error;");return false;} return true; }
-
仍未解决的问题：
- 即使优化了代码的结构，代码的运行效率依旧达不到预期的水准，个人猜测是由于判断输入数据格式的方法太过笨拙。
- 使用不可拓展容器来储存变量，有超出容器容量的风险，应当换用ArrayList等容器。这样不仅解决了容器大小的问题，又可以让数据的增删改查更加方便。
- 由于胡乱的增加类，导致类与类的关系变得混乱，应当将Table类与Order类结合起来，可以增加代码的可读性。
总结:
个人感觉本次的题目集对与刚上手的学生来说还有很大难度，此次对于刚开始接触Java的同学来说还是有很大难度的，需要兼顾语法的同时对题目的算法有不错的理解。不然很容易出现欠缺考虑的情况。但通过这次的题目也可以很好人让我们深入了解面向对象设计语言该如何编写，让我们更快的了解Java运行方式。。总体而言，这套菜单系统让我学到了很多新知识，并且使我对代码结构的理解更加深刻，意识到了代码可拓展性的重要。
-
-