java 带PriorityQueue的数据库管理器

khbbv19g  于 2023-11-15  发布在  Java
关注(0)|答案(1)|浏览(113)

x1c 0d1x的数据

  1. import java.io.PrintWriter;
  2. import java.util.ArrayList;
  3. import java.util.Arrays;
  5. public class LabProgram {
  6.     public static boolean verifyCallbacks(PrintWriter testFeedback, ArrayList<String> actual,
  7.             ArrayList<String> expected) {
  8.         // Compare ArryList sizes first
  9.         boolean areEqual = true;
  10.         if (actual.size() == expected.size()) {
  11.             for (int i = 0; areEqual && i < actual.size(); i++) {
  12.                 if (!actual.get(i).equals(expected.get(i))) {
  13.                     areEqual = false;
  14.                 }
  15.             }
  16.         } 
  17.         else {
  18.             areEqual = false;
  19.         }
  21.         // Print results
  22.         testFeedback.write(areEqual ? "PASS" : "FAIL");
  23.         testFeedback.write(": Verification of invoked callbacks\n");
  24.         testFeedback.write("  Expected: " + expected + "\n");
  25.         testFeedback.write("  Actual:   " + actual + "\n");
  26.         return areEqual;
  27.     }
  29.     public static boolean test1(PrintWriter testFeedback) {
  30.         TestClock clock = new TestClock();
  31.         TimeoutManager timeouts = new TimeoutManager(clock);
  33.         ArrayList<String> actualCallbacks = new ArrayList<String>();
  34.         ArrayList<String> expectedCallbacks = new ArrayList<String>();
  36.         // Test with items:
  37.         // Added at clock time = 0:
  38.         // - item D with delay 500 (callback time is 500)
  39.         // - item A with delay 100 (callback time is 100)
  40.         // Added at clock time = 50
  41.         // - item B with delay 150 (callback time is 200)
  42.         clock.setTime(0);
  43.         timeouts.addTimeout(() -> {
  44.             actualCallbacks.add("D");
  45.             testFeedback.write("Item D's callback\n");
  46.         }, 500);
  47.         timeouts.addTimeout(() -> {
  48.             actualCallbacks.add("A");
  49.             testFeedback.write("Item A's callback\n");
  50.         }, 100);
  51.         clock.setTime(50);
  52.         timeouts.addTimeout(() -> {
  53.             actualCallbacks.add("B");
  54.             testFeedback.write("Item B's callback\n");
  55.         }, 150);
  57.         // Do an update with clock time = 100, which should invoke item A's
  58.         // callback
  59.         clock.setTime(100);
  60.         testFeedback.write("Updating with clock time = 100. Item A should show below.\n");
  61.         timeouts.update();
  63.         // Verify that only item A's callback was called
  64.         expectedCallbacks.add("A");
  65.         if (!verifyCallbacks(testFeedback, actualCallbacks, expectedCallbacks)) {
  66.             return false;
  67.         }
  69.         // Do another update with a clock time of 150, which shouldn't invoke any
  70.         // callbacks
  71.         clock.setTime(150);
  72.         testFeedback.write("Updating with clock time = 150. No callbacks should show below.\n");
  73.         timeouts.update();
  75.         // Verify that still only item A's callback has been called
  76.         if (!verifyCallbacks(testFeedback, actualCallbacks, expectedCallbacks)) {
  77.             return false;
  78.         }
  80.         // Add more timeouts at clock time = 300:
  81.         // - item E with delay 500 (callback time is 800)
  82.         // - item C with delay 100 (callback time is 400)
  83.         clock.setTime(300);
  84.         testFeedback.write("Adding timeouts E and C\n");
  85.         timeouts.addTimeout(() -> {
  86.             actualCallbacks.add("E");
  87.             testFeedback.write("Item E's callback\n");
  88.         }, 500);
  89.         timeouts.addTimeout(() -> {
  90.             actualCallbacks.add("C");
  91.             testFeedback.write("Item C's callback\n");
  92.         }, 100);
  94.         // Verify that adding new timeouts didn't invoke any new callbacks
  95.         if (!verifyCallbacks(testFeedback, actualCallbacks, expectedCallbacks)) {
  96.             return false;
  97.         }
  99.         // Do an update with a clock time of 350, which should invoke item B's
  100.         // callback
  101.         clock.setTime(350);
  102.         testFeedback.write("Updating with clock time = 350. Item B should show below.\n");
  103.         timeouts.update();
  105.         // Verify callbacks: A and B called, others not
  106.         expectedCallbacks.add("B");
  107.         if (!verifyCallbacks(testFeedback, actualCallbacks, expectedCallbacks)) {
  108.             return false;
  109.         }
  111.         // Do an update with a clock time of 550, which should invoke item C's
  112.         // callback and item D's callback, in that order
  113.         clock.setTime(550);
  114.         testFeedback.write("Updating with clock time = 550. Item C and D should show below, ");
  115.         testFeedback.write("in that order.\n");
  116.         timeouts.update();
  118.         // Verify callbacks: A, B, C, and D
  119.         expectedCallbacks.add("C");
  120.         expectedCallbacks.add("D");
  121.         if (!verifyCallbacks(testFeedback, actualCallbacks, expectedCallbacks)) {
  122.             return false;
  123.         }
  125.         // Do another update with a clock time of 700, which shouldn't invoke any
  126.         // callbacks
  127.         clock.setTime(700);
  128.         testFeedback.write("Updating with clock time = 700. No callbacks should show below.\n");
  129.         timeouts.update();
  131.         // Verify callbacks: again just A, B, C, and D
  132.         if (!verifyCallbacks(testFeedback, actualCallbacks, expectedCallbacks)) {
  133.             return false;
  134.         }
  136.         // Do a final update with time = 900, which should invoke item E's callback
  137.         clock.setTime(900);
  138.         testFeedback.write("Updating with clock time = 900. Item E should show below.\n");
  139.         timeouts.update();
  141.         // Verify callbacks: A, B, C, D, and E
  142.         expectedCallbacks.add("E");
  143.         if (!verifyCallbacks(testFeedback, actualCallbacks, expectedCallbacks)) {
  144.             return false;
  145.         }
  147.         return true;
  148.     }
  150.     public static boolean test2(PrintWriter testFeedback) {
  151.         TestClock clock = new TestClock();
  152.         TimeoutManager timeouts = new TimeoutManager(clock);
  154.         ArrayList<String> actualCallbacks = new ArrayList<String>();
  155.         ArrayList<String> expectedCallbacks = new ArrayList<String>();
  157.         // At t = 0:
  158.         // - Add item A with delay 800 (callback time is 800)
  159.         clock.setTime(0);
  160.         testFeedback.write("At t=0, adding timeout A with delay = 800\n");
  161.         timeouts.addTimeout(() -> {
  162.             actualCallbacks.add("A");
  163.         }, 800);
  165.         // At t = 50:
  166.         // - Add item D with delay 600 (callback time is 650)
  167.         clock.setTime(50);
  168.         testFeedback.write("At t=50, adding timeout D with delay = 600\n");
  169.         timeouts.addTimeout(() -> {
  170.             actualCallbacks.add("D");
  171.         }, 600);
  173.         // At t = 100:
  174.         // - Add item C with delay 200 (callback time is 300)
  175.         clock.setTime(100);
  176.         testFeedback.write("At t=100, adding timeout C with delay = 200\n");
  177.         timeouts.addTimeout(() -> {
  178.             actualCallbacks.add("C");
  179.         }, 200);
  181.         // At t = 150:
  182.         // - Add item E with delay 250 (callback time is 400)
  183.         clock.setTime(150);
  184.         testFeedback.write("At t=150, adding timeout E with delay = 250\n");
  185.         timeouts.addTimeout(() -> {
  186.             actualCallbacks.add("E");
  187.         }, 250);
  189.         // At t = 200:
  190.         // - Add item B with delay 50 (callback time is 250)
  191.         // - Update, then verify that no callback have yet been called
  192.         clock.setTime(200);
  193.         testFeedback.write("At t=200, adding timeout B with delay = 50");
  194.         testFeedback.write(", then updating\n");
  195.         timeouts.addTimeout(() -> {
  196.             actualCallbacks.add("B");
  197.         }, 50);
  198.         timeouts.update();
  199.         if (!verifyCallbacks(testFeedback, actualCallbacks, expectedCallbacks)) {
  200.             return false;
  201.         }
  203.         // At t = 400:
  204.         // - Update, then verify that callbacks B, C, and E have been called
  205.         clock.setTime(400);
  206.         testFeedback.write("At t=400, updating\n");
  207.         timeouts.update();
  208.         expectedCallbacks.add("B");
  209.         expectedCallbacks.add("C");
  210.         expectedCallbacks.add("E");
  211.         if (!verifyCallbacks(testFeedback, actualCallbacks, expectedCallbacks)) {
  212.             return false;
  213.         }
  215.         // At t = 450:
  216.         // - Add item F with delay 100 (callback time is 550)
  217.         clock.setTime(450);
  218.         testFeedback.write("At t=450, adding timeout F with delay = 100\n");
  219.         timeouts.addTimeout(() -> {
  220.             actualCallbacks.add("F");
  221.         }, 100);
  223.         // At t = 600:
  224.         // - Update, then verify callbacks: B and C from earlier, E and F now
  225.         clock.setTime(600);
  226.         testFeedback.write("At t=600, updating\n");
  227.         timeouts.update();
  228.         expectedCallbacks.add("F");
  229.         if (!verifyCallbacks(testFeedback, actualCallbacks, expectedCallbacks)) {
  230.             return false;
  231.         }
  233.         // At t = 800:
  234.         // - Update, then verify callbacks: B, C, E, F, D, A
  235.         clock.setTime(800);
  236.         testFeedback.write("At t=800, updating\n");
  237.         timeouts.update();
  238.         expectedCallbacks.add("D");
  239.         expectedCallbacks.add("A");
  240.         if (!verifyCallbacks(testFeedback, actualCallbacks, expectedCallbacks)) {
  241.             return false;
  242.         }
  244.         return true;
  245.     }
  247.     public static void main(String[] args) {
  248.         PrintWriter testFeedback = new PrintWriter(System.out);
  249.         boolean test1Result = test1(testFeedback);
  250.         testFeedback.println();
  252.         boolean test2Result = test2(testFeedback);
  253.         testFeedback.println();
  255.         testFeedback.flush();
  257.         System.out.println("Local test 1: " + (test1Result ? "PASS" : "FAIL"));
  258.         System.out.println("Local test 2: " + (test2Result ? "PASS" : "FAIL"));
  259.         
  260.         testFeedback.close();
  261.     }
  262. }
  1. public abstract class MillisecondClock {
  2.     abstract int getTime();
  3. }
  1. public class TestClock extends MillisecondClock {
  2.     private int currentTime;
  4.     public TestClock() {
  5.         currentTime = 0;
  6.     }
  8.     @Override
  9.     public int getTime() {
  10.         return currentTime;
  11.     }
  13.     // Sets this clock's current time, provided the new time is greater than the
  14.     // previously set time.
  15.     public boolean setTime(int newTime) {
  16.         // Only allow time to move forward
  17.         if (newTime > currentTime) {
  18.             currentTime = newTime;
  19.             return true;
  20.         }
  21.         return false;
  22.     }
  23. }
  1. @FunctionalInterface
  2. interface CallbackMethod {
  3.     void invoke();
  4. }
  6. public class TimeoutItem implements Comparable<TimeoutItem> {
  7.     private int callbackTime;
  8.     private CallbackMethod callbackMethod;
  10.     public TimeoutItem(CallbackMethod callbackMethod, int callbackTime) {
  11.         this.callbackTime = callbackTime;
  12.         this.callbackMethod = callbackMethod;
  13.     }
  15.     public TimeoutItem(TimeoutItem toCopy) {
  16.         this.callbackTime = toCopy.callbackTime;
  17.         this.callbackMethod = toCopy.callbackMethod;
  18.     }
  20.     public void callCallback() {
  21.         callbackMethod.invoke();
  22.     }
  24.     final public int getCallbackTime() {
  25.         return callbackTime;
  26.     }
  28.     @Override
  29.     public int compareTo(TimeoutItem tItem) {
  30.        // Java's PriorityQueue keeps item with smallest value at the front.
  31.         if (this.callbackTime > tItem.callbackTime) {
  32.             return 1;
  33.         } 
  34.         else if (this.callbackTime < tItem.callbackTime) {
  35.             return -1;
  36.         } 
  37.         else {
  38.             return 0;
  39.         }
  40.     }
  41. }
  1. import java.util.PriorityQueue;
  3. public class TimeoutManager {
  4.    private PriorityQueue<TimeoutItem> queue;
  5.    private MillisecondClock clock;
  6.    
  7.    public TimeoutManager(MillisecondClock clock) {
  8.       this.queue = new PriorityQueue<>();
  9.       this.clock = clock;
  10.    }
  11.    
  12.    public void addTimeout(Runnable callback, int delayBeforeCallback) {
  13.       int callbackTime = clock.getTime() + delayBeforeCallback;
  14.       TimeoutItem item = new TimeoutItem(callback, callbackTime);
  15.       queue.offer(item);
  16.    }
  17.    
  18.    public void update() {
  19.       int currentTime = clock.getTime();
  20.       while (!queue.isEmpty() && queue.peek().getCallbackTime() <= currentTime) {
  21.          TimeoutItem item = queue.poll();
  22.          item.getCallbackMethod().run();
  23.       }
  24.    }
  25. }

这是我的代码，但我一直得到错误：
第14章：你是谁？错误：不兼容的类型：Runnable无法转换为CallbackMethod TimeoutItem item = new TimeoutItem（callback，callbackTime）; ^ TimeoutManager.java：22：error：cannot find symbol item.getCallbackMethod（）.run（）; ^ symbol：method getCallbackMethod（）location：variable item of type TimeoutItem注意：某些消息已被简化;使用-Xdiags：verbose重新编译以获得完整输出2错误
我知道我必须在最后一部分做些什么，但我被卡住了。请帮助

Java

1条答案

按热度按时间
mfuanj7w

mfuanj7w1#

超时提示符.PY应该看起来像这样：
从队列导入系统导入优先级队列
从TimeoutItem导入TimeoutItem从时钟导入 *
类TimeoutManager：definit（self，clock）：#add_timeout（）和update（）使用的当前时间self.clock = clock #TimeoutItems的优先级队列。具有#最低回调时间的超时项首先被出队。self.pq = PriorityQueue（）

  1. # Return a timeout manager's internal priority queue.
  2. # Used only for grading purposes.
  3. def get_priority_queue(self):
  4.     return self.pq
  6. def get_priority_queue_times(self):
  7.     return sorted([entry.get_callback_time() for entry in self.pq.queue])
  9. # Add a TimeoutItem.
  10. # The added timeout expires at:
  11. #     (clock's current time when self function is called) + (item's delay time)
  12. def add_timeout(self,
  13.                 delay_before_callback,
  14.                 callback):     
  15.     current_time = self.clock.get_time() 
  16.     callback_time = current_time + delay_before_callback 
  17.     new_timeout_item = TimeoutItem(callback_time, callback) 
  18.     self.pq.put(new_timeout_item) 
  19.     pass
  21. # Dequeues each expired TimeoutItem from the priority queue in order of their
  22. # priority and calls each expired item's callback function.
  23. def update(self):
  24.     current_time = self.clock.get_time() 
  26.     while not self.pq.empty():
  27.         next_item = self.pq.get() 
  28.         if next_item.get_callback_time() <= current_time:
  29.             next_item.call_callback() 
  30.         else:
  31.             self.pq.put(next_item) 
  32.             break

字符串

展开查看全部
赞(0）分享  回复(0）举报  2023-11-15
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com