首页 > 其他分享 >PTA题目集6-8的总结性Blog

PTA题目集6-8的总结性Blog

时间：2023-06-23 21:45:40浏览次数：38  
标签：总结性 return int top System PTA Blog public out

一、前言

在这个PTA题目集中，涉及到了成绩计算中所需要的各种计算方式，容器-HashMap，容器-ArrayList，以及 jmu-Java-02基本语法和接口-自定义接口等方面的知识。总体来说，难度适中，但需要考生对这些概念有一定的了解。

二、设计与分析

首先是7-1 容器-HashMap-检索

输入多个学生的成绩信息，包括：学号、姓名、成绩。

学号是每个学生的唯一识别号，互不相同。

姓名可能会存在重复。

使用HashMap存储学生信息，并实现根据学号的检索功能

输入格式:

输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+成绩

以“end”为输入结束标志

end之后输入某个学号，执行程序输出该生的详细信息

输出格式:

输出查询到的学生信息格式：学号+英文空格+姓名+英文空格+成绩

如果没有查询到，则输出："The student "+查询的学号+" does not exist"

 

分析

本题需要实现一个学生信息管理系统，涉及到学生信息的存储和查询。我们可以使用HashMap来存储学生信息，其中，学号作为key，学生信息作为value。在查询时，根据输入的学号，检索HashMap中是否存在该学生信息，并返回查询结果。如果没有查询到，输出相应的提示信息。

设计

首先，我们需要定义一个类来存储学生信息，包括学号、姓名和成绩。然后，我们可以使用HashMap来存储学生信息，其中，学号作为key，学生信息对象作为value。当用户输入学号时，我们可以通过HashMap的get方法获取该学生的信息对象，然后输出学生信息即可。如果没有查询到该学生，可以输出相应的提示信息。

总结

本题主要考察对HashMap的使用和对类的定义的掌握程度，需要注意输入格式的处理和异常情况的处理。从SourceMonitor的生成报表也能看出题目本身并不是很复杂。

 

 

接下来看一下容器-ArrayList-排序

输入多个学生的成绩信息，包括：学号、姓名、数学成绩、物理成绩。学号是每个学生的唯一识别号，互不相同。姓名可能会存在重复。因此，可以考虑将学生信息封装成一个类，类中包含学号、姓

名、数学成绩、物理成绩等属性，并重写equals()和hashCode()方法，以保证学号的唯一性。

使用ArrayList存储学生信息，可以遍历ArrayList计算每个学生的数学成绩和物理成绩之和，然后按照题目要求排序输出。

输出格式：学号+英文空格+姓名+英文空格+数学/物理成绩之和。

下列代码可以参考

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;
// 定义学生类
class Student {
private String id; // 学号
private String name; // 姓名
private int mathScore; // 数学成绩
private int physicsScore; // 物理成绩
// 构造方法
public Student(String id, String name, int mathScore, int physicsScore) {
this.id = id;
this.name = name;
this.mathScore = mathScore;
this.physicsScore = physicsScore;
}
// 封装方法
public String getId() {
return id;
}
public String getName() {
return name;
}
public int getMathScore() {
return mathScore;
}
public int getPhysicsScore() {
return physicsScore;
}
// 重写equals()方法和hashCode()方法
@Override
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (obj == null || !(obj instanceof Student)) {
return false;
}
Student other = (Student) obj;
return this.id.equals(other.id);
}
@Override
public int hashCode() {
return id.hashCode();
}
// 计算数学成绩和物理成绩之和
public int getScoreSum() {
return mathScore + physicsScore;
}
// 重写toString()方法
@Override
public String toString() {
return id + " " + name + " " + getScoreSum();
}
}
public class StudentScoreSort {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
ArrayList<Student> list = new ArrayList<>();
String input = scanner.nextLine();
while (!input.equals("end")) {
String[] arr = input.split(" ");
String id = arr[0];
String name = arr[1];
int mathScore = Integer.parseInt(arr[2]);
int physicsScore = Integer.parseInt(arr[3]);
Student student = new Student(id, name, mathScore, physicsScore);
list.add(student);
input = scanner.nextLine();
}
scanner.close();
// 按照数学成绩和物理成绩之和排序
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
int sum1 = s1.getScoreSum();
int sum2 = s2.getScoreSum();
if (sum1 != sum2) {
return sum2 - sum1; // 从高到低排序
} else {
return list.indexOf(s1) - list.indexOf(s2); // 按照输入先后顺序排序
}
}
});
// 输出学生信息
for (Student student : list) {
System.out.println(student);
}
}
}

 

 

然后再是7-5 jmu-Java-03面向对象基础-05-覆盖  

PersonOverride类设计

  1. 属性设计
    • String类型的name属性
    • int类型的age属性
    • boolean类型的gender属性 所有属性都必须是私有属性(private)。
  2. 构造方法设计
    • 有参构造方法，参数为name, age, gender
    • 无参构造方法，使用this(name, age,gender)调用有参构造方法。参数值分别为"default",1,true
  3. equals方法设计 比较name、age、gender，这三者内容都相同，才返回true。
  4. toString方法设计 返回格式为：name-age-gender

Main方法设计

  1. 输入n1，使用无参构造方法创建n1个对象，放入ArrayList persons1。
  2. 输入n2，然后指定name age gender。每创建一个对象都使用equals方法比较该对象是否已经在ArrayList中存在，如果不存在，才将该对象放入ArrayList persons2。
  3. 输出persons1中的所有对象
  4. 输出persons2中的所有对象
  5. 输出persons2中实际包含的对象的数量5
  6. 输出PersonOverride的所有构造方法。

import java.util.ArrayList;
import java.util.Arrays;
class PersonOverride {
private String name;
private int age;
private boolean gender;
public PersonOverride(String name, int age, boolean gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
public PersonOverride() {
this("default", 1, true);
}
@Override
public boolean equals(Object obj) {
if (obj instanceof PersonOverride) {
PersonOverride person = (PersonOverride) obj;
return person.name.equals(this.name) && person.age == this.age && person.gender == this.gender;
}
return false;
}
@Override
public String toString() {
return name + "-" + age + "-" + gender;
}
}
public class Main {
public static void main(String[] args) {
ArrayList<PersonOverride> persons1 = new ArrayList<>();
ArrayList<PersonOverride> persons2 = new ArrayList<>();
int n1 = 3;
int n2 = 3;
// 创建n1个PersonOverride对象并添加到persons1中
for (int i = 0; i < n1; i++) {
persons1.add(new PersonOverride());
}
// 创建n2个PersonOverride对象并添加到persons2中
for (int i = 0; i < n2; i++) {
String name = "name" + i;
int age = i;
boolean gender = i % 2 == 0;
PersonOverride person = new PersonOverride(name, age, gender);
if (!persons2.contains(person)) {
persons2.add(person);
}
}
// 输出persons1中的所有对象
System.out.println("persons1:");
for (PersonOverride person : persons1) {
System.out.println(person.toString());
}
// 输出persons2中的所有对象
System.out.println("persons2:");
for (PersonOverride person : persons2) {
System.out.println(person.toString());
}
// 输出persons2中实际包含的对象的数量
System.out.println("persons2包含的对象数量：" + persons2.size());
// 输出PersonOverride的所有构造方法
System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
}
}

优点:

重写了equals方法，可以正确判断两个PersonOverride对象是否相等。

重写了toString方法，可以将PersonOverride对象以字符串形式输出。

用ArrayList存储PersonOverride对象，方便动态添加和删除元素。

通过contains方法和equals方法判断PersonOverride对象是否已经存在于ArrayList中，避免了重复添加。

缺点:

PersonOverride类中的属性和构造方法较为简单，可能无法满足实际需求。

没有使用泛型，可能会导致类型不安全的问题。

没有对输入的n1和n2进行校验，可能会导致程序异常。

只输出了PersonOverride类的构造方法，没有输出其他方法和属性，可能会导致信息不全。

 

 三、踩坑心得

 

import java.util.Arrays;
import java.util.Scanner;
interface IntegerStack {
Integer push(Integer item);
Integer pop();
Integer peek();
boolean empty();
int size();
}
class ArrayIntegerStack implements IntegerStack {
private int top = -1;
private final int capacity;
private final Integer[] array;
public ArrayIntegerStack(int capacity) {
this.capacity = capacity;
this.array = new Integer[capacity];
}
@Override
public Integer push(Integer item) {
if (item == null || top == capacity - 1) {
return null;
}
array[++top] = item;
return item;
}
@Override
public Integer pop() {
if (top == -1) {
return null;
}
return array[top--];
}
@Override
public Integer peek() {
if (top == -1) {
return null;
}
return array[top];
}
@Override
public boolean empty() {
return top == -1;
}
@Override
public int size() {
return top + 1;
}
@Override
public String toString() {
return Arrays.toString(array);
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
if (!scanner.hasNextInt()) {
scanner.close();
return;
}
int n = scanner.nextInt();
ArrayIntegerStack stack = new ArrayIntegerStack(n);
for (int i = 0; i < n; i++) {
if (!scanner.hasNextInt()) {
scanner.close();
return;
}
int value = scanner.nextInt();
Integer result = stack.push(value);
System.out.println(result);
}
Integer top = stack.peek();
if (top == null) {
System.out.println("null");
} else {
System.out.println(top);
}
System.out.format("%b,%d\n", stack.empty(), stack.size());
System.out.println(stack);
if (!scanner.hasNextInt()) {
scanner.close();
return;
}
int x = scanner.nextInt();
for (int i = 0; i < x; i++) {
Integer result = stack.pop();
if (result == null) {
System.out.println("null");
} else {
System.out.println(result);
}
}
top = stack.peek();
if (top == null) {
System.out.println("null");
} else {
System.out.println(top);
}
System.out.format("%b,%d\n", stack.empty(), stack.size());
System.out.println(stack);
scanner.close();
}
}这是改进前代码

import java.util.Arrays;
import java.util.Scanner;
interface IntegerStack {
Integer push(Integer item);
Integer pop();
Integer peek();
boolean empty();
int size();
}
class ArrayIntegerStack implements IntegerStack {
private int top = -1;
private int capacity;
private Integer[] array;
public ArrayIntegerStack(int capacity) {
this.capacity = capacity;
this.array = new Integer[capacity];
}
@Override
public Integer push(Integer item) {
if (item == null) {
return null;
}
if (top == capacity - 1) {
capacity *= 2;
array = Arrays.copyOf(array, capacity);
}
array[++top] = item;
return item;
}
@Override
public Integer pop() {
if (top == -1) {
return null;
}
Integer item = array[top--];
if (top < capacity / 2) {
capacity /= 2;
array = Arrays.copyOf(array, capacity);
}
return item;
}
@Override
public Integer peek() {
if (top == -1) {
return null;
}
return array[top];
}
@Override
public boolean empty() {
return top == -1;
}
@Override
public int size() {
return top + 1;
}
@Override
public String toString() {
return Arrays.toString(Arrays.copyOfRange(array, 0, top + 1));
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
if (!scanner.hasNextInt()) {
scanner.close();
return;
}
int n = scanner.nextInt();
ArrayIntegerStack stack = new ArrayIntegerStack(n);
for (int i = 0; i < n; i++) {
if (!scanner.hasNextInt()) {
scanner.close();
return;
}
int value = scanner.nextInt();
Integer result = stack.push(value);
System.out.println(result);
}
Integer top = stack.peek();
if (top == null) {
System.out.println("null");
} else {
System.out.println(top);
}
System.out.format("%b,%d\n", stack.empty(), stack.size());
System.out.println(stack);
if (!scanner.hasNextInt()) {
scanner.close();
return;
}
int x = scanner.nextInt();
for (int i = 0; i < x; i++) {
Integer result = stack.pop();
if (result == null) {
System.out.println("null");
} else {
System.out.println(result);
}
}
top = stack.peek();
if (top == null) {
System.out.println("null");
} else {
System.out.println(top);
}
System.out.format("%b,%d\n", stack.empty(), stack.size());
System.out.println(stack);
scanner.close();
}
}

改进后有以下优点

  1. 在push方法中加入自动扩容的功能，可以避免栈空间不足的情况，避免使用者频繁扩容，提高了栈的效率；
  2. 在pop方法中加入缩容的功能，可以避免栈空间浪费，提高了栈的效率；
  3. 使用Arrays.copyOf方法来复制数组，可以让代码更加简洁易懂；
  4. 使用Arrays.toString方法来打印数组，可以让代码更加简洁易懂。

四、改进建议

  1. 可以使用封装性更好的List<PersonOverride>代替ArrayList<PersonOverride>；
  2. 可以使用for-each循环代替for循环；
  3. 可以使用System.out.printf代替System.out.println输出格式更清晰的信息；
  4. 可以使用@Override注解确保重写的方法正确性；
  5. 可以使用Objects.equals代替==比较两个对象是否相等

 五、总结

　　不知不觉也已经到学期末了，在学习过程中，我发现深入理解Java编程语言的面向对象思想对于程序设计至关重要。熟练掌握Java编程语言不仅能够使我们写出规范、高效的代码，还能够提高我们的编程思维，为今后的软件开发打下坚实的基础。 总之，这个学期的Java学习让我收获颇丰，不仅熟悉了编程语言本身，也懂得了如何运用编程思维解决具体问题。我相信，这些知识和经验将对我的日后学习和工作产生深远的影响。

 

 

 

标签：总结性,return,int,top,System,PTA,Blog,public,out
From： https://www.cnblogs.com/vyseven/p/17500238.html

相关文章

  • PTA第6-8次成绩系统分析
    PTA第6~8次题目分析前言：第6-8次的成绩系统和之前菜单系统的结构和逻辑都有很多相似的地方，包括信息第二部分的处理判断都需要建立在第一部分上，以及排序输出等。不过这次的排序输出有点新东西，要按中英文的首字母顺序排，我也是搜过之后才学会这点。这次成绩系统还存在不简单的错误提......
  • BLOG-3
    第6-8次大作业总结博客/*全文字数4000+*/ 一、前言：知识点分析：1.Java基础语法（变量、数据类型、运算符、流程控制、函数等）。2.Java集合框架，如List、Map等。3.异常处理机制，如try-catch块。4.数组和字符串操作。5.对象和类，包括静态方法、构造方法、实例方法等等。二......
  • 第三次总结性blog
    目录 1.前言2.设计与分析3.踩坑心得4.改进建议5.总结 1.前言题目集8课程成绩统计程序-1题目集9统计Java程序中关键词的出现次数题目集10容器-HashMap-检索容器-HashMap-排序课程成绩统计程序-2动物发声模拟器......
  • JAVA面向对象程序设计_PTA题目集07-11总结分析
    JAVA面向对象程序设计_PTA题目集07-11总结分析前言：天将降大任于是人也，必先苦其心志，劳其筋骨，饿其体肤，空乏其身，行拂乱其所为。所以动心忍性，增益其所不能。随堂检测在最末浅析。 题目集七：知识点：类间设计，类的设计。题量：一题，菜单计价五。难度：八个满分。 题目集八：知识点：类......
  • BLOG-3
    一、**前言**本次Java大作业是一次非常有意义的学习经历，我们学习了泛型、接口、继承与多态、组合、排序、HashMap、HashSet、TreeMap等知识点，并将它们应用于实际编程中。通过这次大作业，我们不仅巩固了Java基础知识，还学会了如何将这些知识点结合起来进行实际应用。二、**设计与分......
  • BLOG-3
    （1）前言：这三次作业加强了我们对HashMap 类的理解，训练了我们对HashMap 类中方法的掌握，再次加强对我们对继承关系中的多态的掌握。也让我们通过例子掌握ArrayList-排序，以及各种自定义接口。而本次的迭代题目是课程成绩统计，主要还是按照类图设计代码，以及考虑字符的比较以及排序，题目......
  • BLOG-3
    前言： 这次博客是对之前发布的6-8次PTA题目集（成绩计算系列）的一次总结，经过前几次系列题目的磨练，相信对于认真写的同学来说这次成绩系列的题目也不是很难。只要肯花点时间，拿个及格不是问题。题量来说还是比较少的，对于一些高手来说，几个小时便可拿到高分。设计与分析：7-1课程成绩......
  • Blog-3
    (1).前言：（总结之前所涉及到的知识点、题量、难度等情况）一7-1课程成绩统计程序-1难度：对我来说，难，难，难，写这个我花了好长时间，分析了很久很久，但是要比较的话，菜单要更难，还是我太菜了。知识点：1.集合类：代码使用了多种集合类，如'ArrayList'、'HashMap'和'LinkedHashMap'，用于存储和管理......
  • 最后一次Blog
    BLOG： 1.前言:最后几周的PTA难度明显上升,需要设计的类更多,尤其是学生成绩录入系统。还更考察对集合的使用,如Map，Set集合,利用他们自动排序去重的功能,完成题目.难度呈递增趋势。自己还是太菜,许多题目就没有拿到满分。随着本次的博客作业到来也预示着我的本学期的Java课程也......
  • PTA6-8次题目集（成绩计算系列）总结
    1.前言6-8次作业题量不大，难度较菜单计价较小，但实现过程依旧繁琐知识点输入和输出处理：你需要从用户或文件中读取输入数据（课程信息和学生成绩），然后相应地进行处理。你可以使用诸如读取控制台输入（Scanner 类）或从文件读取技术。字符串操作和解析：你需要将输入的字符串分割后提......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99