原型设计模式—解决随机乱序出试卷（试题顺序、选项顺序随机打乱）

最新推荐文章于 2024-04-10 22:54:46 发布
最新推荐文章于 2024-04-10 22:54:46 发布
阅读量2.4k 收藏 17
点赞数 2
分类专栏： 设计模式 文章标签： 原型设计模式 设计模式 clone
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41922349/article/details/117957292
版权

原型设计模式

1、实现机制

 

  • 实现机制：

 
       通过实现 Cloneable接口，再重写 clone()方法返回想要的对象。原型模式实现clone接口的时候必须使用深拷贝。
 
       原型模式实际上就是从一个对象再创建另外一个可定制的对象，且无需知道任何创建的细节。在初始化的信息不发生变化的情况下，克隆是最好的办法，既隐藏了对象创建的细节，又大大提高了性能。因为如果不用 clone，每次 new 都需要执行一次构造函数，如果构造函数的执行时间很长，那么多次的执行初始化操作就太低效了。
 

  • 优点：
  • 使用原型模式创建对象比直接new一个对象，在性能上优势明显。因为 Object 类的 clone() 方法是一个本地方法，直接操作内存中的二进制流，特别是复制大对象时，性能的差别非常明显。
  • 使用原型模式可以简化对象的创建，使得创建对象很简单。
  • 逃避构造函数的约束。使用原型模式复制对象不会调用类的构造方法。因为对象的复制是通过调用Object类的clone方法来完成的，它直接在内存中复制数据，因此不会调用到类的构造方法。不但构造方法中的代码不会执行，甚至连访问权限都对原型模式无效。
  • 缺点： 必须实现Cloneable接口。

 

2、使用场景

 

  • 希望以一个对象为原型，创建其他近似的对象的时候。
  • 代码优化场景，该场景在业务中用的比较少。一般结合工厂方法模式使用。
  • 多个调用者使用时，并且需要修改对象中的值，可以考虑原型模式来提供对象。

 

3、使用案例

 

3.1、案例说明

 

以下案例，实现场景为，一个试题库中含选择题和简答题，要求根据每个考生将考题顺序打乱，同时将选择题的选项顺序打乱。

 

3.2、代码结构

在这里插入图片描述

3.3、案例实现

 

3.3.1、实体类

  • 简答题实体类 （EssayQuestion）

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 简答题
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class EssayQuestion {


    /**
     * 题干
     */
    private String questionStem;

    /**
     * 答案
     */
    private String answer;


}
  • 选择题实体类（ChoiceQuestion）

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.HashMap;

/**
 * 选择题
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ChoiceQuestion {

    /**
     * 题干
     */
    private String questionStem;

    /**
     * 选项
     */
    private HashMap<String, String> option;

    /**
     * 答案
     */
    private String key;

}

 

3.3.2、工具类

  • OutOfOrderHelper 类

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.HashMap;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class OutOfOrderHelper {

    /**
     * 选项
     */
    private HashMap<String, String> option;

    /**
     * 答案
     */
    private String key;

}
  • 选择题选项乱序工具类（OutOfOrderUtil ）

import java.util.*;

/**
 * 乱序工具类
 */
public class OutOfOrderUtil {

    /**
     * 乱序Map元素，记录对应答案key
     * @param option 选项
     * @param key    答案
     * @return OutOfOrderHelper 选项乱序后的对象
     */
    public static OutOfOrderHelper random(Map<String, String> option, String key) {
        // 获取所有选项的key值：(例：A、B、C、D)
        Set<String> keySet = option.keySet();
        ArrayList<String> keyList = new ArrayList<String>(keySet);
        // 使用默认随机源对列表进行置换，所有key置换发生的可能性都是大致相等的。
        Collections.shuffle(keyList);
        HashMap<String, String> newOption = new HashMap<>();
        int idx = 0;
        String newKey = "";
        for (String next : keySet) {
            String randomKey = keyList.get(idx++);
            if (key.equals(next)) {
                newKey = randomKey;
            }
            newOption.put(randomKey, option.get(next));
        }
        return new OutOfOrderHelper(newOption, newKey);
    }

}

 

3.3.3、实现类

  • 实现类（ExamHelper），实现 Cloneable类，重写 clone() 方法

import com.prototype.util.OutOfOrderHelper;
import com.prototype.util.OutOfOrderUtil;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Map;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ExamHelper implements Cloneable {

    /**
     * 考生姓名
     */
    private String candidate;

    /**
     * 考号
     */
    private String candidateNumber;


    /**
     * 简答题集合
     */
    private ArrayList<EssayQuestion> essayQuestions = new ArrayList<>();


    /**
     * 问答题集合
     */
    private ArrayList<ChoiceQuestion> choiceQuestions = new ArrayList<>();


    public ExamHelper append(EssayQuestion essayQuestion) {
        this.essayQuestions.add(essayQuestion);
        return this;
    }


    public ExamHelper append(ChoiceQuestion choiceQuestion) {
        this.choiceQuestions.add(choiceQuestion);
        return this;
    }

    /**
     * 复制对象
     *
     * @return
     * @throws CloneNotSupportedException
     */
    @Override
    public Object clone() throws CloneNotSupportedException {
        ExamHelper examHelper = (ExamHelper) super.clone();
        examHelper.choiceQuestions = (ArrayList<ChoiceQuestion>) this.choiceQuestions.clone();
        examHelper.essayQuestions = (ArrayList<EssayQuestion>) this.essayQuestions.clone();
        // 对题目进行乱序处理
        Collections.shuffle(examHelper.essayQuestions);
        Collections.shuffle(examHelper.choiceQuestions);
        // 对每个选择题的选项进行乱序处理
        ArrayList<ChoiceQuestion> choiceQuestionList = examHelper.choiceQuestions;
        choiceQuestionList.forEach(t -> {
            OutOfOrderHelper outOfOrderHelper = OutOfOrderUtil.random(t.getOption(), t.getKey());
            t.setOption(outOfOrderHelper.getOption());
            t.setKey(outOfOrderHelper.getKey());
        });
        return examHelper;
    }

    @Override
    public String toString() {

        StringBuilder detail = new StringBuilder("考生：" + candidate + "\r\n" +
                "考号：" + candidateNumber + "\r\n" +
                "--------------------------------------------\r\n" +
                "一、选择题" + "\r\n\n");

        for (int idx = 0; idx < choiceQuestions.size(); idx++) {
            detail.append("第").append(idx + 1).append("题：").append(choiceQuestions.get(idx).getQuestionStem()).append("\r\n");
            Map<String, String> option = choiceQuestions.get(idx).getOption();
            for (String key : option.keySet()) {
                detail.append(key).append("：").append(option.get(key)).append("\r\n");
                ;
            }
            detail.append("答案：").append(choiceQuestions.get(idx).getKey()).append("\r\n\n");
        }

        detail.append("二、简答题" + "\r\n\n");

        for (int idx = 0; idx < essayQuestions.size(); idx++) {
            detail.append("第").append(idx + 1).append("题：").append(essayQuestions.get(idx).getQuestionStem()).append("\r\n");
            detail.append("答案：").append(essayQuestions.get(idx).getAnswer()).append("\r\n\n");
        }

        return detail.toString();
    }


}
  • ExamMaker 类

import java.util.HashMap;

public class ExamMaker {

    ExamHelper examHelper = new ExamHelper();


    public ExamMaker() {


        HashMap<String, String> option1 = new HashMap<>();
        option1.put("A", "继承自Throwable");
        option1.put("B", "Serialable");
        option1.put("C", "不记得，反正不正确");
        option1.put("D", "Run");


        HashMap<String, String> option2 = new HashMap<>();
        option2.put("A", "class中的constructor不可省略");
        option2.put("B", "constructor必须与class同名，但方法不能与class同名");
        option2.put("C", "constructor在一个对象被new时执行");
        option2.put("D", "一个class只能定义一个constructor");


        examHelper.append(new ChoiceQuestion("下面关于java.lang.Exception类的说法正确的是（）", option1, "A"))
                .append(new ChoiceQuestion("下列说法正确的有（）", option2, "C"));


        examHelper.append(new EssayQuestion("JDBC操作数据库的步骤?",
                "\n" +
                        "1.加载数据库驱动\n" +
                        "2.建立到数据库的连接\n" +
                        "3.定义sql，获取sql执行环境，设置相应的参数\n" +
                        "4.执行sql，处理sql执行结果——DML语句返回int， DQL语句返回结果集对象 ResultSet\n" +
                        "5.释放资源"))
                .append(new EssayQuestion("String，StringBuilder，StringBuffer的区别",
                        "\n" +
                                "1、 String是定长字符串；StringBuilder，StringBuffer是变长字符串\n" +
                                "2、 StringBuilder是线程非安全，一般用于单线程中，执行效率较StringBuffer高，StringBuffer是线程安全的，如果在多个线程中需要同步则采用此类"))
                .append(new EssayQuestion("List和Map的区别",
                        "\n" +
                                "List：是存储单列数据的集合，存储的数据有序且可重复\n" +
                                "Map: 是存储双列数据的集合，采用键值对的形式进行存储，存储的数据是无序的，且key不能重复，但是value值可以重复"));
    }

    /**
     * 创建试卷
     * @param candidate
     * @param candidateNumber
     * @return
     * @throws CloneNotSupportedException
     */
    public String createExam(String candidate, String candidateNumber) throws CloneNotSupportedException {
        ExamHelper examHelperClone = (ExamHelper) examHelper.clone();
        examHelperClone.setCandidate(candidate);
        examHelperClone.setCandidateNumber(candidateNumber);
        return examHelperClone.toString();
    }


}

 

3.3.4、测试类

 


public class ExamTest {

    public static void main(String[] args) {

        ExamMaker examMaker = new ExamMaker();
        try {
            System.out.println(examMaker.createExam("张三", "9527"));
            System.out.println(examMaker.createExam("李四", "9528"));
            System.out.println(examMaker.createExam("王五", "9529"));
            System.out.println(examMaker.createExam("陈六", "9530"));
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

        
    }

}

 

3.3.5、测试结果

 


考生：张三
考号：9527
--------------------------------------------
一、选择题

第1题：下列说法正确的有（）
A：一个class只能定义一个constructor
B：class中的constructor不可省略
C：constructor必须与class同名，但方法不能与class同名
D：constructor在一个对象被new时执行
答案：D

第2题：下面关于java.lang.Exception类的说法正确的是（）
A：继承自Throwable
B：Run
C：不记得，反正不正确
D：Serialable
答案：A

二、简答题

第1题：String，StringBuilder，StringBuffer的区别
答案：
1、 String是定长字符串；StringBuilder，StringBuffer是变长字符串
2、 StringBuilder是线程非安全，一般用于单线程中，执行效率较StringBuffer高，StringBuffer是线程安全的，如果在多个线程中需要同步则采用此类

第2题：List和Map的区别
答案：
List：是存储单列数据的集合，存储的数据有序且可重复
Map: 是存储双列数据的集合，采用键值对的形式进行存储，存储的数据是无序的，且key不能重复，但是value值可以重复

第3题：JDBC操作数据库的步骤?
答案：
1.加载数据库驱动
2.建立到数据库的连接
3.定义sql，获取sql执行环境，设置相应的参数
4.执行sql，处理sql执行结果——DML语句返回int， DQL语句返回结果集对象 ResultSet
5.释放资源


考生：李四
考号：9528
--------------------------------------------
一、选择题

第1题：下列说法正确的有（）
A：constructor在一个对象被new时执行
B：class中的constructor不可省略
C：constructor必须与class同名，但方法不能与class同名
D：一个class只能定义一个constructor
答案：A

第2题：下面关于java.lang.Exception类的说法正确的是（）
A：Run
B：继承自Throwable
C：Serialable
D：不记得，反正不正确
答案：B

二、简答题

第1题：List和Map的区别
答案：
List：是存储单列数据的集合，存储的数据有序且可重复
Map: 是存储双列数据的集合，采用键值对的形式进行存储，存储的数据是无序的，且key不能重复，但是value值可以重复

第2题：JDBC操作数据库的步骤?
答案：
1.加载数据库驱动
2.建立到数据库的连接
3.定义sql，获取sql执行环境，设置相应的参数
4.执行sql，处理sql执行结果——DML语句返回int， DQL语句返回结果集对象 ResultSet
5.释放资源

第3题：String，StringBuilder，StringBuffer的区别
答案：
1、 String是定长字符串；StringBuilder，StringBuffer是变长字符串
2、 StringBuilder是线程非安全，一般用于单线程中，执行效率较StringBuffer高，StringBuffer是线程安全的，如果在多个线程中需要同步则采用此类


考生：王五
考号：9529
--------------------------------------------
一、选择题

第1题：下面关于java.lang.Exception类的说法正确的是（）
A：Run
B：继承自Throwable
C：Serialable
D：不记得，反正不正确
答案：B

第2题：下列说法正确的有（）
A：class中的constructor不可省略
B：constructor必须与class同名，但方法不能与class同名
C：一个class只能定义一个constructor
D：constructor在一个对象被new时执行
答案：D

二、简答题

第1题：JDBC操作数据库的步骤?
答案：
1.加载数据库驱动
2.建立到数据库的连接
3.定义sql，获取sql执行环境，设置相应的参数
4.执行sql，处理sql执行结果——DML语句返回int， DQL语句返回结果集对象 ResultSet
5.释放资源

第2题：String，StringBuilder，StringBuffer的区别
答案：
1、 String是定长字符串；StringBuilder，StringBuffer是变长字符串
2、 StringBuilder是线程非安全，一般用于单线程中，执行效率较StringBuffer高，StringBuffer是线程安全的，如果在多个线程中需要同步则采用此类

第3题：List和Map的区别
答案：
List：是存储单列数据的集合，存储的数据有序且可重复
Map: 是存储双列数据的集合，采用键值对的形式进行存储，存储的数据是无序的，且key不能重复，但是value值可以重复


考生：陈六
考号：9530
--------------------------------------------
一、选择题

第1题：下面关于java.lang.Exception类的说法正确的是（）
A：继承自Throwable
B：Run
C：Serialable
D：不记得，反正不正确
答案：A

第2题：下列说法正确的有（）
A：class中的constructor不可省略
B：constructor必须与class同名，但方法不能与class同名
C：constructor在一个对象被new时执行
D：一个class只能定义一个constructor
答案：C

二、简答题

第1题：JDBC操作数据库的步骤?
答案：
1.加载数据库驱动
2.建立到数据库的连接
3.定义sql，获取sql执行环境，设置相应的参数
4.执行sql，处理sql执行结果——DML语句返回int， DQL语句返回结果集对象 ResultSet
5.释放资源

第2题：String，StringBuilder，StringBuffer的区别
答案：
1、 String是定长字符串；StringBuilder，StringBuffer是变长字符串
2、 StringBuilder是线程非安全，一般用于单线程中，执行效率较StringBuffer高，StringBuffer是线程安全的，如果在多个线程中需要同步则采用此类

第3题：List和Map的区别
答案：
List：是存储单列数据的集合，存储的数据有序且可重复
Map: 是存储双列数据的集合，采用键值对的形式进行存储，存储的数据是无序的，且key不能重复，但是value值可以重复

 
 
 
 
 
 
 
 
.

STRANG-P
关注
  • 2
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java考试打乱题目的顺序util
起風了
12-10 677
/** * 打乱Map元素，记录对应答案key * @param option * 如： * key: value * A: java EE * B: java SE * C: java ME * D: java HE * @param key */ public static void rando
Java考试系统题目和选项乱序实现
Tender&Tough的博客
08-28 2024
学习笔记——日常实现思路 要求：实现每个考生对于一套试卷进行乱序显示。 前提：由于所有考生的试卷是一套，且只有一份数据，并不是每个考生都生成了一份试卷。要想保证每个考生进入考试都看到不一样的顺序，以及要保留考生每次进去之后要与初次进入的乱序结果要一致。 思路：要乱序还要保留原始数据，则需缓存数据，缓存有两个方案： 1、考虑Redis进行缓存每个考生考试的试题和选项乱序顺序数据。 2、在考生开始考试后存储当前考生所有提交...
答题小程序源码题目选项随机打乱功能分析
suncentwl的博客
12-01 348
通过上面的截图我们可以看到，这是在排位PK答题过程中，两个用户在同一房间内进行pk答题，系统出的题目是一样的，但选项的位置被随机打乱了，两个用户看到的选项位置是不同的，这时候就需要用户通过看题、审题然后再做出正确的选项。通过多年的开发经验及实际使用用户的反馈，答题小程序源码完善了题库选项随机打乱功能，该功能的出现有效避免了用户在答题时不经审题、思索而凭机记忆机械化做出选择的弊端。值得注意的是，无论选项位置如何变化，正确的答案不会改变。此功能的推出受到了广大答题小程序用户的一致好评！
LeetCode 刷题汇总——题目序号顺序版
最新发布
seniusen的博客
04-10 639
剑指 Offer——和为 S 的两个数字 剑指 Offer——数字在排序数组中出现的次数 剑指 Offer——和为 S 的连续正数序列 剑指 Offer——最小的 K 个数 剑指 Offer——连续子数组的最大和 剑指 Offer——数组中的逆序对LeetCode 1——两数之和 LeetCode 2——两数相加 LeetCode 3——无重复字符的最长子串 LeetCode 4——两个排序数组中的中位数 LeetCode 5——最长回文子串 LeetCode 10——正则表达式匹配 LeetCode 19
正确的序号及标点使用格式（参考文）
热门推荐
qq_17808401的博客
06-16 1万+
论文格式
重学 Java 设计模式：实战原型模式「上机考试多套试，每人题目和答案乱序排列场景」
bugstack虫洞栈
05-29 3247
作者：小傅哥 博客：https://bugstack.cn 沉淀、分享、成长，让自己和他人都能有所收获！???? 一、前言 老板你加钱我的代码能飞 程序员这份工作里有两种人；一类是热爱喜欢的、一类是仅当成工作的。而喜欢代码编程的这部分人会极其主动学习去丰富自己的羽翼，也非常喜欢对技术探索力求将学到的知识赋能到平时的业务需求开发中。对于这部分小伙伴来说上班写代码还能赚钱真的是幸福！ 怎么成为喜欢编码都那部分人 无论做哪行那业你都喜欢，往往来自从中持续不断都获取成就感。就开发编程而言因为你的一行代码影响到了
PHP设计模式之原型设计模式原理与用法分析
10-18
主要介绍了PHP设计模式之原型设计模式,简单描述了原型设计模式的概念、原理并结合实例形式分析了php原型设计模式的定义与使用方法,需要的朋友可以参考下
设计模式之原型模式.docx
09-28
【设计模式之原型模式】 设计模式是软件工程中的一种最佳实践，是对在特定上下文中反复出现的软件设计问题的解决方案。原型模式属于对象创建型模式，它的主要思想是通过复制已有对象来创建新对象，降低了类的实例化...
ava常用设计模式-原型模式
08-26
ava常用设计模式-原型模式 原型模式（Prototype Pattern）是一种创建型设计模式，允许通过复制现有对象来创建新对象，而不是通过实例化类来创建新对象。在需要创建大量相似对象时非常有用，它可以避免重复创建对象...
c++20设计模式-第4章-原型模式代码
02-05
在C++编程中，设计模式是一种经过验证的解决常见问题的最佳实践。原型模式（Prototype Pattern）是其中一种行为设计模式，它允许我们通过复制现有对象来创建新对象，而不是通过传统方式实例化新对象。这一模式尤其...
题目编号生成器
weixin_30482383的博客
06-12 132
【程序描述】 利用C++随机函数编写了此程序，用于神犇们在各种OI网站上灵活地攻坚克难，检验他们自己的超高水平。 【操作描述】 F11。 【结果描述】 一个洛谷(www.luogu.org)网站中题目的ID编号（可能无此题，请尝试新的输出）。 源代码： #include<cstdio> #include<cstdlib> #incl...
一道试题中备选答案打乱顺序，随机展示，用数组实现
FellowYourHeart的博客
03-13 2632
    今天遇到一个写一个测试题的小项目，测试题是从数据库（试题库）随机抽取的。现在的小需求是，在拿到这道试题之后，备选答案随机展示。    比如这里title是标题，answer01、answer02、answer03、answer04是四个备选项，tureanswer是正确选项的索引，此时就表示第一个属于正确答案。    如果打乱选项顺序，思路是选用数组，将这个四个选项取出来，组成一个数组，找...
C#List随机打乱顺序，List顺序反转
weixin_39667153的博客
03-01 3019
List打乱顺序代码。List顺序反转代码。
打乱数组顺序的三种方法
liNewman的博客
03-16 8320
打乱数组顺序的三种方法 sort排序法（最简单的打乱数组顺序的方法） 原理： 利用sort用法：arr.sort(compareFunction) 如果 compareFunction(a,b) 返回的值大于 0 ，则 b 在 a 的前边； 如果 compareFunction(...
java复习-乱序
LecW
07-04 221
1     解释main方法格式        格式：                public static void main(String[] args){                }                public：被jvm调用。访问权限要足够大                static：被jvm调用，不用创建对象，直接类名访问                void...
java100万乱序文件排序,java实现题目以及选项乱序的方法实例
weixin_29807369的博客
03-14 426
前言在现实生活中，考试是我们的必经之路，但是线上考试总有一部分人抄写答案，为了防止抄写，将题目和答案打乱，防止抄袭。本文实现通过map轮询时将选项乱序，最终答案也变化。选择题类 ChoiceQuestionimport java.util.Map;/*** 单选题*/public class ChoiceQuestion {private String name; // 题目private...
java 乱序算法_Java排序算法
weixin_42133452的博客
02-16 746
Java排序算法1)分类：1)插入排序(直接插入排序、希尔排序)2)交换排序(冒泡排序、快速排序)3)选择排序(直接选择排序、堆排序)4)归并排序5)分配排序(箱排序、基数排序)所需辅助空间最多：归并排序所需辅助空间最少：堆排序平均速度最快：快速排序不稳定：快速排序，希尔排序，堆排序。1)选择排序算法的时候1.数据的规模 ；2.数据的类型 ；3.数据已有的顺序一般来说，当数据规模较小时，应...
随机打乱数组顺序
liangkaihuaen的博客
07-18 951
function randomsort(a, b) { return Math.random() > .5 ? -1 : 1; } this.questionArray.sort(randomsort)

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值