Java 为什么可以'；我不能比较两个哈希映射吗

在我的代码中，我需要有一个包含两个值的队列，我将它们作为键和值存储在HashMap中。但当我将地图放入队列时，会出现以下异常：

Exception in thread "main" java.lang.ClassCastException: java.util.HashMap cannot be cast to java.lang.Comparable
        at java.util.PriorityQueue.siftUpComparable(Unknown Source)
        at java.util.PriorityQueue.siftUp(Unknown Source)
        at java.util.PriorityQueue.offer(Unknown Source)
        at java.util.PriorityQueue.add(Unknown Source)
        at com.n2s.StringsPractise.Prime.primeCheck(Prime.java:32)
        at com.n2s.StringsPractise.Randomizer.main(Randomizer.java:22)

下面是我的代码的说明，然后是代码本身：

Randomizer的工作是生成一系列正随机整数，并通过分布式整数队列将其发送给Prime。 Primes的任务是接收整数，计算整数是否为素数，并通过包含原始数字和布尔值的分布式队列（仅为java队列实现，无需实现JMS等）将答案返回给Randomizer；哪个随机发生器将打印到系统输出

随机化器类：

    public class Randomizer{

    static Queue<Integer> q = new PriorityQueue<Integer>(); 
    public static Queue<Integer> randomGenerate(){
        int num = 0;
        Random rand = new Random();
        for(int k = 0; k < 10; k++){
        num = rand.nextInt(Integer.MAX_VALUE);
        q.add(num);
        num = 0;
        }
        return q;
    }
    public static void main(String[] args){
        Queue<HashMap<Integer, String>> outQ = Prime.primeCheck(randomGenerate());
        System.out.println(outQ);}
    }
}

公共类随机化器{
静态队列q=new PriorityQueue（）；
公共静态队列随机生成（）{
int num=0；
Random rand=新的Random（）；
对于（int k=0；k<10；k++）{
num=rand.nextInt（整数.MAX_值）；
q、 添加（num）；
num=0；
}
返回q；
}
公共静态void main（字符串[]args）{
Queue outQ=Prime.primeCheck（randomGenerate（））；
System.out.println（outQ）；}
}
}

基本类：

public class Prime{
    Randomizer rn = new Randomizer();
    static HashMap<Integer, String> map = new HashMap<Integer, String>();
    static Queue<HashMap<Integer, String>> primeQ = new PriorityQueue<HashMap<Integer, String>>();

    public static Queue<HashMap<Integer, String>> primeCheck(Queue<Integer> q){
            boolean flag = false;
            Iterator<Integer> itr = q.iterator();
                while(itr.hasNext()){
                    int item = (int) itr.next();
                    int srt = (int) Math.sqrt((double) item);
                    if (item==1) {
                            flag = true;
                        } else{
                        for(int i=2;i<=srt;i++){

                            if(item % i == 0) flag = false;          
                        }
                        flag =  true;
                        }
                    if(flag == true)
                    map.put(item, "Prime");
                    else map.put(item, "Not Prime");

                    primeQ.add(map);

                }
                return primeQ;              
            }
}

公共类素数{
随机发生器rn=新随机发生器（）；
静态HashMap map=newhashmap（）；
静态队列primeQ=new PriorityQueue（）；
公共静态队列primeCheck（队列q）{
布尔标志=假；
迭代器itr=q.Iterator（）；
while（itr.hasNext（））{
int item=（int）itr.next（）；
int srt=（int）Math.sqrt（（双）项）；
如果（项目==1）{
flag=true；
}否则{
对于（int i=2；i，您的问题是PriorityQueue试图比较两个哈希映射，但它们没有进行比较的有效方法

我建议您使用如下值持有者类：

public class Value implements Comparable<Value> {

    int item;
    boolean isPrime;

    public Value(int item, boolean isPrime) {
        this.item = item;
        this.isPrime = isPrime;
    }

    @Override
    public int compareTo(Value o) {
        if (o == null) {
            return 1;
        }
        return this.item - o.item;
    }

    @Override
    public String toString() {
        return "Value{" + "item=" + item + ", isPrime=" + isPrime + '}';
    }
}

公共类值实现可比较{
国际项目；
布尔互质；
公共值（整数项，布尔值）{
this.item=项目；
this.isPrime=isPrime；
}
@凌驾
公共整数比较（值o）{
如果（o==null）{
返回1；
}
返回此.item-o.item；
}
@凌驾
公共字符串toString（）{
返回“Value{”+“item=“+item+”，isPrime=“+isPrime+'}”；
}
}

然后，您的整个代码将如下所示：（我冒昧地清理了它并修复了您的逻辑问题，正如我在对您的问题的评论中所提到的）

公共类DLH{
公共静态void main（字符串[]args）{
随机发生器ran=新随机发生器（）；
Queue outQ=new Prime（）.primeCheck（ran.randomGenerate（））；
系统输出打印项次（outQ）；
}
私有静态类值实现可比较{
国际项目；
布尔互质；
公共值（整数项，布尔值）{
this.item=项目；
this.isPrime=isPrime；
}
@凌驾
公共整数比较（值o）{
如果（o==null）{
返回1；
}
返回此.item-o.item；
}
@凌驾
公共字符串toString（）{
返回“Value{”+“item=“+item+”，isPrime=“+isPrime+'}”；
}
}
私有静态类素数{
Queue primeQ=new PriorityQueue（）；
公共队列primeCheck（队列q）{
布尔标志；
迭代器itr=q.Iterator（）；
while（itr.hasNext（））{
价值增值；
int item=（int）itr.next（）；
int srt=（int）Math.sqrt（（双）项）；
如果（项目==1）{
flag=true；
}否则{
flag=true；
对于（int i=2；i HashMap不实现Compariable接口，因此无法将其强制转换为Compariable，即使在实现Compariable和Comparieto（）之后也无法解析，您有一个逻辑错误：如果某个对象不是素数，则设置flag=false，然后直接设置flag=true。
public class DLH {

    public static void main(String[] args) {
        Randomizer ran = new Randomizer();
        Queue<Value> outQ = new Prime().primeCheck(ran.randomGenerate());
        System.out.println(outQ);
    }

    private static class Value implements Comparable<Value> {

        int item;
        boolean isPrime;

        public Value(int item, boolean isPrime) {
            this.item = item;
            this.isPrime = isPrime;
        }

        @Override
        public int compareTo(Value o) {
            if (o == null) {
                return 1;
            }
            return this.item - o.item;
        }

        @Override
        public String toString() {
            return "Value{" + "item=" + item + ", isPrime=" + isPrime + '}';
        }
    }

    private static class Prime {

        Queue<Value> primeQ = new PriorityQueue<>();

        public Queue<Value> primeCheck(Queue<Integer> q) {
            boolean flag;
            Iterator<Integer> itr = q.iterator();
            while (itr.hasNext()) {
                Value val;
                int item = (int) itr.next();
                int srt = (int) Math.sqrt((double) item);
                if (item == 1) {
                    flag = true;
                } else {
                    flag = true;
                    for (int i = 2; i <= srt; i++) {

                        if (item % i == 0) {
                            flag = false;
                        }
                    }
                }
                val = new Value(item, flag);

                primeQ.add(val);

            }
            return primeQ;
        }
    }

    private static class Randomizer {

        public Queue<Integer> randomGenerate() {
            Queue<Integer> q = new PriorityQueue<>();
            int num;
            Random rand = new Random();
            for (int k = 0; k < 10; k++) {
                num = rand.nextInt(Integer.MAX_VALUE);
                q.add(num);
            }
            return q;
        }
    }
}