给你一支股票价格的数据流。数据流中每一条记录包含一个 时间戳 和该时间点股票对应的 价格 。

    不巧的是，由于股票市场内在的波动性，股票价格记录可能不是按时间顺序到来的。某些情况下，有的记录可能是错的。如果两个有相同时间戳的记录出现在数据流中，前一条记录视为错误记录，后出现的记录 更正 前一条错误的记录。

    请你设计一个算法，实现：

    更新 股票在某一时间戳的股票价格，如果有之前同一时间戳的价格，这一操作将 更正 之前的错误价格。
    找到当前记录里 最新股票价格 。最新股票价格 定义为时间戳最晚的股票价格。
    找到当前记录里股票的 最高价格 。
    找到当前记录里股票的 最低价格 。
    请你实现 StockPrice 类：

    StockPrice() 初始化对象，当前无股票价格记录。
    void update(int timestamp, int price) 在时间点 timestamp 更新股票价格为 price 。
    int current() 返回股票 最新价格 。
    int maximum() 返回股票 最高价格 。
    int minimum() 返回股票 最低价格 。

    示例 1：

    输入：
    [“StockPrice”, “update”, “update”, “current”, “maximum”, “update”, “maximum”, “update”, “minimum”]
    [[], [1, 10], [2, 5], [], [], [1, 3], [], [4, 2], []]
    输出：
    [null, null, null, 5, 10, null, 5, null, 2]

    解释：
    StockPrice stockPrice = new StockPrice();
    stockPrice.update(1, 10); // 时间戳为 [1] ，对应的股票价格为 [10] 。
    stockPrice.update(2, 5); // 时间戳为 [1,2] ，对应的股票价格为 [10,5] 。
    stockPrice.current(); // 返回 5 ，最新时间戳为 2 ，对应价格为 5 。
    stockPrice.maximum(); // 返回 10 ，最高价格的时间戳为 1 ，价格为 10 。
    stockPrice.update(1, 3); // 之前时间戳为 1 的价格错误，价格更新为 3 。
    // 时间戳为 [1,2] ，对应股票价格为 [3,5] 。
    stockPrice.maximum(); // 返回 5 ，更正后最高价格为 5 。
    stockPrice.update(4, 2); // 时间戳为 [1,2,4] ，对应价格为 [3,5,2] 。
    stockPrice.minimum(); // 返回 2 ，最低价格时间戳为 4 ，价格为 2 。

    提示：

    1 <= timestamp, price <= 109
    update，current，maximum 和 minimum 总 调用次数不超过 105 。
    current，maximum 和 minimum 被调用时，update 操作 至少 已经被调用过 一次 。

    1. class StockPrice {
    2.     Map<Integer,Integer> map = new HashMap<>();
    3.     PriorityQueue<int[]> maxq = new PriorityQueue<>((a,b) -> b[1] - a[1]);
    4.     PriorityQueue<int[]> minq = new PriorityQueue<>((a,b) -> a[1] - b[1]);
    5.     int currTime = 0, current = 0;;
    6.     public StockPrice() {
    7.         //用优先队列分别维护最大值和最小值，但是在插入过程中无法解决时间戳的股票被覆盖的问题
    8.         //所以引入map，当出队时需要跟map里面的股票值比较，如果不一样说明是无效值应该舍弃
    9.     }
    11.     public void update(int timestamp, int price) {
    12.         if (timestamp >= currTime) {
    13.             current = price;
    14.             currTime = timestamp;
    15.         }
    16.         //如果当前时间戳的股票是最大值就出队，更新
    17.         if (!maxq.isEmpty() && maxq.peek()[0] == timestamp) {
    18.             maxq.poll();
    19.         }
    20.         maxq.add(new int[]{timestamp,price});
    21.         //如果当前时间戳的股票是最小值就出队，更新
    22.         if (!minq.isEmpty() && minq.peek()[0] == timestamp) {
    23.             minq.poll();
    24.         }
    25.         minq.add(new int[]{timestamp,price});
    26.         map.put(timestamp,price);
    27.     }
    29.     public int current() {  
    30.         return current;
    31.     }
    33.     public int maximum() {
    34.         //如果当前最大值的时间戳跟map里时间戳的股票不一样，就说明是无效的数据，出队
    35.         while (maxq.peek()[1] != map.get(maxq.peek()[0])) maxq.poll();
    36.         return maxq.peek()[1];
    37.     }
    39.     public int minimum() {
    40.         //如果当前最小值的时间戳跟map里时间戳的股票不一样，就说明是无效的数据，出队
    41.         while (minq.peek()[1] != map.get(minq.peek()[0])) minq.poll();
    42.         return minq.peek()[1];
    43.     }
    44. }
    46. /**
    47.  * Your StockPrice object will be instantiated and called as such:
    48.  * StockPrice obj = new StockPrice();
    49.  * obj.update(timestamp,price);
    50.  * int param_2 = obj.current();
    51.  * int param_3 = obj.maximum();
    52.  * int param_4 = obj.minimum();
    53.  */