爲優先級較高的元素和其他優先級較低的元素排序優先隊列

Question

我有一個包含以下字段的實體類：id，orderNo。每個 實體必須存儲在一個java優先級隊列中。 id在1至3000之間的元素 具有更高的優先級，並且必須以 的升序存儲，不存在於id> 3000的元素之上。具有> 3000的元素的元素 以高於優先級元素 的orderNo的升序存儲與ids 1 - 3000）。

如：

(1st insertion to queue: id=4000 orderNo=1) 
(2nd insertion to queue: id=5000 orderNo=2) 
(3rd insertion to queue: id=100 orderNo=3) 
(4th insertion to queue: id=50 orderNo=4) 

預期排序順序：

(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; 
     } 
    } 
} 

訂單處理器類：

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(); 
    } 
} 

Answer 1

在這種情況下，物體的自然排序與您的特殊要求不同，最好不要使用Comparable，因爲它可能在將來有其他用途。因此，剩下的解決方案是使用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 + 
        '}'; 
     } 
    } 
} 

編輯：

如果你不想通過調用poll方法刪除元素，你必須在一個數組或列表的元素進行排序，這樣的事情：

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

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

事實上，在這種情況下，你不需要使用PriorityQueue和一個簡單的排序上的列表或數組將做的工作。

Answer 2

這是一個使用Java 8的解決方案，不需要任何複雜的比較器實現。我反對你提供的兩個例子。訣竅是認識到有兩組ID，那些< = 3000，以及上面的那些。如果您可以以某種方式對這兩組中的數字進行歸一化，那麼您可以簡單地使用規範化ID的自然排序，然後按順序號自然排序。

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); 
     } 
    } 
}