Java 大学餐厅排队的建模

以下是限制条件： 这家餐厅每天早上6点到晚上11点59分营业（因此营业时间为360分钟）

平均每5分钟就有一位顾客到达餐厅。（因此，一分钟内有20%的机会成为客户。）

餐厅需要2到7分钟来填写客户订单，而且因为整个餐厅只有一个人经营，所以排队的下一位客户只有在将食物提供给前一位客户之后才能获得服务

尽管餐厅试图按照每个人的进餐顺序为他们提供服务，但一些群体的人却被优先考虑。高年级学生将在低年级学生之前接受服务；二年级之前的三年级学生；大二学生比大一学生先

到目前为止，我已经使用Java优先级队列和映射实现了下面的代码。我试图在每位顾客进来时（从360岁起）和他们的等级识别他们。但是，这是我第一次使用优先级队列和映射，我不太确定我是否做对了事实上，它在下面返回了这个错误，尽管我查阅了API和其他一些java资源，但我不确定如何修复这个错误：

线程“main”java.lang.ClassCastException中的异常：java.base/java.util.AbstractMap$SimpleEntry不能强制转换为java.base/java.lang.Compariable

import java.util.*；
导入java.util.PriorityQueue；
导入java.util.Comparator；
导入java.util.Map；
类CustomerComparator实现Comparator
{
公共整数比较（客户c1、客户c2）
{
如果（c1级c2级）
返回-1；
其他的
返回0；
}
}
类客户
{
公共内部评级；
公共双等待时间；
公共客户（整数级，双等待时间）
{
这个。等级=等级；
this.waitingTime=waitingTime；
}
public int getGrade（）
{
返回等级；
}
公共双getWaitingTime（）
{
返回等待时间；
}
}
公营餐馆优先
{
public static Queue Restaurant=new PriorityQueue（）；
公共静态int waitingTime=2+（int）（Math.random（）*（（7-2）+1））；
公共静态void main（字符串[]args）
{
餐馆优先权（）；
}
公共静态无效餐厅优先级（）
{
双随机数=0.0；
布尔值newCustomer=false；
对于（int i=360；i=0.0&&rand<0.2）
newCustomer=true；
其他的
newCustomer=false；
if（新客户）
{
int等级=0；
double rand2=Math.random（）；
如果（rand>=0.0&&rand<0.25）
等级=1；
否则如果（兰德>=0.25&&兰德<0.5）
等级=2；
如果（rand>=0.5&&rand
公共类餐厅优先权{
public static Queue Restaurant=new PriorityQueue（new customer comparator（））；
公共静态int waitingTime=2+（int）（Math.random（）*（（7-2）+1））；
公共静态void main（字符串[]args）{
餐馆优先权（）；
}
公共静态无效餐厅优先级（）{
双随机数=0.0；
布尔值newCustomer=false；
对于（int i=360；i<1440；i++）{
if（Restaurant.isEmpty（））{
waitingTime=2+（int）（Math.random（）*（（7-2）+1））；
}
如果（i==1439）{
而（！Restaurant.isEmpty（））{
等待时间--；
如果（waitingTime==0）{
删除（）；
waitingTime=2+（int）（Math.random（）*（（7-2）+1））；
}
System.out.println（i+“：”+餐厅）；
i++；
}
}
rand=Math.random（）；
如果（rand>=0.0&&rand<0.2）{
newCustomer=true；
}否则{
newCustomer=false；
}
if（新客户）{
int等级=0；
double rand2=Math.random（）；
如果（rand>=0.0&&rand<0.25）{
等级=1；
}否则如果（兰德>=0.25&&兰德<0.5）{
等级=2；
}否则如果（兰德>=0.5&&兰德<0.75）{
等级=3；
}否则{
等级=4；
}
添加（新客户（等级，i））；
}
如果（！Restaurant.isEmpty（））{
等待时间--；
如果（waitingTime==0）{
poll（）；
}
}
如果（！Restaurant.isEmpty（）&&waitingTime==0）{
waitingTime=2+（int）（Math.random（）*（（7-2）+1））；
}
如果（i<1439）{
System.out.println（i+“：”+餐厅）；
}
}
}}
您希望将客户保存在队列而不是映射中。要让优先级队列知道如何对其排序，您需要为其提供一个比较器。
另一个更优雅的解决方案可能是使用Random类而不是Math.Random（）。Random可以为您提供具有定义上限的整数。此外，您不需要命名的比较器

另外，请尝试使用java命名约定

公共静态void RestaurantPriority（）{
随机=新随机（）；
队列客户=新优先级队列（Comparator.comparingit（o->o.grade））；
双重服务时间=0；
对于（int i=360；i<1440；i++）{
如果（servingTime）在创建PriorirtQueue时，请使用实现Comparable的对象创建。否则，请在PriorityQueue构造函数中传递comparator对象。在代码中，为什么有Customer类和CustomerComparator类？
Queue Restaurant=new PriorityQueue（new CustomerComparator（））
看一下PriorityQueue-哦，我不太明白这一点，谢谢！但是，我一直在跑的一个问题是，如果有人已经在排队，但不是高年级学生，然后出现了一个新的高年级客户，高年级学生会首先得到服务，甚至在现有学生的等待时间还没有到之前。并且
public class RestaurantPriority {

public static Queue<Customer> Restaurant = new PriorityQueue<Customer>(new CustomerComparator());
public static int waitingTime = 2 + (int) (Math.random() * ((7 - 2) + 1));

public static void main(String[] args) {
    RestaurantPriority();
}

public static void RestaurantPriority() {
    double rand = 0.0;
    boolean newCustomer = false;
    for (int i = 360; i < 1440; i++) {
        if (Restaurant.isEmpty()) {
            waitingTime = 2 + (int) (Math.random() * ((7 - 2) + 1));
        }
        if (i == 1439) {
            while (!Restaurant.isEmpty()) {
                waitingTime--;
                if (waitingTime == 0) {
                    Restaurant.remove();
                    waitingTime = 2 + (int) (Math.random() * ((7 - 2) + 1));
                }
                System.out.println(i + ": " + Restaurant);
                i++;
            }
        }
        rand = Math.random();
        if (rand >= 0.0 && rand < 0.2) {
            newCustomer = true;
        } else {
            newCustomer = false;
        }
        if (newCustomer) {
            int grade = 0;
            double rand2 = Math.random();
            if (rand >= 0.0 && rand < 0.25) {
                grade = 1;
            } else if (rand >= 0.25 && rand < 0.5) {
                grade = 2;
            } else if (rand >= 0.5 && rand < 0.75) {
                grade = 3;
            } else {
                grade = 4;
            }
            Restaurant.add(new Customer(grade, i));
        }

        if (!Restaurant.isEmpty()) {
            waitingTime--;
            if (waitingTime == 0) {
                Restaurant.poll();
            }
        }
        if (!Restaurant.isEmpty() && waitingTime == 0) {
            waitingTime = 2 + (int) (Math.random() * ((7 - 2) + 1));
        }
        if (i < 1439) {
            System.out.println(i + ": " + Restaurant);
        }
    }
}}

    public static void RestaurantPriority() {
        Random random = new Random();
        Queue<Customer> customers = new PriorityQueue<>(Comparator.comparingInt(o -> o.grade));
        double servingTime = 0;
        for (int i = 360; i < 1440; i++) {
            if(servingTime <= 0 && !customers.isEmpty()){
                servingTime = customers.poll().waitingTime;
            }
            if (random.nextDouble()<0.20) {
                customers.add(new Customer(
                    random.nextInt(4),
                    random.nextInt(5)+2)
                );
            }
            servingTime--;
        }
    }