首页 > 编程语言 >Java题目集1-3总结

Java题目集1-3总结

时间：2024-04-18 21:23:11浏览次数：23  
标签：总结 题目 String int void num answer Java public

（1）前言：第一次大作业的知识点包括类与对象正则表达式以及数组对象和不同类之间的关系；题量较小，难度不大，关键是理清question，test-paper，answer-paper之间的关系。
第二次大作业的知识点增加了List,ArrayList,HashMap,三种变长数组的使用，增加了正则表达式的难度，题量增加，难度上升，试卷中的题目增加了分数。
第三次大作业的知识点增加了很多的异常处理，例如wrongformat,删除题目等；题量中等，难度中等，答卷可能为空，题目不存在等异常情况的判断处理。
（2）设计与分析：
第一次大作业源码
import java.util.Scanner;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main{
public static class Topic{
private int num;
private String item;
private String standardanswer;
public Topic(){}
public Topic(int num,String item,String standardanswer)
{
this.num=num;
this.item=item;
this.standardanswer=standardanswer;
}
public int getTopicnum(){
return this.num;
}
public void setTopicnum(int num)
{
this.num=num;
}
public String getitem(){
return this.item;
}
public void setitem(String item){
this.item=item;
}
public String getstandardanswer()
{
return this.standardanswer;
}
public void setstandardanswer(String standardanswer)
{
this.standardanswer=standardanswer;;
}
public Boolean judge(String answer){
if(standardanswer.equals(answer))
return true;
else
return false;
}
}
public static class Tpaper{
private Listtopics=new ArrayList<>();
private List topicNumbers = new ArrayList<>();
public Tpaper(){
}
public void addTopic(int num, String item, String standardAnswer) {
Topic topic = new Topic(num,item, standardAnswer);
topics.add(topic);
topicNumbers.add(num);
}
public boolean judge(int num, String answer) {
Topic topic = getTopicByNumber(num);
return topic != null && topic.judge(answer);
}

    public Topic getTopicByNumber(int num) {
        for (Topic topic : topics) {
            if (topic.num == num) {
                return topic;
            }
        }
        return null;
    }
}
public static class Apaper{
    private Tpaper tpaper;
    private List<String> answers = new ArrayList<>();
    private List<Boolean> answerresults = new ArrayList<>();
    public Apaper(){}
    public Apaper(Tpaper tpaper)
    {
        this.tpaper=tpaper;
    }
    public void addAnswer(int num, String answer) {
    answers.add(answer);
    answerresults.add(tpaper.judge(num, answer));
    }
    public void tostring() {
    for (int i = 0; i < answers.size(); i++) {
    Topic topic= tpaper.getTopicByNumber(i + 1);
    System.out.println(topic.getitem() +"~" + answers.get(i));
    }
    for(int i=0;i<answers.size();i++)
    {
    boolean result =answerresults.get(i);
    if(i!=answers.size()-1)
    System.out.print((result ? "true" : "false")+" ");
    else
    System.out.print((result ? "true" : "false"));
    }
                            }
}
public static void main(String[] args)
{
    Scanner input=new Scanner(System.in);
    int n,num;
    String s,topicitem,standardanswer,Ap;
    n=input.nextInt();
    input.nextLine();
    Tpaper tpaper=new Tpaper();
    Pattern pattern = Pattern.compile("#N:\\s*(\\d+)\\s*#Q:\\s*([^#]+)\\s#A:\\s*(\\S+)");
    for(int i=0;i<n;i++)
    {
        s=input.nextLine();
        Matcher matcher = pattern.matcher(s);
        if(matcher.find())
        {
            num=Integer.parseInt(matcher.group(1));
            topicitem=matcher.group(2);
            topicitem=topicitem.trim();
            standardanswer=matcher.group(3);
            tpaper.addTopic(num,topicitem,standardanswer);
        }
    }
        Apaper apaper=new Apaper(tpaper);
        while (!(Ap = input.nextLine()).equals("end")) {
        String[] partofanswer = Ap.split(" ");
        for (int i = 0; i < partofanswer.length; i++) {
            apaper.addAnswer(i + 1, partofanswer[i].substring(3));
        }
    }
    apaper.tostring();
}

}
第一次大作业设计了三个类，分别是topic题目，testpaper试卷，answerpaper答卷
topic中有题号，题目内容，标答三个属性，有判题方法判断答卷中的答案与标答是否一致；
test paper中有题目集合题目号集合两个数据判题方法，添加题目方法，根据题号得到题目方法；
Answerpaper中有试卷数据，答案数据集合，答案结果集合三个数据，以及打印题目作答结果方法；
主方法中使用了正则表达式去匹配题目信息，使用字符串数组储存答案内容；最后调用answer paper的tostring方法输出结果。
第二次大作业试卷中增加了题目的分数给题目赋分，并且可以有多张试卷和答卷答卷的信息输入格式也不同。并且若试卷总分不足100分需要提示和答案可能为空等情况。
增加的代码没有很多，这里就不赘述了。
第三次大作业源码
import java.util.Scanner;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
import java.util.ArrayList;
import java.util.List;
class Question {
private int num,score,answer,sumscore,flag=1;
private String item;
public Question(){}
public Question(int num, String item, int answer) {
this.num = num;
this.item = item;
this.answer = answer;
}
public Question(int num,int answer)
{
this.num=num;
this.answer=answer;
}
public int getnum() {
return this.num;
}
public void setnum(int num)
{
this.num=num;
}
public int getscore() {
return this.score;
}
public void setscore(int score) {
this.score = score;
}
public int getsumscore()
{
return this.sumscore;
}
public void setsumscore(int sumscore)
{
this.sumscore=sumscore;
}
public int getanswer() {
return this.answer;
}
public void setanswer(int answer)
{
this.answer=answer;
}
public String getitem()
{
return this.item;
}
public void setitem(String item)
{
this.item=item;
}
public void setflag(int flag)
{
this.flag=flag;
}
public int getflag()
{
return this.flag;
}
}
class Testpaper {
private int num;
public List questions = new ArrayList<>();
public Testpaper(){}
public Testpaper(int num)
{
this.num=num;
}
public int getnum(){
return this.num;
}
public void setnum(int num) {
this.num = num;
}
public void addQuestion(Question question) {
this.questions.add(question);
}
public int getsumscore() {
int sumscore=0;
for (Question question : this.questions) {
sumscore += question.getscore();
}
return sumscore;
}
public List getquestions(){
return this.questions;
}
}
class Answerpaper {
private int number;
private String sid;
private List questions = new ArrayList<>();
public Answerpaper(){}
public Answerpaper(int number)
{
this.number=number;
}
public void setnumber(int number) {
this.number = number;
}
public int getnumber(){
return this.number;
}
public void addanswer(int num,int answer)
{
Question question=new Question(num,answer);
this.questions.add(question);
}
public List getquestions() {
return this.questions;
}
public String getsid()
{
return this.sid;
}
public void setsid(String sid) {
this.sid = sid;
}
}
class Student{
private String sid,name;
Student(){}
Student(String sid,String name)
{
this.sid=sid;
this.name=name;
}
public String getsid() {
return sid;
}

public void setsid(String sid) {
	this.sid = sid;
}

public String getname() {
	return name;
}

public void setname(String name) {
	this.name = name;
}

}
public class Main {
public static void main(String[] args) {
Listquestions=new ArrayList<>();
Listtestpapers=new ArrayList<>();
Listanswerpapers=new ArrayList<>();
Liststudents=new ArrayList<>();
Scanner input = new Scanner(System.in);
String str;
Pattern pattern1 = Pattern.compile("#N:\s(\d+)\s#Q:\s([^#]+)\s#A:\s(\S+)");
//pattern1匹配question;
Pattern pattern2 = Pattern.compile("#T:\s(\d+)\s([\d+]-[\d+]\s)+");
//pattern2匹配test paper；
Pattern pattern3 = Pattern.compile("#X:\s([\d]+\s[A-Za-z]+-)+");
//pattern3匹配Student；
Pattern pattern4 = Pattern.compile("#S:\s(\d+)\s(\d+)\s(#A:\s[\d]+-[\d]+\s)");
//pattern4匹配Answer paper;
Pattern pattern5 = Pattern.compile("#D:N-\s(\d+)");
//pattern5匹配删除题目信息；
while(!(str=input.nextLine()).equals("end"))
{
int flag=0;
Matcher matcher1 = pattern1.matcher(str);
Matcher matcher2 = pattern2.matcher(str);
Matcher matcher3 = pattern3.matcher(str);
Matcher matcher4 = pattern4.matcher(str);
Matcher matcher5 = pattern5.matcher(str);
if(matcher1.find())
flag=1;
else if(matcher2.find())
flag=2;
else if(matcher3.find())
flag=3;
else if(matcher4.find())
flag=4;
else if(matcher5.find())
flag=5;
switch(flag)
{
case 0:
System.out.println("wrong format:"+str);
break;
case 1:
Question question=new Question(Integer.parseInt(matcher1.group(1)),matcher1.group(2).trim(),Integer.parseInt(matcher1.group(3)));
questions.add(question);
break;
case 2:
int num=Integer.parseInt(matcher2.group(1));
Testpaper testpaper=new Testpaper();
testpaper.setnum(num);
Pattern pattern6 = Pattern.compile("(\d+)-(\d+)");
Matcher matcher6 = pattern6.matcher(str);
while(matcher6.find())
{
flag=0;
for (Question question1 : questions) {
if (question1.getnum() == Integer.parseInt(matcher6.group(1))) {
flag=1;
Question question2 = new Question(question1.getnum(), question1.getitem(), question1.getanswer());
question2.setscore(Integer.parseInt(matcher6.group(2)));
testpaper.addQuestion(question2);
}
}
if(flag==0)
{
Question question2 = new Question();
question2.setnum(Integer.parseInt(matcher6.group(1)));
question2.setscore(Integer.parseInt(matcher6.group(2)));
testpaper.addQuestion(question2);
}
}
testpapers.add(testpaper);
break;
case 3:
Pattern pattern7 = Pattern.compile("(\d+)\s([A-Za-z]+)");
Matcher matcher7 = pattern7.matcher(str);
while(matcher7.find())
{
Student student=new Student(matcher7.group(1),matcher7.group(2));
students.add(student);
}
break;
case 4:
num=Integer.parseInt(matcher4.group(1));
String sid=matcher4.group(2);
Answerpaper answerpaper=new Answerpaper();
answerpaper.setnumber(num);
answerpaper.setsid(sid);
Pattern pattern8 = Pattern.compile("#A:\s*(\d+)-(\d+)");
Matcher matcher8 = pattern8.matcher(str);
while(matcher8.find())
{
num=Integer.parseInt(matcher8.group(1));
int answer=Integer.parseInt(matcher8.group(2));
answerpaper.addanswer(num, answer);
}
answerpapers.add(answerpaper);
break;
case 5:
num=Integer.parseInt(matcher5.group(1));
for (Testpaper testpaperj : testpapers)
{
for (Question questionk : testpaperj.getquestions())
{
if(numquestionk.getnum())
{
questionk.setflag(0);
}
}
}
break;
default :break;
}
}
for (Testpaper testpaperi : testpapers) {
if (testpaperi.getsumscore() != 100) {
System.out.println("alert: full score of test paper" + testpaperi.getnum() + " is not 100 points");
}
}
for (Answerpaper answerpaperi : answerpapers) {
int f = 0,num;
num = answerpaperi.getnumber();
for (Testpaper testpaperj : testpapers) {
if (num == testpaperj.getnum()) {
f = 1;
int x = 0;
for (Question questionk : testpaperj.getquestions()) {
if(x>=answerpaperi.getquestions().size()){
System.out.println("answer is null");
continue;
}
if(questionk.getflag()1)
{
if (questionk.getanswer() == answerpaperi.getquestions().get(x).getanswer()&&questionk.getnum()answerpaperi.getquestions().get(x).getnum()) {
questionk.setsumscore(testpaperj.getquestions().get(x).getscore());
System.out.println(questionk.getitem() + "~" + answerpaperi.getquestions().get(x).getanswer() + "~" + "true");
} else {
questionk.setsumscore(0);
if(questionk.getanswer()0)
{
System.out.println("non-existent question~0");
}
else
for(Question que:answerpaperi.getquestions())
{
if(questionk.getnum()que.getnum())
System.out.println(questionk.getitem() + ""+que.getanswer()+""+"false");
}
}
}
else
{
System.out.println("the question "+questionk.getnum()+" invalid~0");
questionk.setsumscore(0);
}
x++;
}
int flag2=0;
for(Student studentsi:students)
{
if(answerpaperi.getsid().equals(studentsi.getsid()))
{
flag2=1;
System.out.print(studentsi.getsid()+" "+studentsi.getname()+": ");
break;
}
}
if(flag21)
{
int sum = 0;
int t = 0;
for(Question questionl:testpaperj.getquestions()){
if(t == 0){
sum+=questionl.getsumscore();
System.out.print(questionl.getsumscore());
t++;
}else{
sum+=questionl.getsumscore();
System.out.print(" "+questionl.getsumscore());
}
}
System.out.println("~"+sum);
}
else
{
System.out.println(answerpaperi.getsid()+" not found");
}
}
}
if(f == 0){
System.out.println("The test paper number does not exist");
}
}
}
}
第三次大作业增加了学生信息和删除题目信息，学生信息中包含学生学号和学生姓名的属性，还增加了删除题目信息，被删除的题目不能被引用，被引用时要给出提示。
也增加了很多异常判断，较大地增加了题目的难度。
（3）踩坑心得：
第三次作业中我将question中的答案属性定义为int型，但是后来添加的样例让我发现答案定义为String型才对这导致我一直有几个测试点过不去
class Question {private int num,score,answer,sumscore,flag=1;
还有空试卷和答案为空字符的情况我不知道该如何处理，那几个测试点也过不去，在main函数中我的代码太长太乱了，圈复杂度很高，代码耦合性很高，第二次到第三次很能对代码进行修改，而且其中的逻辑很复杂代码可读性很低，我应该在answerpaper中保存答案和答题结果属性，应该把判题方法放在test paper中而不是主函数中，也应该把输出答题结果的方法放在answer paper中，这样才不会使主函数过于复杂。
（4）改进建议：
大作业1的改进：
1.将tostring方法改名为displayResults，以更清晰地表达其功能。
2. 异常处理：在处理输入时，考虑添加异常处理逻辑，以应对可能的非法输入。
3. 代码清晰性：在Apaper类的构造函数中，可以省略默认的无参构造函数。
4. 代码优化：在Tpaper类中，getTopicByNumber方法可以利用Java 8的流（Stream）来简化查找逻辑。
6. 代码组织：考虑将打印逻辑（如输出格式）从Apaper类中分离出来，以提高代码的可维护性和可读性。
8. 代码注释：添加必要的注释来解释复杂的逻辑或决策。
12. 资源管理：使用Scanner时，记得在最后关闭它，以释放系统资源。
下面是根据上述建议修改后的代码示例：
其他类保持不变）
public static class Apaper {
private Tpaper tpaper;
private List answers = new ArrayList<>();
private List answerresults = new ArrayList<>();

public Apaper(Tpaper tpaper) {
    this.tpaper = tpaper;
}

public void addAnswer(int num, String answer) {
    answers.add(answer);
    answerresults.add(tpaper.judge(num, answer));
}

改进后的输出方法
public void displayResults() {
    for (int i = 0; i < answers.size(); i++) {
        Topic topic = tpaper.getTopicByNumber(i + 1);
        System.out.println(topic.getitem() + "~" + answers.get(i));
    }
    for (int i = 0; i < answers.size(); i++) {
        boolean result = answerresults.get(i);
        System.out.print(result ? "true" : "false");
        if (i < answers.size() - 1) {
            System.out.print(" ");
        }
    }
    System.out.println(); // 添加换行符以保持格式整洁
}

}
main方法保持不变，但考虑添加异常处理和资源管理）
在main方法的最后，添加资源释放
input.close();
这些改进将使代码更加健壮、清晰，并易于维护。
大作业3的改进建议：
3. 输入验证：在处理用户输入时，添加必要的验证逻辑，确保输入的数据格式正确、有效。
4. 代码注释：为复杂的逻辑和正则表达式添加注释，帮助其他开发者理解代码的意图和功能。
5. 代码重构：对于较长的方法，考虑拆分成更小的、功能单一的方法，以提高代码的清晰度。
6. 性能优化：考虑使用更高效的数据结构，如HashMap，来存储和管理题目、试卷和答卷信息，以提高查找和匹配的效率。
11. 功能扩展：考虑未来可能的功能扩展，如支持多种题型、不同分值的题目、成绩统计和分析等。
13. 资源管理：确保在程序结束时正确关闭所有打开的资源，如Scanner对象。
14. 解耦：尝试将不同的功能模块解耦，以提高代码的灵活性和可维护性。
15. 代码复用：在处理相似的功能时，避免重复代码，提高代码的复用性。
17. 安全性：如果程序将被用于实际的考试环境，考虑添加必要的安全措施，如防止作弊和确保数据的完整性。
这些建议旨在提高程序的健壮性、可维护性、用户友好性和可扩展性。根据具体需求和资源，可以选择合适的建议来改进程序。
（5）总结：
通过这三次题目集我学到了如何定义类和创建对象，对类内的数据进行封装，调用类内的方法，不同类之间的关系有几种具体是怎么样的；还学会了正则表达式的入门简单使用，还有List，ArrayList,HashMap这三种集合存储方式不同的方法各有优劣，这里不过多讨论，还有类图，类间关系的设计。
正则表达式还不够熟练需要进一步学习及研究正则表达式是一种强大的文本处理工具，它定义了搜索或操作字符串的一种逻辑公式。通过使用正则表达式，可以进行复杂的文本匹配、验证、提取和替换等操作。以下是学习正则表达式的基本步骤：
学习资源：

  1. 在线教程：有许多在线教程和网站提供正则表达式的学习材料，如RegexOne、RegExr等。
  2. 书籍：《正则表达式必知必会》等书籍系统地介绍了正则表达式的基础知识和应用。
  3. 实践工具：使用正则表达式测试工具，如Regex101、RegExtester，可以实时测试和调试正则表达式。
  4. 编程文档：查阅编程语言官方文档，了解如何在特定语言中使用正则表达式。
    学习建议：
  5. 理解基础：首先掌握正则表达式的基本语法和概念。
  6. 动手实践：通过编写和测试正则表达式来加深理解。
  7. 逐步提高：在掌握基础之后，逐步学习更高级的特性和技巧。
  8. 实际应用：尝试在实际项目中应用正则表达式，解决实际问题。
  9. 持续学习：正则表达式是一个深奥的主题，不断学习新技巧和最佳实践。
    通过上述步骤和资源，我可以逐步提高我的正则表达式技能，并在实际编程和大作业中有效地使用它们。
    最后，对教师、课程、作业、实验、课上及课下组织方式等方面我个人无意见。

标签：总结,题目,String,int,void,num,answer,Java,public
From： https://www.cnblogs.com/97-1412/p/18144430

相关文章

  • java-collections-map t
    MapMap常用子类HashMap：HashMap是最常用的Map实现之一，它基于哈希表实现，提供了O(1)时间复杂度的插入、删除和查找操作。Hashtable：Hashtable是较早期的Java集合类，它是线程安全的，但性能通常比HashMap差，因为它的方法是同步的。TreeMap：TreeMap是基于红黑树实现的有序Ma......
  • java 代码编译检查工具
    <build><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>3.11.0</version><configuration><encoding&......
  • CXF WebService wsdl2java
    下载apache-cxf-3.3.1并解压到bin目录下，输入生成命令wsdl2java-encodingutf-8-dD:\Software\Webservice\wshttp://XXX.XXX.XXX.XXX:XXX/WSInterface.asmx?wsdl把生成的文件，复制到项目中，进行后续编码......
  • java-mysql-语法
    条件查询1.条件运算符:>,<,=,!=,<>2.按逻辑表达式:&&,||,!and，or，not &&和and:两个条件都为true.结果为true,反之为false ||和or:只要有一个条件为true,结果就为true,反之为false !和not:如果连接的条件本身就为false,结果为......
  • 通过Java修改consul配置（保留注释、保留缩进）
         直接上代码了，找了很久也没找到保留注释的三方包，snakeyaml的缩进一直也有问题，就自己写了个正则方式的consul也没有相关接口，只接受整个的传key和value，替换相应value值，大佬有更好的方法希望能告诉我<dependency><groupId>com.orbitz.consu......
  • JAVA基础-流程控制、字符串
    一、java基础1、java主类结构packagecom.study.again001;包名publicclasshelloword{类名staticStrings1="1";静态成员变量publicstaticvoidmain(String[]args){main方法Strings2="2";局部变量System.out.println(s1......
  • java静态代理模式
    通过模拟租房来展现静态代理模式租房接口//租房publicinterfaceRent{publicvoidrent();}被代理的真实角色房东//房东publicclassHostimplementsRent{@Overridepublicvoidrent(){System.out.println("房东要出租房租");}}......
  • 30天【代码随想录算法训练营34期】第七章 回溯算法part06 （● 332.重新安排行程 ● 51
    332.重新安排行程木有看懂，没视频所以也没看懂51.N皇后自己写出来还是有难度的classSolution:defsolveNQueens(self,n:int)->List[List[str]]:result=[]#存储最终结果的二维字符串数组chessboard=['.'*nfor_inrange(n)]#初始化......
  • 如何在HTML中使用JavaScript：从基础到高级的全面指南！
    JavaScript是一种轻量级的编程语言，通常用于网页开发，以增强用户界面的交互性和动态性。然而在HTML中，有多种方法可以嵌入和使用JavaScript代码。本文就带大家深入了解如何在HTML中使用JavaScript。一、使用script标签要在HTML中使用JavaScript，我们需要使用<script>标签。这个标......
  • vue3+elementplus+axios+router的入门项目总结
    一、使用vite方式创建项目：1、创建空文件夹，用vscode打开空文件夹，终端上运行如下命令$npminitvite-app[项目名]：初始化项目$cd[项目名]：进入项目$npminstall：安装项目依赖$npmrundev：启动项目2、启动项目后会出现访问地址： 3、进入访问地址： 二、引入elementpuls......

赞助商

阅读排行

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

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

Copyright © 2020-2023 IPS99 版权所有 IPS99