BLOG-3

标签：return String get int ins BLOG public

前言

之前发布的6-8次PTA题目集依旧保持了之前一贯的特点：题目数量少，每道题目的难度相对大，题目的分数也非常的集中（基本集中在课程成绩统计程序系列的三道题目上）。其中，第六次PTA作业只有课程成绩统计程序-1这一道题目，100分完全由这一道题目囊括；第七次PTA作业共四道题目，课程成绩统计程序-2占了其中60分，其它三道题目共占40分；第八次PTA作业与第七次PTA作业相似，课程成绩统计程序-3这一道题目占64分，另外四道题目占了36分。与此同时，题目的难度也比较集中，都分布在课程成绩统计程序系列的三道题目上，与其所占有的分数相对应。而这三道题目我除了第一道以外基本没怎么写出来。这三、次PTA题目集所涉及的知识点主要是：ArrayList、接口、类与对象等等。主要是这个学期学的有关面向对象程序设计以及Java语言程序设计基础的内容。这几次题目集对我来说是比较大的挑战，毕竟我的水平在班级中比较的靠后。这也在我的分数上体现了出来：几次题目集我的得分都比较的低，排名也靠后。

设计与分析

（1）课程成绩统计程序-1

这道题目是我在课程成绩统计程序系列的三道题目中唯一得分的一道，后面两道题目我都没有得分。但是即使是这道题目我也是在同学的帮助之下完成的，凭我自己的能力属实无法写出这道题目。

这道题目要求对输入的学生课程和成绩信息进行分析，并输出相应的平均分和统计结果。以下是对题目的分析和解答步骤：

1. 首先，我们需要解析输入的课程和成绩信息。按照题目给出的格式，可以通过逐行读取输入并按照空格分割的方式解析出不同字段的值。
2. 对于每个成绩信息，需要进行一系列的判断和处理。包括：
3. 在解析成绩信息的过程中，需要维护多个数据结构来保存需要的数据，如学生的成绩和总成绩、每门课程的成绩和总成绩以及每个班级的总成绩。
4. 解析完成后，根据输出要求对结果进行计算和排序。包括：
5. 根据不同的情况输出结果，包括正常结果和异常情况下的错误信息。

• 检查课程名称是否在已输入的课程列表中，如果不在则输出错误信息。
• 检查成绩数量和课程的考核方式是否匹配，如果不匹配则输出错误信息。
• 检查成绩是否超出范围，如果超出则输出错误信息。
• 根据课程的性质和考核方式，计算学生的总成绩。

• 计算学生所有课程总成绩的平均分，并按学号由低到高排序输出。
• 计算每门课程的平均分，按课程名称的字符顺序输出。
• 计算班级所有课程总成绩的平均分，并按班级由低到高排序输出。

以下是我的源码：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

 

public class Main {
static ArrayList<Class> Classes=new ArrayList<>();
static ArrayList<Lesson> lessons=new ArrayList<>();
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
String[] ins;
while(true){
ins=input.nextLine().split(" ");
if(ins[0].equals("end")){
break;
}
try{
int temp=Integer.parseInt(ins[0]);
}catch (Exception e){ //课程信息: java 必修 考试
if(CheckLessonFormat(ins)){ //检查输入格式
System.out.println("wrong format");
continue;
}
if(ins[1].equals("必修")){
if(ins[2].equals("考察")){
System.out.println(ins[0]+" : course type & access mode mismatch");
continue;
}
else if(FindLesson(ins[0])!=-1){ //处理重复课程输入
continue;
}
else {
lessons.add(new Lesson(ins[0],1,1));
}
}
else {
if(FindLesson(ins[0])!=-1){ //处理重复课程输入
continue;
}
if(ins[2].equals("考试")){
lessons.add(new Lesson(ins[0], 2, 1));
}
else{
lessons.add(new Lesson(ins[0], 2, 2));
}
}
continue;
} //学生信息: 20201103 张三 java 20 40 / 20201103 张三 java 20
if(CheckStuFormat(ins)){
System.out.println("wrong format");
continue;
}
if(ins[3].length()>2){
System.out.println("wrong format");
continue;
}
String ClassID=ins[0].substring(0,6);
int ClassNum=GetClass(ClassID);
int flag=0;
for(int t=0;t<Classes.size();t++){
if(Classes.get(t).FindStudent(ins[0])!=null){
flag=1;
}
}
if(flag==0){
Classes.get(ClassNum).AddStudent(ins[0], ins[1]);
}
if(FindLesson(ins[2])==-1){
System.out.println(ins[2]+" does not exist");
continue;
}
Lesson temp=lessons.get(FindLesson(ins[2]));
if((temp.Test==2&&ins.length==5)||(temp.Test==1&&ins.length==4)){
System.out.printf("%s %s : access mode mismatch\n",ins[0],ins[1]);
continue;
}
try{
if (temp.Test == 1) { //判断课程考查形式 1：考试 2：考察
Classes.get(ClassNum).students.get(Classes.get(ClassNum).students.size() - 1).AddLesson(temp, Integer.parseInt(ins[3]), Integer.parseInt(ins[4]));
} else
Classes.get(ClassNum).students.get(Classes.get(ClassNum).students.size() - 1).AddLesson(temp, Integer.parseInt(ins[3]));
}catch (Exception e){
System.out.printf("%s %s : access mode mismatch\n",ins[0],ins[1]);
}
}
FinalPrint();
}
static int GetClass(String ID){ //班级存在就返回班级序号，不存在则新建班级并返回序号
for(int t=0;t<Classes.size();t++){
if(Classes.get(t).getClassID().equals(ID)){
return t;
}
}
Classes.add(new Class(ID));
return Classes.size()-1;
}
static void FinalPrint(){
int SumStudent=0;
for(int t=0;t<Classes.size();t++)
SumStudent+=Classes.get(t).students.size(); //算出学生总数
if(SumStudent!=0)
{
ArrayList<Student> studentss = new ArrayList<>();
for (int t = 0; t < Classes.size(); t++) {
for (int t1 = 0; t1 < Classes.get(t).students.size(); t1++) {
studentss.add(Classes.get(t).students.get(t1));
}
}
Student[] student=new Student[studentss.size()];
for(int t=0;t<studentss.size();t++){
student[t]=studentss.get(t);
}
if(SumStudent>1){
Arrays.sort(student, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getID().compareTo(o2.getID());
}
});
}
for (int t = 0; t < SumStudent; t++) {
if (student[t].FinalScore.size() == 0) {
System.out.printf("%s %s did not take any exams\n", student[t].getID(), student[t].getName());
} else
System.out.printf("%s %s %d\n", student[t].getID(), student[t].getName(), GetAverage(student[t].FinalScore));
}
}
//以上为学生个人成绩
//
//
//以下输出课程总成绩
Lesson[] lesson=new Lesson[lessons.size()];
for(int t=0;t<lessons.size();t++){
lesson[t]=lessons.get(t);
}
Arrays.sort(lesson, new Comparator<Lesson>() {
// 创建 Collator 对象，指定升序排序规则为中文
public int compare(Lesson o1, Lesson o2) {
return o1.Name.compareTo(o2.Name);
}
});
if(lesson.length!=0)
for(int t=0;t<lesson.length;t++){
if(lesson[t].FinalScores.size()==0){
System.out.println(lesson[t].Name+" has no grades yet");
}
else if(lesson[t].Test==1){
System.out.printf("%s %d %d %d\n",lesson[t].Name,Main.GetAverage(lesson[t].DurScores),Main.GetAverage(lesson[t].TestScores),Main.GetAverage(lessons.get(t).FinalScores));
}
else{
System.out.printf("%s %d %d\n",lesson[t].Name,Main.GetAverage(lesson[t].TestScores),Main.GetAverage(lesson[t].FinalScores));
}
}
//
//以下为班级输出
Class[] classes=new Class[Classes.size()];
for(int t=0;t<Classes.size();t++){
classes[t]=Classes.get(t);
}
Arrays.sort(classes, new Comparator<Class>() {
@Override
public int compare(Class o1, Class o2) {
return o1.getClassID().compareTo(o2.getClassID());
}
});
for(int t=0;t<Classes.size();t++){
if(classes[t].GetAverageScore()==0){
System.out.println(classes[t].getClassID()+" has no grades yet");
continue;
}
System.out.println(classes[t].getClassID()+" "+classes[t].GetAverageScore());
}
}
static int GetAverage(ArrayList<Integer> input){
double Ave=0;
int n=0;
for(int t=0;t<input.size();t++){
if(input.get(t)==0)
break;
Ave+=input.get(t);
n++;
}
Ave/=n;
return (int)Ave;
}
static int GetAverage(int[] input){
double Ave=0;
int n=0;
for(int t=0;t<input.length;t++){
if(input[t]==0)
break;
Ave+=input[t];
n++;
}
Ave/=n;
return (int)Ave;
}
static boolean CheckStuFormat(String ins[]){ //检查学生信息格式
return ins[0].length()!=8||ins[1].length()>10||ins.length>5||ins.length<4;
}
static boolean CheckLessonFormat(String ins[]){ //检查课程信息格式
return ins[0].length()>10||ins.length!=3;
}
static int FindLesson(String Name){
for(int t=0;t< lessons.size();t++){
if(lessons.get(t)==null||lessons.get(t).Name.equals(Name)){
return t;
}
}
return -1;
}
}

class Class{
private String ClassID;

public String getClassID() {
return ClassID;
}

public void setClassID(String classID) {
ClassID = classID;
}

ArrayList<Student> students=new ArrayList<>();
Class(String ID){
this.ClassID=ID;
}
void AddStudent(String ID,String Name){
students.add(new Student(Name,ID));
}

Student FindStudent(String ID){
for(int t=0;t<students.size();t++){
if(students.get(t).getID().equals(ID)){
return students.get(t);
}
}
return null;
}

int GetAverageScore(){
int Ave=0;
int flag=0;
for(int t=0;t<students.size();t++){
Ave+=Main.GetAverage(students.get(t).FinalScore);
}
return (int)(Ave/students.size());
}
}

class Student{
private String Name;
private String ID;

public String getName() {
return Name;
}

public void setName(String name) {
Name = name;
}

public String getID() {
return ID;
}

public void setID(String ID) {
this.ID = ID;
}

ArrayList<Integer> FinalScore=new ArrayList<>();
ArrayList<Lesson> lessons=new ArrayList<>();
void AddLesson(Lesson lesson,int DurGrade,int TestGrade){
this.lessons.add(lesson);
this.lessons.get(lessons.size()-1).setDurGrade(DurGrade);
this.lessons.get(lessons.size()-1).setTestGrade(TestGrade);
this.lessons.get(lessons.size()-1).setFinalGrade((int)(DurGrade*0.3+TestGrade*0.7));
FinalScore.add(this.lessons.get(lessons.size()-1).getFinalGrade());
Main.lessons.get(Main.FindLesson(lesson.Name)).AddScore(DurGrade,TestGrade); //将分数加入Lesson中
}
void AddLesson(Lesson lesson,int TestGrade){
this.lessons.add(lesson);
this.lessons.get(lessons.size()-1).setTestGrade(TestGrade);
this.lessons.get(lessons.size()-1).setFinalGrade(TestGrade);
Main.lessons.get(Main.FindLesson(lesson.Name)).AddScore(TestGrade); //将分数加入Lesson中
FinalScore.add(this.lessons.get(lessons.size()-1).getFinalGrade());
}
Student(String Name,String ID){
this.ID=ID;
this.Name=Name;
}

int compareTo(Student O2){
return Integer.parseInt(this.ID)-Integer.parseInt(this.ID);
}
}

class Lesson{
private int TestGrade;

public int getTestGrade() {
return TestGrade;
}

public void setTestGrade(int testGrade) {
TestGrade = testGrade;
}

private int DurGrade;

public int getDurGrade() {
return DurGrade;
}

public void setDurGrade(int durGrade) {
DurGrade = durGrade;
}

ArrayList<Integer> TestScores=new ArrayList<Integer>();
ArrayList<Integer> DurScores=new ArrayList<Integer>();
private int FinalGrade;

public int getFinalGrade() {
return FinalGrade;
}

public void setFinalGrade(int finalGrade) {
FinalGrade = finalGrade;
}

ArrayList<Integer> FinalScores=new ArrayList<Integer>();
String Name;
int Required=0; //1：必修 2：选修
int Test=0; //1；考试 2：考察
Lesson(String Name,int Required,int Test){
this.Name=Name;
this.Required=Required;
this.Test=Test;
}

void AddScore(int DurScore,int TestScore){
this.TestScores.add(TestScore);
this.DurScores.add(DurScore);
this.FinalScores.add((int)(0.3*DurScore+0.7*TestScore));
}
void AddScore(int TestScore){
this.TestScores.add(TestScore);
this.FinalScores.add(TestScore);
}
int[] GetAveScores(){ //平时成绩 期末成绩 总成绩
int[] Output;
if(Test==1){
Output=new int[3];
Output[1]=Main.GetAverage(TestScores);
Output[2]=Main.GetAverage(FinalScores);
int Sum=0;
int n=0;
for(int t=0;t<FinalScores.size();t++){
if(DurScores.get(t)!=0) {
Sum += DurScores.get(t);
n++;
}
}
Output[0]=(int)(Sum/n);
}
else {
Output=new int[2];
Output[0]=Main.GetAverage(TestScores);
Output[1]=Main.GetAverage(FinalScores);
}
return Output;
}
}

（2）容器-HashMap-检索

这道题要求实现一个学生信息管理系统，通过输入多个学生的成绩信息，包括学号、姓名和成绩，使用HashMap存储学生信息，并能根据学号进行查询。

首先，我们可以使用一个HashMap来存储学生信息，其中键为学号，值为一个包含姓名和成绩的字符串。由于学号是唯一的，所以HashMap的键是唯一的。

接下来，我们可以使用一个循环来读取输入的学生信息，直到输入的学号为"end"为止。在每次循环中，我们可以使用split方法将输入的字符串分割成学号、姓名和成绩，并将其存储在HashMap中。

在读取完所有学生信息后，我们可以使用一个循环来接收查询学号的输入，并在HashMap中查找对应的学生信息。如果找到了学生信息，则输出该学生的学号、姓名和成绩；如果没有找到，则输出相应的提示信息。

以下是我的源码：

import java.util.*;

public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
Map<String, String[]> map = new HashMap<>();
while (in.hasNextLine()) {
String[] tmp = in.nextLine().split(" ");
if (tmp[0].equals("end")) {
break;
} else {
map.put(tmp[0], new String[]{tmp[1], tmp[2]});
}
}
String key = in.nextLine();
if (map.containsKey(key)) {
String[] val = map.get(key);
System.out.println(key + " " + val[0] + " " + val[1]);
} else {
System.out.println("The student " + key + " does not exist");
}
}
}

（3）容器-HashMap-排序

这道题目要求输入多个学生的成绩信息，包括学号、姓名和成绩，并使用HashMap存储学生信息。最后按学号从大到小的顺序输出所有学生的信息。

首先，我们可以使用一个HashMap来存储学生信息，其中键为学号，值为一个包含姓名和成绩的字符串。由于学号是唯一的，所以HashMap的键是唯一的。

接下来，我们可以使用一个循环来读取输入的学生信息，直到输入的学号为"end"为止。在每次循环中，我们可以使用split方法将输入的字符串分割成学号、姓名和成绩，并将其存储在HashMap中。

在读取完所有学生信息后，我们可以使用一个ArrayList来存储所有的学生信息，并使用Collections.sort方法按学号从大到小的顺序对学生信息进行排序。

最后，我们可以使用一个循环来遍历排序后的学生信息列表，并输出每个学生的学号、姓名和成绩。

下面是我的源码：

import java.util.*;

public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
Map<Integer, String[]> map = new HashMap<>();
while (in.hasNextLine()) {
String[] tmp = in.nextLine().split(" ");
if (tmp[0].equals("end")) {
break;
} else {
map.put(Integer.parseInt(tmp[0]), new String[]{tmp[1], tmp[2]});
}
}
// TreeMap默认按key从小到大排序
Map<Integer, String[]> sortedMap = new TreeMap<>(Collections.reverseOrder());
sortedMap.putAll(map); // 复制一份，按key从大到小排序
for (Map.Entry<Integer, String[]> entry : sortedMap.entrySet()) {
int key = entry.getKey();
String[] val = entry.getValue();
System.out.println(key + " " + val[0] + " " + val[1]);
}
}
}

（4）容器-ArrayList-排序

这道题要求输入多个学生的成绩信息，并使用ArrayList来存储学生信息。每个学生的成绩信息包括学号、姓名、数学成绩和物理成绩。学号是每个学生的唯一识别号，而姓名可能会存在重复。

输入的格式为每个学生的成绩信息，格式为：学号+英文空格+姓名+英文空格+数学成绩+英文空格+物理成绩。输入以"end"为结束标志。

输出的格式要求按照数学/物理成绩之和从高到低的顺序输出所有学生信息。每个学生信息的输出格式为：学号+英文空格+姓名+英文空格+数学/物理成绩之和。如果有多个学生的成绩之和相同，则按照输入的先后顺序输出。

解题思路：

创建一个ArrayList来存储学生信息。

使用循环读取输入，直到输入为"end"为止。

每次读取输入时，将学生的成绩信息分割成学号、姓名、数学成绩和物理成绩。

计算数学/物理成绩之和，并将学生信息存储到ArrayList中。

对ArrayList进行排序，按照数学/物理成绩之和从高到低排序。

遍历排序后的ArrayList，按照指定的输出格式输出每个学生的信息。下面是我的源码：

import java.util.ArrayList;

import java.util.Scanner;public class Main {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

ArrayList<Student> list = new ArrayList<>();

while (true) {
String str = input.nextLine();
if ("end".equals(str)) {
break;
}

String[] s = str.split(" ");

String sno = s[0];
String name = s[1];
int math = Integer.parseInt(s[2]);
int physics = Integer.parseInt(s[3]);

list.add(new Student(sno, name, math, physics));
}

// 按照数学分数排序
list.sort((o1, o2) -> (o2.getMath() + o2.getPhysics()) - (o1.getMath() + o1.getPhysics()));

for (Student stu : list) {
System.out.println(stu);
}
}
}

class Student {
private final String sno;
private final String name;
private final int math;
private final int physics;
private final int sum;

public Student(String sno, String name, int math, int physics) {
this.sno = sno;
this.name = name;
this.math = math;
this.physics = physics;
this.sum = math + physics;
}

public String getSno() {
return sno;
}

public String getName() {
return name;
}

public int getMath() {
return math;
}

public int getPhysics() {
return physics;
}

public int getSum() {
return sum;
}

@Override
public String toString() {
return sno + " " + name + " " + sum;

（5） jmu-Java-02基本语法-03-身份证排序

 

这道题目要求我们输入一些身份证号码，并根据输入的指令进行不同的操作。我们需要根据输入的是"sort1"还是"sort2"来执行相应的功能。

首先，我们需要输入一个整数n，表示接下来要输入的身份证号码的数量。然后，我们需要连续输入n个身份证号码。

接下来，我们需要根据输入的指令来执行相应的功能。如果输入的是"sort1"，我们需要将每个身份证的年月日抽取出来，并按照年-月-日的格式组装起来。然后，我们需要对组装后的年-月-日进行升序排序，并输出结果。

如果输入的是"sort2"，我们需要将所有身份证的年月日抽取出来，并按照年-月-日的格式组装起来。然后，我们需要对组装后的年-月-日进行升序排序，并输出结果。

如果输入的不是"sort1"也不是"sort2"，我们需要输出"exit"并退出程序。

在处理输入的时候，我们可以使用Scanner类的nextLine()方法来读取输入，以免出错。

（6）jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack

这道题要求定义一个IntegerStack接口，声明了一些常见的栈操作方法。然后，根据输入的n建立一个可包含n个元素的ArrayIntegerStack对象，并进行入栈和出栈操作。最后输出栈顶元素、是否为空、栈的大小以及内部数组中的值。

定义IntegerStack接口，用于声明一个存放Integer元素的栈的常见方法:

public Integer push(Integer item); //如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。

public Integer pop(); //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null public Integer peek(); //获得栈顶元素，如果为空，则返回null. public boolean empty(); //如果为空返回true public int size(); //返回栈中元素个数

定义IntegerStack的实现类ArrayIntegerStack，内部使用数组实现。创建时，可指定内部数组大小。

main方法说明 输入n，建立可包含n个元素的ArrayIntegerStack对象 输入m个值，均入栈。每次入栈均打印入栈返回结果。 输出栈顶元素，输出是否为空，输出size 使用Arrays.toString()输出内部数组中的值。 输入x，然后出栈x次，每次出栈均打印。 输出栈顶元素，输出是否为空，输出size 使用Arrays.toString()输出内部数组中的值。

下面是源码：

import java.util.Arrays; import java.util.Scanner;

interface IntegerStack { public Integer push(Integer item); // 如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item

public Integer pop(); // 出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null

public Integer peek(); // 获得栈顶元素，如果为空，则返回null

public boolean empty(); // 如果为空返回true

public int size(); // 返回栈中元素个数
}

class ArrayIntegerStack implements IntegerStack { private Integer[] arr; private int top = 0;

public ArrayIntegerStack(int n) {
arr = new Integer[n];
Arrays.fill(arr, null);
}

public ArrayIntegerStack() {
}

@Override
public String toString() {
return Arrays.toString(arr);
}

@Override
public Integer push(Integer item) {
if (item == null || arr.length == top) {
return null;
}
arr[top++] = item;
return item;
}

@Override
public Integer pop() {
if (top == 0) {
return null;
}
return arr[--top];
}

@Override
public Integer peek() {
if (top == 0) {
return null;
}
return arr[top - 1];
}

@Override
public boolean empty() {
return top == 0;
}

@Override
public int size() {
return top;
}
}

public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int stackSize = scanner.nextInt(); ArrayIntegerStack stack = new ArrayIntegerStack(stackSize); int numItems = scanner.nextInt(); while (numItems-- > 0) { int item = scanner.nextInt(); System.out.println(stack.push(item)); } System.out.println(stack.peek() + "," + stack.empty() + "," + stack.size()); System.out.println(stack); int numPops = scanner.nextInt(); while (numPops-- > 0) { System.out.println(stack.pop()); } System.out.println(stack.peek() + "," + stack.empty() + "," + stack.size()); System.out.println(stack); } }

（7）jmu-Java-03面向对象基础-05-覆盖

 

这道题要求我们定义一个名为PersonOverride的类，并覆盖其toString和equals方法。

首先，我们需要定义PersonOverride类，该类具有以下属性：

• name：姓名，类型为String
• age：年龄，类型为int
• gender：性别，类型为boolean

接下来，我们需要实现PersonOverride类的构造方法：

• 有参构造方法：接受name、age和gender作为参数，用于初始化对象的属性。
• 无参构造方法：使用this关键字调用有参构造方法，并传入默认的参数值。

然后，我们需要覆盖PersonOverride类的toString方法，以返回格式为"name-age-gender"的字符串。

最后，我们需要覆盖PersonOverride类的equals方法，用于比较两个PersonOverride对象是否相等。在比较过程中，我们需要比较name、age和gender这三个属性的值是否都相等，只有当这三个属性的值都相等时，equals方法才返回true。

采坑心得

1. 理解题目要求：在开始解题之前，确保完全理解题目要求和给定的输入输出格式。这将帮助您确定所需的数据结构和算法，并避免在后续实现中出现错误。

2. 处理输入数据：在处理输入数据时，要注意数据类型的转换和异常处理。确保正确读取输入，并根据题目要求将其转换为适当的数据类型。还要注意处理可能出现的异常情况，例如输入格式错误或输入值超出范围等。

3. 设计合适的数据结构：根据题目要求，选择合适的数据结构来存储和操作数据。在这道题中，您可能需要使用类和对象来表示学生信息，并使用列表或数组来存储学生对象。

4. 实现逻辑和算法：根据题目要求，实现相应的逻辑和算法。在这道题中，您可能需要计算学生的总分，并根据总分对学生进行排序。

5. 调试和测试：在实现代码之后，进行适当的调试和测试以确保代码的正确性。检查边界条件和特殊情况，并验证代码的输出是否与预期结果一致。

6. 优化性能：如果您的代码在性能方面存在问题，可以考虑优化算法或数据结构来提高代码的效率。例如，使用适当的数据结构来减少时间复杂度或使用缓存来减少重复计算。

7. 编码风格和可读性：编写清晰、易于理解和维护的代码是非常重要的。遵循适当的命名约定、良好的缩进和注释，以提高代码的可读性。此外，考虑使用合适的设计模式和封装来提高代码的模块化和可重用性。

改进建议

 7-1 容器-HashMap-检索

这段代码看起来基本上是正确的，但是有一些改进的地方可以考虑：

1. 输入验证：在读取输入行并拆分为字符串数组之前，可以添加一些输入验证，确保输入的格式是正确的。例如，检查输入行是否包含至少三个元素，以避免出现数组越界错误。

2. 错误处理：如果输入的键不存在于映射中，代码将输出一条错误消息。可以考虑在这种情况下提示用户输入一个有效的键，或者提供其他选项。

3. 分离逻辑：将代码分解为更小的方法可以提高可读性和可维护性。例如，可以将读取输入和构建映射的逻辑放在一个单独的方法中，然后在主方法中调用该方法。

4. 使用更具描述性的变量名：变量名tmp不够具有描述性，可以考虑使用更具意义的变量名来提高代码的可读性。

5. 添加注释：在代码中添加适当的注释可以帮助其他人理解代码的目的和逻辑。

7-2 容器-HashMap-排序

以下是对您的代码进行改进的建议：

1. 格式化代码的缩进：代码缩进是提高代码可读性的重要因素。请确保代码的缩进正确，以使代码块之间的关系清晰可见。

2. 使用合适的命名规范：根据Java的命名规范，类名应该使用大驼峰命名法，方法名和变量名应该使用小驼峰命名法。请考虑修改类名和方法名的命名方式，以使其符合命名约定。

3. 使用try-with-resources进行资源管理：对于Scanner类的实例，最好使用try-with-resources语句进行资源管理，以确保资源正确关闭。

4. 将循环条件改为有意义的检查：在您的代码中，“while(true)”是无限循环的条件。为了使代码更具可读性，建议使用具有有意义的循环条件，例如检查输入字符串是否为“end”后终止循环。

5. 考虑异常处理：在您的代码中，将字符串转换为整数时使用了“Integer.parseInt()”方法，但没有处理NumberFormatException。请考虑添加适当的异常处理机制。

6. 实现Comparable接口：为学生类实现Comparable接口，并重写compareTo方法，以便在排序过程中指定比较的规则。这样，您可以直接对学生对象进行排序，而不需要在排序之前计算总分。

7. 在Student类中添加equals和hashCode方法：为了正确比较学生对象的相等性，建议在学生类中添加equals和hashCode方法。这样，您可以在需要时正确比较学生对象。

8. 使用StringBuilder构建字符串：在循环中使用“+”操作符来拼接字符串可能会造成性能问题。建议使用StringBuilder类来构建字符串，以提高性能。

9. 将打印逻辑提取为一个方法：将打印学生列表的逻辑提取为一个独立的方法，以提高代码的模块化和可重用性。

总结

我认为这三次PTA题目集作为作业非常出色。它们与教学内容紧密结合，涵盖了重点知识点，让我学到了很多东西，也发现了自己需要改进的地方。

这三次作业的布置时间与课程进度基本一致，与教学贴合度很高。但是，要想更好地完成这些作业，仅仅依靠课堂上学到的知识是不够的。我们还需要在课外时间进行更多的补充学习，比如其中一个题目需要用到哈希表。

这三次作业非常明确地强调了我们学习的重点知识。键盘录入与输出、选择、循环、一维数组等基础知识重点在题目中反复出现，而在学完面向对象程序设计后，题目也及时跟进，引入了菜单系列题目。这让我巩固了课堂上所学的知识。

此外，通过这些题目，我也发现了自己的很多不足之处。首先是对面向对象思想的理解和运用还比较浅薄，导致我在解决菜单系列题目时遇到了很多问题。因此，我需要加强对类和对象、封装、继承和多态思想的理解和接受程度。其次，我在编程时不能够抓住关键点，完成作业的效率明显低于其他同学，结果也更差。

最后，我认为老师在布置作业时可以更多考虑到学生个人能力有限的情况，并相应地调整题目的难度。这样可以使学生逐步掌握学习内容，循序渐进地提高能力。

   

此外，我还发现在完成这些作业的过程中，自己的编程能力得到了显著的提升。通过反复练习，我逐渐掌握了编写代码的基本技巧和方法，例如如何合理地使用变量、循环和条件语句，以及如何进行模块化的程序设计。这些技能不仅在解决作业问题时发挥了重要作用，也在日常生活中帮助我解决了一些实际问题。

此外，通过与同学们的交流和讨论，我也学到了很多新的解题思路和方法。每个人都有自己独特的思考方式和解决问题的经验，通过与他们的交流，我不仅开阔了眼界，也学到了很多新的知识和技巧。这种合作学习的方式不仅提高了我的编程能力，也促进了我与他人的交流和合作能力。

总的来说，这三次PTA题目集作为作业给了我很好的学习机会，让我在实践中巩固和提升了自己的编程能力。通过不断地思考和解决问题，我不仅学到了很多新的知识，也发现了自己的不足之处，并且在与同学们的交流中不断进步。我相信，通过持续的努力和学习，我会在编程领域取得更大的进步。

标签：return,String,get,int,ins,BLOG,public
From： https://www.cnblogs.com/p1t2s3d4/p/17507365.html