操作系统---实验3---JavaGUI实现进程调度算法仿真（FCFS、SJF、HRRF）

已于 2022-11-20 15:29:06 修改
阅读量1.1k 收藏 20
点赞数 1
分类专栏： # 操作系统实验课 文章标签： java
于 2022-10-29 19:31:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yi_tong_/article/details/127590860
版权

文章目录

  • 实验内容：
    实现的算法：FCFS、SJF、HRRF
  • 程序功能：
    使用Java编写并调试一个模拟的进程调度程序，分别采用FCFS、SJF、HRRF调度算法进行调度，计算出开始时间、结束时间、周转时间、带权周转时间。并使用JavaGUI图形化。
  • 程序流程图：
    在这里插入图片描述
    代码：
package Main;

import java.util.ArrayList;
import java.util.Vector;

import Utils.*;
import UI.*;

public class main {

    public static String flag = "";
    public static ArrayList<PCB> pcbArr = new ArrayList<PCB>();
    public static ArrayList<PCB> rArr = new ArrayList<PCB>();

    public static void main(String[] args) {
        new p_UI().setVisible(true);
    }

    public static void start() {

        if (flag == "先来先服务（FCFS）") {
            rArr = FCFS.FCFS(pcbArr);
        } else if (flag == "最短进程优先（SPF）") {
            rArr = SPF.SPF(pcbArr);
        } else if (flag == "响应比高者优先（HRN）") {
            rArr = HRN.HRN(pcbArr);
        }

        //刷新表格数据
        p_UI.data.clear();

        for (int i = 0; i < rArr.size(); i++) {
            Vector aData = new Vector();
            aData.add(rArr.get(i).id);
            aData.add(rArr.get(i).name);
            aData.add(rArr.get(i).priority);
            aData.add(rArr.get(i).workTime);
            aData.add(rArr.get(i).arriveTime);
            aData.add(rArr.get(i).beginTime);
            aData.add(rArr.get(i).finshTime);
            //计算周转时间和带权周转时间
            rArr.get(i).setTAT(rArr.get(i).getFinshTime() - rArr.get(i).getArriveTime());
            rArr.get(i).setWTAT(rArr.get(i).getTAT() / rArr.get(i).getWorkTime());
            aData.add(rArr.get(i).TAT);
            aData.add(rArr.get(i).WTAT);
            p_UI.data.add(aData);
        }

        //刷新表格
        p_UI.dtm.setDataVector(p_UI.data, p_UI.colName);
        p_UI.table.setModel(p_UI.dtm);
    }

    //撤销执行
    public static void revoke() {

        p_UI.tTAT.setText("");
        p_UI.tWTAT.setText("");
        p_UI.data.clear();

        for (int i = 0; i < pcbArr.size(); i++) {
            Vector aData = new Vector();
            aData.add(pcbArr.get(i).id);
            aData.add(pcbArr.get(i).name);
            aData.add(pcbArr.get(i).priority);
            aData.add(pcbArr.get(i).workTime);
            aData.add(pcbArr.get(i).arriveTime);
            p_UI.data.add(aData);
        }

        p_UI.dtm.setDataVector(p_UI.data, p_UI.colName);
        p_UI.table.setModel(p_UI.dtm);
    }
}

package Main;

public class PCB {
    public int id;            //序号
    public String name;        //进程名
    public int priority;       //优先级
    public double workTime;    //服务时间
    public double arriveTime;  //到达时间
    public double beginTime;   //开始运行时间
    public double finshTime;   //运行结束时间
    public double TAT;         //周转时间
    public double WTAT;        //带权周转时间

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getPriority() {
        return priority;
    }

    public void setPriority(int priority) {
        this.priority = priority;
    }

    public double getWorkTime() {
        return workTime;
    }

    public void setWorkTime(double workTime) {
        this.workTime = workTime;
    }

    public double getArriveTime() {
        return arriveTime;
    }

    public void setArriveTime(double arriveTime) {
        this.arriveTime = arriveTime;
    }

    public double getBeginTime() {
        return beginTime;
    }

    public void setBeginTime(double beginTime) {
        this.beginTime = beginTime;
    }

    public double getFinshTime() {
        return finshTime;
    }

    public void setFinshTime(double finshTime) {
        this.finshTime = finshTime;
    }

    public double getTAT() {
        return TAT;
    }

    public void setTAT(double tAT) {
        TAT = tAT;
    }

    public double getWTAT() {
        return WTAT;
    }

    public void setWTAT(double wTAT) {
        WTAT = wTAT;
    }

    public PCB() {
    }

    public PCB(int id, String name, double arrivetime, double workTime, int priority) {
        setId(id);
        setName(name);
        setArriveTime(arrivetime);
        setWorkTime(workTime);
        setPriority(priority);
    }
}

package UI;

import javax.swing.*;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.DefaultTableModel;
import java.awt.*;
import java.awt.event.*;
import java.util.Vector;

import Main.*;

public class p_UI extends JFrame {

    public static Vector data = new Vector(); //存放进程信息
    public static Vector colName = new Vector();
    public static DefaultTableModel dtm = new DefaultTableModel();
    public static JTable table = new JTable();
    public static JLabel tTAT = new JLabel("");
    public static JLabel tWTAT = new JLabel("");

    public p_UI() {

        super("进程调度模拟");

        int WIDTH = 720;
        int HEIGHT = 540;
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        this.setBounds((int) (screenSize.getWidth() - WIDTH) / 2, (int) (screenSize.getHeight() - HEIGHT) / 2, WIDTH, HEIGHT);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        init();
    }

    public void init() {

        JPanel P = new JPanel();
        P.setLayout(null);
        JScrollPane table = new JScrollPane(setTable());
        table.setBounds(3, 150, 700, 350);

        P.add(setPage());
        P.add(table);

        this.add(P);
    }

    //设置页面
    public JPanel setPage() {

        JPanel jp = new JPanel();
        jp.setBounds(0, 0, 700, 150);
        jp.setLayout(null);

        JLabel id = new JLabel("序号：");
        id.setBounds(10, 30, 40, 30);
        jp.add(id);

        JTextField idT = new JTextField();
        idT.setBounds(45, 30, 60, 30);
        jp.add(idT);

        JLabel name = new JLabel("进程名：");
        name.setBounds(115, 30, 60, 30);
        jp.add(name);

        JTextField nameT = new JTextField();
        nameT.setBounds(165, 30, 60, 30);
        jp.add(nameT);

        JLabel priority = new JLabel("优先级：");
        priority.setBounds(235, 30, 60, 30);
        jp.add(priority);

        JTextField priorityT = new JTextField();
        priorityT.setBounds(285, 30, 60, 30);
        jp.add(priorityT);

        JLabel workTime = new JLabel("服务时间：");
        workTime.setBounds(355, 30, 70, 30);
        jp.add(workTime);

        JTextField workTimeT = new JTextField();
        workTimeT.setBounds(415, 30, 60, 30);
        jp.add(workTimeT);

        JLabel arriveTime = new JLabel("到达时间：");
        arriveTime.setBounds(485, 30, 70, 30);
        jp.add(arriveTime);

        JTextField arriveTimeT = new JTextField();
        arriveTimeT.setBounds(545, 30, 60, 30);
        arriveTimeT.addKeyListener(new KeyAdapter() {
            @Override
            //enter 添加事件
            public void keyPressed(KeyEvent e) {
                int keyCode = e.getKeyCode();
                if (e.getKeyChar() == KeyEvent.VK_ENTER) {
                    String id = idT.getText();
                    idT.setText("");
                    String name = nameT.getText();
                    nameT.setText("");
                    String priority = priorityT.getText();
                    priorityT.setText("");
                    String arriveTime = arriveTimeT.getText();
                    arriveTimeT.setText("");
                    String workTime = workTimeT.getText();
                    workTimeT.setText("");

                    //传递进程信息到main的执行程序
                    int idInt = Integer.parseInt(id);
                    int priorityInt = Integer.parseInt(priority);
                    double arriveTimeInt = Double.parseDouble(arriveTime);
                    double workTimeInt = Double.parseDouble(workTime);
                    main.pcbArr.add(new PCB(idInt, name, arriveTimeInt, workTimeInt, priorityInt));

                    //传递进程信息到表格显示
                    Vector aData = new Vector();//一行表格信息
                    aData.add(id);
                    aData.add(name);
                    aData.add(priority);
                    aData.add(workTime);
                    aData.add(arriveTime);
                    data.add(aData);
                    dtm.setDataVector(data, colName);
                    table.setModel(dtm);
                }
            }
        });
        jp.add(arriveTimeT);

        JButton add = new JButton("添加");
        add.setBounds(625, 30, 80, 30);
        add.setBackground(new Color(202, 204, 209));
        add.setBorderPainted(true);
        add.setFocusPainted(false);
        add.addMouseListener(new MouseListener() {
            @Override
            public void mouseClicked(MouseEvent e) {
                String id = idT.getText();
                idT.setText("");
                String name = nameT.getText();
                nameT.setText("");
                String priority = priorityT.getText();
                priorityT.setText("");
                String arriveTime = arriveTimeT.getText();
                arriveTimeT.setText("");
                String workTime = workTimeT.getText();
                workTimeT.setText("");

                //传递进程信息到main的执行程序
                int idInt = Integer.parseInt(id);
                int priorityInt = Integer.parseInt(priority);
                double arriveTimeInt = Double.parseDouble(arriveTime);
                double workTimeInt = Double.parseDouble(workTime);
                main.pcbArr.add(new PCB(idInt, name, arriveTimeInt, workTimeInt, priorityInt));

                //传递进程信息到表格显示
                Vector aData = new Vector();//一行表格信息
                aData.add(id);
                aData.add(name);
                aData.add(priority);
                aData.add(workTime);
                aData.add(arriveTime);
                data.add(aData);
                dtm.setDataVector(data, colName);
                table.setModel(dtm);
            }

            @Override
            public void mousePressed(MouseEvent e) {
            }

            @Override
            public void mouseReleased(MouseEvent e) {
            }

            @Override
            public void mouseEntered(MouseEvent e) {
            }

            @Override
            public void mouseExited(MouseEvent e) {
            }
        });
        jp.add(add);


        JLabel aTAT = new JLabel("平均周转时间：");
        aTAT.setBounds(10, 90, 100, 30);
        jp.add(aTAT);

        tTAT.setBounds(100, 90, 50, 30);
        jp.add(tTAT);

        JLabel aWTAT = new JLabel("平均带权周转时间：");
        aWTAT.setBounds(150, 90, 125, 30);
        jp.add(aWTAT);

        tWTAT.setBounds(265, 90, 50, 30);
        jp.add(tWTAT);

        JComboBox type = new JComboBox();
        type.addItem("先来先服务（FCFS）");
        type.addItem("最短进程优先（SPF）");
        type.addItem("响应比高者优先（HRN）");
        type.setBounds(360, 90, 180, 30);
        jp.add(type);

        JButton start = new JButton("执行");
        start.setBounds(555, 90, 70, 30);
        start.setBackground(new Color(202, 204, 209));
        start.setBorderPainted(true);
        start.setFocusPainted(false);
        start.addMouseListener(new MouseListener() {
            @Override
            public void mouseClicked(MouseEvent e) {
                main.flag = (String) type.getSelectedItem();
                main.start();
                double aveTAT = 0;
                double aveWTAT = 0;
                for (int i = 0; i < data.size(); i++) {
                    aveTAT += main.rArr.get(i).TAT;
                    aveWTAT += main.rArr.get(i).WTAT;
                }
                aveTAT /= data.size();
                aveWTAT /= data.size();
                tTAT.setText(String.valueOf(aveTAT));
                tWTAT.setText(String.valueOf(aveWTAT));
            }

            @Override
            public void mousePressed(MouseEvent e) {
            }

            @Override
            public void mouseReleased(MouseEvent e) {
            }

            @Override
            public void mouseEntered(MouseEvent e) {
            }

            @Override
            public void mouseExited(MouseEvent e) {
            }
        });
        jp.add(start);

        JButton back = new JButton("撤销");
        back.setBounds(625, 90, 70, 30);
        back.setBackground(new Color(202, 204, 209));
        back.setBorderPainted(true);
        back.setFocusPainted(false);
        back.addMouseListener(new MouseListener() {
            @Override
            public void mouseClicked(MouseEvent e) {
                main.revoke();
            }

            @Override
            public void mousePressed(MouseEvent e) {
            }

            @Override
            public void mouseReleased(MouseEvent e) {
            }

            @Override
            public void mouseEntered(MouseEvent e) {
            }

            @Override
            public void mouseExited(MouseEvent e) {
            }
        });
        jp.add(back);

        return jp;
    }

    //信息表格
    public JTable setTable() {

        colName.add("序号");
        colName.add("进程名");
        colName.add("优先级");
        colName.add("服务时间");
        colName.add("到达时间");
        colName.add("开始运行时间");
        colName.add("结束运行时间");
        colName.add("周转时间");
        colName.add("带权周转时间");

        //设置表格文字居中
        DefaultTableCellRenderer tcr = new DefaultTableCellRenderer();
        tcr.setHorizontalAlignment(JLabel.CENTER);
        table.setDefaultRenderer(Object.class, tcr);

        dtm.setDataVector(data, colName);
        table.setModel(dtm);

        return table;
    }
}

package Utils;

import Main.PCB;
import java.util.ArrayList;
import java.util.Collections;

public class FCFS {

    //先来先服务算法（FCFS）
    public static ArrayList<PCB> FCFS(ArrayList<PCB> PCBArr) {

        //根据到达时间将输入队列排序，同时到达的进程根据序号排序
        for(int i=0;i<PCBArr.size();i++) {
            for(int j=i+1;j<PCBArr.size();j++) {
                if(PCBArr.get(i).getArriveTime()>PCBArr.get(j).getArriveTime()) {
                    Collections.swap(PCBArr, i, j);
                }
            }
        }

        //复制原PCB数组
        ArrayList<PCB> tempArr = PCBArr;
        //存储结果数组
        ArrayList<PCB> workArr = new ArrayList<PCB>();
        for(PCB p : tempArr) {
            if(workArr.size() == 0){    //执行第一个进程
                p.setBeginTime(p.getArriveTime());
                p.setFinshTime(p.getBeginTime()+p.getWorkTime());
            } else {
                p.setBeginTime(workArr.get(workArr.size()-1).getFinshTime());
                p.setFinshTime(p.getBeginTime()+p.getWorkTime());
            }
            workArr.add(p);
        }

        return workArr;
    }
}

package Utils;

import Main.PCB;

import java.util.ArrayList;

public class HRN {

    //响应比高者优先（HRN）算法，响应比 =（等待时间 + 工作时间）/ 工作时间
    public static ArrayList<PCB> HRN(ArrayList<PCB> PCBArr) {

        //由于刚开始多个进程如果同时第一个到达，其响应比都为1，所以不做判断，只根据到达时间获取第一个到达的进程
        PCB first;
        first = PCBArr.get(0);
        for (int i = 0; i < PCBArr.size(); i++) {
            if (first.getArriveTime() > PCBArr.get(i).getArriveTime()) {
                first = PCBArr.get(i);
            }
        }

        //复制原PCB数组
        ArrayList<PCB> tempArr = new ArrayList<PCB>();
        for (int i = 0; i < PCBArr.size(); i++) {
            tempArr.add(PCBArr.get(i));
        }

        //第一个进入工作队列中
        ArrayList<PCB> workArr = new ArrayList<PCB>();    //存储结果数组
        workArr.add(first);
        workArr.get(0).setBeginTime(first.getArriveTime());
        workArr.get(0).setFinshTime(first.getArriveTime() + first.getWorkTime());

        //删除已经进入工作队列的第一个进程的PCB
        tempArr.remove(first);

        //剩下的进程通过响应比高者优先调度算法依次进入工作队列
        while (!tempArr.isEmpty()) {
            ArrayList<PCB> temp = new ArrayList<PCB>();
            double lastFinshTime = workArr.get(workArr.size() - 1).getFinshTime();

            //筛选出在上一个进程结束前到达的进程放入temp数组
            for (PCB p : tempArr) {
                if (p.getArriveTime() < lastFinshTime) {
                    temp.add(p);
                }
            }

            if (temp.isEmpty()) {
                for (PCB p : tempArr)
                    temp.add(p);
            }

            //筛选出temp数组中响应比最高的进程first2
            PCB first2;
            first2 = temp.get(0);

            //记录当前first2指定进程的响应比
            double largeHrn = ((workArr.get(workArr.size() - 1).getFinshTime() - first2.getArriveTime()) + first2.getWorkTime()) / first2.getWorkTime();

            for (int i = 0; i < temp.size(); i++) {
                double hrn = ((workArr.get(workArr.size() - 1).getFinshTime() - temp.get(i).getArriveTime()) + temp.get(i).getWorkTime()) / temp.get(i).getWorkTime();
                if (largeHrn < hrn) {
                    largeHrn = hrn;
                    first2 = temp.get(i);
                }
            }

            //将first2对应进程放入工作队列并运行，同时在临时复制的PCB（tempArr)中删除该进程的PCB
            first2.setBeginTime(lastFinshTime);
            first2.setFinshTime(first2.getBeginTime() + first2.getWorkTime());
            workArr.add(first2);
            tempArr.remove(first2);
        }
        return workArr;
    }
}

package Utils;

import Main.PCB;

import java.util.ArrayList;

public class SPF {

    //最短进程优先算法（SPF）
    public static ArrayList<PCB> SPF(ArrayList<PCB> PCBArr) {

        //根据到达时间获取第一个到达并且服务时间较短的进程
        PCB first;
        first = PCBArr.get(0);
        for (int i = 0; i < PCBArr.size(); i++) {
            if (first.getArriveTime() == PCBArr.get(i).getArriveTime()) {
                if (first.getWorkTime() > PCBArr.get(i).getWorkTime()) {
                    first = PCBArr.get(i);
                }
            } else if (first.getArriveTime() > PCBArr.get(i).getArriveTime()) {
                first = PCBArr.get(i);
            }
        }

        //复制原PCB数组
        ArrayList<PCB> tempArr = new ArrayList<PCB>();
        for (int i = 0; i < PCBArr.size(); i++) {
            tempArr.add(PCBArr.get(i));
        }

        //第一个进入工作队列中
        ArrayList<PCB> workArr = new ArrayList<PCB>();  //存储结果数组
        workArr.add(first);
        workArr.get(0).setBeginTime(first.getArriveTime());
        workArr.get(0).setFinshTime(first.getArriveTime() + first.getWorkTime());

        //删除已经进入工作队列的第一个进程的PCB
        tempArr.remove(first);

        //剩下的进程通过最短进程优先调度算法依次进入工作队列
        while (!tempArr.isEmpty()) {
            ArrayList<PCB> temp = new ArrayList<PCB>();
            double lastFinshTime = workArr.get(workArr.size() - 1).getFinshTime();

            //筛选出在上一个进程结束前到达的进程放入temp数组
            for (PCB p : tempArr) {
                if (p.getArriveTime() < lastFinshTime) {
                    temp.add(p);
                }
            }

            if (temp.isEmpty()) {
                for (PCB p : tempArr)
                    temp.add(p);
            }

            //筛选出temp数组中最短的进程first2
            PCB first2;
            first2 = temp.get(0);
            for (int i = 0; i < temp.size(); i++) {
                if (first2.getWorkTime() > temp.get(i).getWorkTime())
                    first2 = temp.get(i);
            }

            //将first2对应进程放入工作队列并运行，同时在临时复制的PCB（tempArr)中删除该进程的PCB
            first2.setBeginTime(lastFinshTime);
            first2.setFinshTime(first2.getBeginTime() + first2.getWorkTime());
            workArr.add(first2);
            tempArr.remove(first2);
        }
        return workArr;
    }
}
小星星xx
关注
  • 1
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
随机点名-认识新同学JAVA GUI系统
07-23
有图、有详细的设计报告稳定，有图，可以替换增加图片，进行点击按钮点名，非常好的练手JAVA GUI系统，也可以作为JAVA 课程设计。
JQuantum:Java的量子计算库
04-27
JQuantum Java的量子计算库 Quantum.java是一个量子计算仿真框架，旨在使Java程序员易于访问和理解。 它可以与经典计算Java代码一起运行。 该库有效地运行了产生精确量子结果所需的所有数学运算。 我打算让尽可能多的程序员能够自己利用这一计算领域，并能够理解这种技术的可能性。 当然，该库无法在极端规模上运行，并且无法在与理论量子计算机相当的时间内解决问题。 这种仿真器的优点是可重复的实验，极高的可靠性，可扩展性，甚至有可能无法在实际的量子硬件上进行操作。 而且，它更易于访问，并且以程序员的语言而不是物理学家的语言编写。 这不是火箭科学，只是量子物理学 您可能已经听说量子计算允许qubit同时处于0状态和1状态。 它实际上比听起来还酷。 它们不仅可以同时处于两种状态，而且整个量子计算机可以同时处于1和0的所有可能组合中，并且这些状态（称为基态）中的每一个都有一个系数
JAVA操作系统实验进程调度图形化模拟程序
01-10
是一个模拟进程调度过程的操作系统程序，采用JAVA16编写，有图形化界面GUI。该程序包含先进先出算法、短进程优先算法和响应比高者优先算法，需要其他算法可以下载我的另一个作业调度资源
进程调度的设计与实现图形界面c++ mfc实现
10-15
使用vs2010实现进程调度的设计，并通过pcb读取进程的状态信息，非常适合初学者了解进程调度和进程控制块。
RIP-Simulator:Java中距离矢量路由算法的网络仿真
05-11
RIP模拟器 拉斐特学院CS305 2018年Spring。 RIP使用的Java中距离矢量路由算法的简单网络仿真。 建立模拟 使用随附的Makefile构建项目，如下所示： $ make compile 运行模拟 要运行模拟，请使用以下命令初始化多个路由器 $ java Router [-reverse] configFile 然后通过命令行与路由器进行交互。 路由器还将自动向其邻居定期发送更新。 作者 执照 非商业用途，仅用于教育用途。 除非有书面授权。
Java实现操作系统进程调度模拟程序+GUI图形化
LambBlog
01-10 2256
0、资源下载链接：csdn资源下载 一、 设计要求 编写并调试一个模拟的进程调度程序，采用采用分别先来先服务（FCFS），以及最短进程优先（SPF）、响应比高者优先（HRN）的调度算法进行调度。 二、 运行环境 此程序运行于Java 16.0.2 环境中，在windows系统 三、 系统功能 模拟多进程的调度，本程序采用了可选择先来先服务算法、最短进程优先算法和响应比高者算法进行调度。 用户使用模拟功能前先输入自定义的进程信息包括：序号、进程名、优先级、服务时间和到达时间。然后通过选择框选择需要使用的调度算
操作系统实验—进程调度算法（java）
weixin_55743328的博客
12-18 3451
模拟进程调度的5个算法：FCFS、SJF、RR、PR(动态)、HRRN
JAVA操作系统实验作业调度图形化模拟程序
01-10
是一个模拟作业调度过程的操作系统程序，采用JAVA16编写，有图形化界面GUI。该程序包含先进先出算法、优先级优先算法和简单轮转法算法，需要其他算法可以下载我的另一个进程调度资源
基于Java Swing 可视化模拟进程调度（代码开源）
qq_53574266的博客
10-29 1393
Java Swing 可视化实现模拟进程调度、项目讲解、代码开源。
基于Java实现单处理器系统的进程调度
毕业作品网站
07-14 1211
明确陈述说明程序设计的任务，强调的是程序要做什么，主要包括：输入的形式和输入值的范围；输入形式是键盘输入和鼠标输入，键盘输入值的范围是[0,10]的整数，鼠标输入的选择有确认、四种调度算法（时间片轮转调度、优先数调度、最短进程优先调度和最短剩余时间调度优先调度）、开始模拟、清空和退出。输出的形式；输出的形式为java图形界面显示。根据输入模拟进程调度，输出由动态面板显示出来。程序所能达到的功能；创建进程，模拟四种调度算法，通过图形界面动态显示过程与结果。清空前一次的模拟结果。测试数据：包括正确的输入及其输出
基于MATLAB-GUI的电机仿真管理系统-PPT课件.ppt
11-20
基于MATLAB-GUI的电机仿真管理系统-PPT课件.ppt
基于Q-Learing的路径规划MATLAB仿真系统自测
03-06
使用Q-Learing算法实现任意障碍物环境下的路径规划，可任意选择起点和目标。本套程序适合算法初学者和进阶学习，也可以学习到matlab GUI界面相关开发知识。可在此基础上进行算法改进，发表相关学术论文等。
进程调度的设计与实现（有GUI） java
06-05
进程调度的设计与实现（有GUI） java
java-laboratory-gui:java 实验室 programmin gui sqlite
06-15
java-实验室-gui java 实验室程序 gui / #sqlite #database
C#(C Sharp)学习笔记_类【十五】
追求细节，成就完美
05-01 384
类（Class）是面向对象程序设计（OOP，Object-Oriented Programming）实现信息封装的基础。类是一种用户定义的引用数据类型，也称类类型。每个类包含数据说明和一组操作数据或传递消息的函数。类的实例称为对象。
Spring Cloud——LoadBalancer
最新发布
????
05-01 1497
这里只是简单的讲解了一下LoadBalancer如何使用，因为实际上我们使用的不是很多，主要还是使用OpenFeign。
链表刷题集
yajunjiao的专栏
04-30 533
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
d15(136-148)-勇敢开始Java，咖啡拯救人生
m0_73459387的博客
04-28 1129
对象哈希值的特点：同一个对象调用hashCode()返回的哈希值相同；HashMap的键依赖hashCode方法和equals方法保证键的唯一，存储自定义类型的对象时，重写这两个方法。实际上，Set系列集合的底层就是基于Map实现的，只是Set集合中的元素要键数据，不要值数据。当12个位置都占满时就会扩容，大约扩容为原来的二倍，再把原数组数据转移到新数组。使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误。基于哈希表实现，每个键值对额外多了一个双链表的机制，记录元素顺序（保证。
Java解决最长公共前缀
无人罪的博客
04-28 435
编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串""。
通过javaGUI实现进程调度的短进程优先调度算法具体代码
06-10
这个示例代码基于Java Swing库创建一个GUI，并实现了短进程优先调度算法。用户可以通过界面添加进程和对应的短程时间，然后点击“Compute SJF”按钮计算结果。结果将显示在文本区域中，包括每个进程的等待时间和周转...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值