Java 为一系列具有较高优先级的元素和其他具有较低优先级的元素排序优先级队列

我有一个具有以下字段的实体类：id，orderNo。每个 实体必须存储在java优先级队列中。元素 id介于1-3000之间的具有更高的优先级，并且必须存储在 id>3000的元素上方orderNo的升序。元素 如果ID>3000，则以orderNo的升序存储在 更高优先级的元素（ID为1-3000）

例如：

预期的排序顺序：

(id=100  orderNo=3) 
(id=50   orderNo=4) 
(id=4000 orderNo=1) 
(id=5000 orderNo=2)

OrderEntity类：

public class OrderEntity implements Comparable<OrderEntity> {
    private int id;
    private int getOrderNo;

    public int getId() {
        return id;
    }

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

    public int getOrderNo() {
        return getOrderNo;
    }

    public void setOrderNo(int getOrderNo) {
        this.getOrderNo = getOrderNo;
    }

    @Override
    public int compareTo(OrderEntity arg0) {
        if ((this.getId() >= 1 && this.getId() <= 3000) && (arg0.getId() >= 1 && arg0.getId() <= 3000)) {
            if (this.getOrderNo() > arg0.getOrderNo()) {
                return 1;
            } else {
                return 0;
            }
        } else if ((this.getId() <= 3000) && (arg0.getId() > 3000)) {
            return 1;
        } else if ((this.getId() > 3000) && (arg0.getId() <= 3000)) {
            return 1;
        } else if ((this.getId() > 3000) && (arg0.getId() > 3000)) {
            if (this.getOrderNo() > arg0.getOrderNo()) {
                return 1;
            } else {
                return 0;
            }
        } else {
            return 0;
        }
    }
}

公共类OrderEntity实现了可比较的{
私有int-id；
私有int getOrderNo；
公共int getId（）{
返回id；
}
公共无效集合id（内部id）{
this.id=id；
}
public int getOrderNo（）{
返回getOrderNo；
}
public void setOrderNo（int getOrderNo）{
this.getOrderNo=getOrderNo；
}
@凌驾
公共整数比较（OrderEntity arg0）{
如果（（this.getId（）>=1&&this.getId（）=1&&arg0.getId（）arg0.getOrderNo（））{
返回1；
}否则{
返回0；
}
}else if（（this.getId（）3000））{
返回1；
}else if（（this.getId（）>3000）和&（arg0.getId（）3000）和&（arg0.getId（）>3000））{
if（this.getOrderNo（）>arg0.getOrderNo（））{
返回1；
}否则{
返回0；
}
}否则{
返回0；
}
}
}

OrderProcessor类：

public class OrderProcessor {
    private static int count;
    static Queue<OrderEntity> pq = new PriorityQueue<>();

    public String createOrder(int id) {
        OrderEntity orderEntity = new OrderEntity();
        orderEntity.setId(id);
        count = count + 1;
        orderEntity.setOrderNo(count);
        pq.add(orderEntity);

        String res = "";
        for (OrderEntity rd : pq) {
            res = res + rd.getId() + " " + rd.getOrderNo() + "\n";
        }
        return res.trim();
    }
}

公共类OrderProcessor{
私有静态整数计数；
静态队列pq=新的优先级队列（）；
公共字符串createOrder（int id）{
OrderEntity OrderEntity=新的OrderEntity（）；
setId（id）；
计数=计数+1；
orderEntity.setOrderNo（计数）；
pq.add（订单实体）；
字符串res=“”；
对于（订单实体rd:pq）{
res=res+rd.getId（）+“”+rd.getOrderNo（）+“\n”；
}
返回res.trim（）；
}
}

在对象的自然顺序与您的特殊需求不同的情况下，最好不要使用

Comparable

，因为它将来可能有其他用途。因此，剩下的解决方案是使用

Comparator

，这非常适合您的问题，因为您的

OrderEntity

类不会e依赖于此特殊比较。以下是显示解决方案的示例代码：

import java.util.Comparator;
import java.util.PriorityQueue;

public class OrderProcessor {
    public static void main(String[] args) {
        PriorityQueue<OrderEntity> q = new PriorityQueue<>(new OrderEntityComparator());
        q.add(new OrderEntity(4000, 1));
        q.add(new OrderEntity(5000, 2));
        q.add(new OrderEntity(100, 3));
        q.add(new OrderEntity(50, 4));

        while(!q.isEmpty())
            System.out.println(q.poll());
    }

    public static class OrderEntityComparator implements Comparator<OrderEntity> {

        @Override
        public int compare(OrderEntity o1, OrderEntity o2) {
            if(o1.getId() <= 3000 && o2.getId() <= 3000)
                return Integer.compare(o1.getOrderNo(), o2.getOrderNo());
            if(o1.getId() > 3000 && o2.getId() > 3000)
                return Integer.compare(o1.getOrderNo(), o2.getOrderNo());
            if(o1.getId() <= 3000 && o2.getId() > 3000)
                return -1;
            return 1;
        }
    }

    public static class OrderEntity {
        private int id;
        private int orderNo;

        public OrderEntity(int id, int orderNo) {
            this.id = id;
            this.orderNo = orderNo;
        }

        public int getId() {
            return id;
        }

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

        public int getOrderNo() {
            return orderNo;
        }

        public void setOrderNo(int orderNo) {
            this.orderNo = orderNo;
        }

        @Override
        public String toString() {
            return "OrderEntity{" +
                    "id=" + id +
                    ", orderNo=" + orderNo +
                    '}';
        }
    }
}

---

事实上，在这种情况下，您不需要使用

优先队列

，对列表或数组进行简单排序就可以了。

在这种情况下，对象的自然顺序与您的特殊要求不同，最好不要使用

可比

，因为它将来可能有其他用途解决方案使用的是非常适合您的问题的

Comparator

，因为您的

OrderEntity

类不会依赖于此特殊比较。以下是显示解决方案的示例代码：

import java.util.Comparator;
import java.util.PriorityQueue;

public class OrderProcessor {
    public static void main(String[] args) {
        PriorityQueue<OrderEntity> q = new PriorityQueue<>(new OrderEntityComparator());
        q.add(new OrderEntity(4000, 1));
        q.add(new OrderEntity(5000, 2));
        q.add(new OrderEntity(100, 3));
        q.add(new OrderEntity(50, 4));

        while(!q.isEmpty())
            System.out.println(q.poll());
    }

    public static class OrderEntityComparator implements Comparator<OrderEntity> {

        @Override
        public int compare(OrderEntity o1, OrderEntity o2) {
            if(o1.getId() <= 3000 && o2.getId() <= 3000)
                return Integer.compare(o1.getOrderNo(), o2.getOrderNo());
            if(o1.getId() > 3000 && o2.getId() > 3000)
                return Integer.compare(o1.getOrderNo(), o2.getOrderNo());
            if(o1.getId() <= 3000 && o2.getId() > 3000)
                return -1;
            return 1;
        }
    }

    public static class OrderEntity {
        private int id;
        private int orderNo;

        public OrderEntity(int id, int orderNo) {
            this.id = id;
            this.orderNo = orderNo;
        }

        public int getId() {
            return id;
        }

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

        public int getOrderNo() {
            return orderNo;
        }

        public void setOrderNo(int orderNo) {
            this.orderNo = orderNo;
        }

        @Override
        public String toString() {
            return "OrderEntity{" +
                    "id=" + id +
                    ", orderNo=" + orderNo +
                    '}';
        }
    }
}

---

事实上，在这种情况下，您不需要使用

PriorityQueue

，对列表或数组进行简单排序就可以了。

这里有一个使用Java 8的解决方案，它不需要任何复杂的比较器实现。我针对您提供的两个示例运行了它。诀窍是认识到有两组id，即id/3000) ) .thenComparingInt（OrderEntity:：getOrderNo）； 公共静态void main（字符串[]args）{ PriorityQueue队列=新的PriorityQueue（orderEntityComparator）； 添加（新的OrderEntity（4000，1））； 添加（新的OrderEntity（5000，2））； 添加（新的OrderEntity（100,3））； 添加（新的OrderEntity（50，4））； // 100, 50, 4000, 5000 queue.clear（）； 添加（新的OrderEntity（100，1））； 添加（新的OrderEntity（200，2））； 添加（新的OrderEntity（4000，3））； 添加（新的OrderEntity（300，4））； 而（！queue.isEmpty（））{ System.out.println（queue.poll（））； } // 100, 200, 300, 4000 } 静态类OrderEntity{ 私有int-id； 私人int订单号； 公共订单实体（int-id，int-orderNo）{ this.id=id； this.orderNo=orderNo； } 公共int getId（）{ 返回id； } public int getOrderNo（）{ 退货订单号； } @凌驾 公共字符串toString（）{ 返回String.format（（id=%d，orderNo=%d）”，id，orderNo）； } } }

---

这是一个使用Java 8的解决方案，它不需要任何复杂的比较器实现。我将它与您提供的两个示例进行了对比。诀窍是认识到有两组id，即id/3000） ) .thenComparingInt（OrderEntity:：getOrderNo）； 公共静态void main（字符串[]args）{ PriorityQueue队列=新的PriorityQueue（orderEntityComparator）； 添加（新的OrderEntity（4000，1））； 添加（新的OrderEntity（5000，2））； 添加（新的OrderEntity（100,3））； 添加（新的OrderEntity（50，4））； // 100, 50, 4000, 5000 queue.clear（）； 添加（新的OrderEntity（100，1））； 添加（新的OrderEntity（200，2））； 添加（新的OrderEntity（4000，3））； 添加（新的OrderEntity（300，4））； 而（！queue.isEmpty（））{ System.out.println（queue.poll（））； } // 100, 200, 300, 4000 } 静态类OrderEntity{ 私有int-id； 私人int订单号； 公共订单实体（int-id，int-orderNo）{ this.id=id； this.orderNo=orderNo； } 公共int getId（）{ 返回id； } public int getOrderNo（）{ 退货订单号； } @凌驾 公共字符串toString（）

    OrderEntity[] a = new OrderEntity[q.size()];
    q.toArray(a);
    Arrays.sort(a, new OrderEntityComparator());

    for(OrderEntity entity : a)
        System.out.println(entity);

public class Main {
    private static Comparator<OrderEntity> orderEntityComparator =
        Comparator.<OrderEntity, Integer>comparing(OrderEntity::getId,
                comparingInt(id -> id / 3000)
        )
                .thenComparingInt(OrderEntity::getOrderNo);

    public static void main(String[] args) {
        PriorityQueue<OrderEntity> queue = new PriorityQueue<>(orderEntityComparator);
        queue.add(new OrderEntity(4000, 1));
        queue.add(new OrderEntity(5000, 2));
        queue.add(new OrderEntity(100, 3));
        queue.add(new OrderEntity(50, 4));

        // 100, 50, 4000, 5000

        queue.clear();

        queue.add(new OrderEntity(100, 1));
        queue.add(new OrderEntity(200, 2));
        queue.add(new OrderEntity(4000, 3));
        queue.add(new OrderEntity(300, 4));

        while (!queue.isEmpty()) {
            System.out.println(queue.poll());
        }
        // 100, 200, 300, 4000
    }

    static class OrderEntity {
        private int id;
        private int orderNo;

        public OrderEntity(int id, int orderNo) {
            this.id = id;
            this.orderNo = orderNo;
        }

        public int getId() {
            return id;
        }

        public int getOrderNo() {
            return orderNo;
        }

        @Override
        public String toString() {
            return String.format("(id=%d, orderNo=%d)", id, orderNo);
        }
    }
}