How would you implement this Java class?

25 thoughts on “How would you implement this Java class?”

• 

  By Tiejun - March 19, 2015 9:34 PM Reply

  import java.util.Arrays; import java.util.Date; /** * This class represents a fixed hourly schedule. * * It can tell you the next start time for an event after a given point in * time. * * You first define the minutes past each hour that an event can * occur (for example HH:00, HH:15, HH:30, and HH:45). Then you call * {@link #getNextTime(long)} to find the next occurrence from any point * in time. In the above scenario, passing in 4:23 PM today should return * 4:30 PM today. * */ public class HourlySchedulerTest { private final int[] minutesPastHour; private static long MILLIS_IN_MINUTE = (60 * 1000); private static long MINUTE_IN_HOUR = 60; private static long MILLIS_IN_HOUR = (MINUTE_IN_HOUR * MILLIS_IN_MINUTE); /** * Accepts the minutes past each hour that an event can start * (for example 0, 15, 30, and 45). * unit is minute; */ public HourlySchedulerTest(int ... minutesPastHour) { this.minutesPastHour = minutesPastHour; Arrays.sort(this.minutesPastHour); } /** * Returns the next start time from the given point in time. */ public long getNextTime(long fromMillis) { long timeLessThanHour = fromMillis % MILLIS_IN_HOUR; long hoursInMillis = fromMillis - timeLessThanHour; /* * change milliseconds to minute; */ long minuteInHour = timeLessThanHour / MILLIS_IN_MINUTE; int index = 0; for (int minute : minutesPastHour) { if (minuteInHour > minute) { index++; } else { break; } } if (index == minutesPastHour.length) { // get first time in next hour. return (hoursInMillis + (minutesPastHour[0] + MINUTE_IN_HOUR) * MILLIS_IN_MINUTE); } else { return (hoursInMillis + minutesPastHour[index] * MILLIS_IN_MINUTE); } } public static void main(String[] args) { HourlySchedulerTest test = new HourlySchedulerTest(0, 15, 30, 45); final long now = 1426708139391L; // Wed Mar 18 15:48:59 2015 expect(test, now, 1426708800000L); expect(test, now + 900000L, 1426709700000L); expect(test, now + 1800000, 1426710600000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426712400000L); } private static void expect(HourlySchedulerTest test, long fromMillis, long expectedNextTime) { long actualNextTime = test.getNextTime(fromMillis); if (actualNextTime != expectedNextTime) { System.out.println("Test failed. Expected: " + new Date(expectedNextTime) + " (" + expectedNextTime + "), but found " + new Date(actualNextTime) + " (" + actualNextTime + ")"); } else { System.out.println("Test passed. " + new Date(actualNextTime)); } } }

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90

  import java.util.Arrays; import java.util.Date;   /** * This class represents a fixed hourly schedule.   * * It can tell you the next start time for an event after a given point in * time. * * You first define the minutes past each hour that an event can * occur (for example HH:00, HH:15, HH:30, and HH:45).  Then you call * {@link #getNextTime(long)} to find the next occurrence from any point * in time.  In the above scenario, passing in 4:23 PM today should return * 4:30 PM today. * */ public class HourlySchedulerTest {       private final int[] minutesPastHour;       private static long MILLIS_IN_MINUTE = (60 * 1000);     private static long MINUTE_IN_HOUR = 60;     private static long MILLIS_IN_HOUR = (MINUTE_IN_HOUR * MILLIS_IN_MINUTE);       /**      * Accepts the minutes past each hour that an event can start      * (for example 0, 15, 30, and 45).      * unit is minute;      */     public HourlySchedulerTest(int ... minutesPastHour) {         this.minutesPastHour = minutesPastHour;         Arrays.sort(this.minutesPastHour);     }       /**      * Returns the next start time from the given point in time.      */     public long getNextTime(long fromMillis) {         long timeLessThanHour = fromMillis % MILLIS_IN_HOUR;           long hoursInMillis = fromMillis - timeLessThanHour;           /*          * change milliseconds to minute;          */         long minuteInHour = timeLessThanHour / MILLIS_IN_MINUTE;           int index = 0;         for (int minute : minutesPastHour) {             if (minuteInHour > minute) {                 index++;             } else {                 break;             }         }           if (index == minutesPastHour.length) {             // get first time in next hour.             return (hoursInMillis + (minutesPastHour[0] + MINUTE_IN_HOUR)                 * MILLIS_IN_MINUTE);         } else {             return (hoursInMillis + minutesPastHour[index] * MILLIS_IN_MINUTE);         }     }       public static void main(String[] args) {           HourlySchedulerTest test = new HourlySchedulerTest(0, 15, 30, 45);                  final long now = 1426708139391L;  // Wed Mar 18 15:48:59 2015           expect(test, now, 1426708800000L);         expect(test, now + 900000L, 1426709700000L);         expect(test, now + 1800000, 1426710600000L);         expect(test, now + 2700000L, 1426711500000L);         expect(test, now + 3600000L, 1426712400000L);       }       private static void expect(HourlySchedulerTest test, long fromMillis, long expectedNextTime) {         long actualNextTime = test.getNextTime(fromMillis);         if (actualNextTime != expectedNextTime) {             System.out.println("Test failed.  Expected: "                     + new Date(expectedNextTime) + " (" + expectedNextTime + "), but found "                     + new Date(actualNextTime) + " (" + actualNextTime + ")");         } else {             System.out.println("Test passed.  "  + new Date(actualNextTime));         }     } }

  • 

    By Dele Taylor - March 19, 2015 11:38 PM Reply

    Very close to our implementation 🙂 You can reduce several lines of code by replacing the break statement with a return.

• 

  By Philippe FERY - March 21, 2015 5:25 AM Reply

  I would implement it as follow:

  package hourlyscheduler; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Date; import java.util.GregorianCalendar; import java.util.List; /** * This class represents a fixed hourly schedule. * * It can tell you the next start time for an event after a given point in time. * * You first define the minutes past each hour that an event can occur (for * example HH:00, HH:15, HH:30, and HH:45). Then you call * {@link #getNextTime(long)} to find the next occurrence from any point in * time. In the above scenario, passing in 4:23 PM today should return 4:30 PM * today. * */ public class HourlyScheduler { List millis; /** * Accepts the minutes past each hour that an event can start (for example * 0, 15, 30, and 45). * */ public HourlyScheduler(int... minutesPastHour) { millis = new ArrayList(); for (int mins : minutesPastHour) millis.add((long) (mins == 0 ? 60 : mins) * 60 * 1000); Collections.sort(millis); } /** * Returns the next start time from the given point in time. */ public long getNextTime(long fromMillis) { long startTime = fromMillis - (fromMillis % (60 * 60 * 1000)); long nextTime = startTime; for (int i = millis.size() - 1; i >= 0 && startTime + millis.get(i) >= fromMillis; i--) { nextTime = startTime + millis.get(i); } return nextTime; } public static void main(String[] args) { HourlyScheduler test = new HourlyScheduler(0, 15, 30, 45); final long now = 1426708139391L; // Wed Mar 18 15:48:59 2015 expect(test, now, 1426708800000L); expect(test, now + 900000L, 1426709700000L); expect(test, now + 1800000, 1426710600000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426712400000L); } private static void expect(HourlyScheduler test, long fromMillis, long expectedNextTime) { long actualNextTime = test.getNextTime(fromMillis); if (actualNextTime != expectedNextTime) { System.out.println("Test failed. Expected: " + new Date(expectedNextTime) + " (" + expectedNextTime + "), but found " + new Date(actualNextTime) + " (" + actualNextTime + ")"); } else { System.out.println("Test passed. " + new Date(actualNextTime)); } } }

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78

  package hourlyscheduler;   import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Date; import java.util.GregorianCalendar; import java.util.List;   /** * This class represents a fixed hourly schedule. * * It can tell you the next start time for an event after a given point in time. * * You first define the minutes past each hour that an event can occur (for * example HH:00, HH:15, HH:30, and HH:45). Then you call * {@link #getNextTime(long)} to find the next occurrence from any point in * time. In the above scenario, passing in 4:23 PM today should return 4:30 PM * today. * */ public class HourlyScheduler { List millis;   /** * Accepts the minutes past each hour that an event can start (for example * 0, 15, 30, and 45). * */ public HourlyScheduler(int... minutesPastHour) { millis = new ArrayList(); for (int mins : minutesPastHour) millis.add((long) (mins == 0 ? 60 : mins) * 60 * 1000); Collections.sort(millis); }   /** * Returns the next start time from the given point in time. */ public long getNextTime(long fromMillis) { long startTime = fromMillis - (fromMillis % (60 * 60 * 1000)); long nextTime = startTime; for (int i = millis.size() - 1; i >= 0 && startTime + millis.get(i) >= fromMillis; i--) { nextTime = startTime + millis.get(i); } return nextTime; }   public static void main(String[] args) {   HourlyScheduler test = new HourlyScheduler(0, 15, 30, 45);   final long now = 1426708139391L; // Wed Mar 18 15:48:59 2015   expect(test, now, 1426708800000L); expect(test, now + 900000L, 1426709700000L); expect(test, now + 1800000, 1426710600000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426712400000L);   }   private static void expect(HourlyScheduler test, long fromMillis, long expectedNextTime) { long actualNextTime = test.getNextTime(fromMillis); if (actualNextTime != expectedNextTime) { System.out.println("Test failed.  Expected: " + new Date(expectedNextTime) + " (" + expectedNextTime + "), but found " + new Date(actualNextTime) + " (" + actualNextTime + ")"); } else { System.out.println("Test passed.  " + new Date(actualNextTime)); } }   }

  • 

    By Dele Taylor - March 21, 2015 6:03 AM Reply

    Nice approach Philippe and your line count is almost on par with ours.

    If I had included a real set of unit tests you would have caught an assumption in your code — that all schedules start on the hour. You can see what I mean by changing the input to be 15 and 45 minutes past the hour.

    HourlySchedulerTest test = new HourlySchedulerTest(15, 45); final long now = 1426708139391L; // Wed Mar 18 15:48:59 2015 expect(test, now + 900000L, 1426709700000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426713300000L);

    1 2 3 4 5 6 7

    HourlySchedulerTest test = new HourlySchedulerTest(15, 45);   final long now = 1426708139391L; // Wed Mar 18 15:48:59 2015   expect(test, now + 900000L, 1426709700000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426713300000L);

    Thanks for being a good sport and sharing your quick answer.

• 

  By Philippe FERY - March 21, 2015 11:02 AM Reply

  You’re right: i missed it! … Shame on me 🙂

  This time, it shoul be ok….

  package hourlyscheduler; import java.util.ArrayList; import java.util.Collections; import java.util.Date; import java.util.List; /** * This class represents a fixed hourly schedule. * * It can tell you the next start time for an event after a given point in time. * * You first define the minutes past each hour that an event can occur (for * example HH:00, HH:15, HH:30, and HH:45). Then you call * {@link #getNextTime(long)} to find the next occurrence from any point in * time. In the above scenario, passing in 4:23 PM today should return 4:30 PM * today. * */ public class HourlySchedulerTest { private List millis; /** * Accepts the minutes past each hour that an event can start (for example * 0, 15, 30, and 45). * */ public HourlySchedulerTest(int... minutesPastHour) { millis = new ArrayList(); for (int mins : minutesPastHour) millis.add((long) mins * 60 * 1000); Collections.sort(millis); } /** * Returns the next start time from the given point in time. */ public long getNextTime(long fromMillis) { long startTime = fromMillis -fromMillis % (60 * 60 * 1000); long nextTime = startTime; int i = -1; while (nextTime <= fromMillis) nextTime = startTime + millis.get(++i % millis.size())+((int)(i/millis.size())*(60*60*1000)); return nextTime; } public static void main(String[] args) { HourlySchedulerTest test = new HourlySchedulerTest(0, 15, 30, 45); final long now = 1426708139391L; // Wed Mar 18 15:48:59 2015 expect(test, now, 1426708800000L); expect(test, now + 900000L, 1426709700000L); expect(test, now + 1800000, 1426710600000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426712400000L); test = new HourlySchedulerTest(15, 45); expect(test, now + 900000L, 1426709700000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426713300000L); } private static void expect(HourlySchedulerTest test, long fromMillis, long expectedNextTime) { long actualNextTime = test.getNextTime(fromMillis); if (actualNextTime != expectedNextTime) { System.out.println("Test failed. Expected: " + new Date(expectedNextTime) + " (" + expectedNextTime + "), but found " + new Date(actualNextTime) + " (" + actualNextTime + ")"); } else { System.out.println("Test passed. " + new Date(actualNextTime)); } } }

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78

  package hourlyscheduler;   import java.util.ArrayList; import java.util.Collections; import java.util.Date; import java.util.List;   /** * This class represents a fixed hourly schedule. * * It can tell you the next start time for an event after a given point in time. * * You first define the minutes past each hour that an event can occur (for * example HH:00, HH:15, HH:30, and HH:45). Then you call * {@link #getNextTime(long)} to find the next occurrence from any point in * time. In the above scenario, passing in 4:23 PM today should return 4:30 PM * today. * */ public class HourlySchedulerTest { private List millis;   /** * Accepts the minutes past each hour that an event can start (for example * 0, 15, 30, and 45). * */ public HourlySchedulerTest(int... minutesPastHour) { millis = new ArrayList(); for (int mins : minutesPastHour) millis.add((long) mins * 60 * 1000); Collections.sort(millis); }   /** * Returns the next start time from the given point in time. */ public long getNextTime(long fromMillis) { long startTime = fromMillis -fromMillis % (60 * 60 * 1000); long nextTime = startTime; int i = -1; while (nextTime <= fromMillis) nextTime = startTime + millis.get(++i % millis.size())+((int)(i/millis.size())*(60*60*1000)); return nextTime; }   public static void main(String[] args) {   HourlySchedulerTest test = new HourlySchedulerTest(0, 15, 30, 45);   final long now = 1426708139391L; // Wed Mar 18 15:48:59 2015   expect(test, now, 1426708800000L); expect(test, now + 900000L, 1426709700000L); expect(test, now + 1800000, 1426710600000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426712400000L);   test = new HourlySchedulerTest(15, 45); expect(test, now + 900000L, 1426709700000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426713300000L); }   private static void expect(HourlySchedulerTest test, long fromMillis, long expectedNextTime) { long actualNextTime = test.getNextTime(fromMillis); if (actualNextTime != expectedNextTime) { System.out.println("Test failed.  Expected: " + new Date(expectedNextTime) + " (" + expectedNextTime + "), but found " + new Date(actualNextTime) + " (" + actualNextTime + ")"); } else { System.out.println("Test passed.  " + new Date(actualNextTime)); } }   }

• 

  By Ervin Nemesszeghy - March 21, 2015 10:32 PM Reply

  package dele; import java.util.ArrayList; import java.util.Collections; import java.util.Date; /** * This class represents a fixed hourly schedule. * * It can tell you the next start time for an event after a given point in * time. * * You first define the minutes past each hour that an event can * occur (for example HH:00, HH:15, HH:30, and HH:45). Then you call * {@link #getNextTime(long)} to find the next occurrence from any point * in time. In the above scenario, passing in 4:23 PM today should return * 4:30 PM today. * */ public class HourlySchedulerTest { int [] minutesPastHour; /** * Accepts the minutes past each hour that an event can start * (for example 0, 15, 30, and 45). * */ public HourlySchedulerTest(int ... minutesPastHour) { this.minutesPastHour = minutesPastHour; } /** * Returns the next start time from the given point in time. */ public long getNextTime(long fromMillis) { long ret = 0l; // -- Copy to an Array List -- ArrayList minutesList = new ArrayList(); for ( long el: minutesPastHour) { Long l = el; minutesList.add( l ); } long maxMinute = Collections.max(minutesList) * 60 * 1000; long partHours = fromMillis / 1000 / 60 / 60; partHours = partHours * 60 * 60 * 1000L; long partMillis = fromMillis - partHours; ret = partHours; // -- Do we need to go to the next hour? -- if ( partMillis > maxMinute ) { ret = ret + 3600000L; partMillis = 0; } // --- Recursively find the closes upward Min part -- ret = ret + getMillsPart(partMillis, minutesList); return ret; } /** * Recursively find the right Mill part * @param partMillis * @param list * @return */ private long getMillsPart(long partMillis, ArrayList list) { if (list == null || list.size() < 1) { return 0; } long mills = 0; Long min = Collections.min(list); if ( partMillis <= min * 60 * 1000l ) { mills = min * 60 * 1000; } else { list.remove(min); mills = getMillsPart( partMillis, list ); } return mills; } public static void main(String[] args) { HourlySchedulerTest test = new HourlySchedulerTest(0, 15, 30, 45); final long now = 1426708139391L; // Wed Mar 18 15:48:59 2015 expect(test, now, 1426708800000L); expect(test, now + 900000L, 1426709700000L); expect(test, now + 1800000, 1426710600000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426712400000L); } private static void expect(HourlySchedulerTest test, long fromMillis, long expectedNextTime) { long actualNextTime = test.getNextTime(fromMillis); if (actualNextTime != expectedNextTime) { System.out.println("Test failed. Expected: " + new Date(expectedNextTime) + " (" + expectedNextTime + "), but found " + new Date(actualNextTime) + " (" + actualNextTime + ")"); } else { System.out.println("Test passed. " + new Date(actualNextTime)); } } }

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110

  package dele;   import java.util.ArrayList; import java.util.Collections; import java.util.Date;   /** * This class represents a fixed hourly schedule.   * * It can tell you the next start time for an event after a given point in * time. * * You first define the minutes past each hour that an event can * occur (for example HH:00, HH:15, HH:30, and HH:45).  Then you call * {@link #getNextTime(long)} to find the next occurrence from any point * in time.  In the above scenario, passing in 4:23 PM today should return * 4:30 PM today. * */ public class HourlySchedulerTest { int [] minutesPastHour;     /**      * Accepts the minutes past each hour that an event can start      * (for example 0, 15, 30, and 45).      *      */     public HourlySchedulerTest(int ... minutesPastHour) {           this.minutesPastHour = minutesPastHour;     }          /**      * Returns the next start time from the given point in time.      */     public long getNextTime(long fromMillis) {      long ret = 0l;      // -- Copy to an Array List --      ArrayList minutesList = new ArrayList();      for ( long el: minutesPastHour) {      Long l = el;      minutesList.add( l );      }      long maxMinute = Collections.max(minutesList) * 60 * 1000;           long partHours = fromMillis / 1000 / 60 / 60;      partHours = partHours * 60 * 60 * 1000L;      long partMillis = fromMillis - partHours;      ret = partHours;           // -- Do we need to go to the next hour? --      if ( partMillis > maxMinute ) {      ret = ret + 3600000L;      partMillis = 0;      }      // --- Recursively find the closes upward Min part --      ret = ret + getMillsPart(partMillis, minutesList);         return ret;     }          /**      * Recursively find the right Mill part      * @param partMillis      * @param list      * @return      */     private long getMillsPart(long partMillis, ArrayList list) {           if (list == null || list.size() < 1) {      return 0;      }           long mills = 0;      Long min = Collections.min(list);      if ( partMillis <= min * 60 * 1000l ) {      mills = min * 60 * 1000;      } else {      list.remove(min);      mills = getMillsPart( partMillis, list );      }           return mills;     }               public static void main(String[] args) {           HourlySchedulerTest test = new HourlySchedulerTest(0, 15, 30, 45);                  final long now = 1426708139391L;  // Wed Mar 18 15:48:59 2015           expect(test, now, 1426708800000L);         expect(test, now + 900000L, 1426709700000L);         expect(test, now + 1800000, 1426710600000L);         expect(test, now + 2700000L, 1426711500000L);         expect(test, now + 3600000L, 1426712400000L);       }       private static void expect(HourlySchedulerTest test, long fromMillis, long expectedNextTime) {         long actualNextTime = test.getNextTime(fromMillis);         if (actualNextTime != expectedNextTime) {             System.out.println("Test failed.  Expected: "                     + new Date(expectedNextTime) + " (" + expectedNextTime + "), but found "                     + new Date(actualNextTime) + " (" + actualNextTime + ")");         } else {             System.out.println("Test passed.  "  + new Date(actualNextTime));         }     }   }

  • 

    By Dele Taylor - March 22, 2015 3:58 AM Reply

    +1 for showing recursion instead of iteration.

    I probably wouldn’t do this in prod code because of the overhead in calling methods. I’d also suggest making minutesList a field and moving its initialization to the constructor to save time and memory.

• 

  By Tomm Carr - March 22, 2015 2:18 AM Reply

  Just found your site. Here is my first ever entry.

  public class HourlySchedulerTest{ private static long MillisPerMinute = 60 * 1000; private static long MillisPerHour = 60 * 60 * 1000; private long[] mStartingTimes; /** * Accepts the minutes past each hour that an event can start (for example 0, 15, 30, and 45). * The times may be in any order (15, 45, 0, 30) but must be between 0 and 59. * * Note: no checking is performed to ensure values are in the correct range. This is, after all, only a test. */ public HourlySchedulerTest( int... minutesPastHour ){ int lLen = minutesPastHour.length; mStartingTimes = new long[ lLen ]; while( lLen > 0 ){ lLen--; mStartingTimes[lLen] = minutesPastHour[lLen] == 0 ? MillisPerHour : minutesPastHour[lLen] * MillisPerMinute; } } /** * Returns the next start time from the given point in time. */ public long getNextTime( long fromMillis ){ long lHour0 = fromMillis / MillisPerHour * MillisPerHour; // Round down to the hour long lHour1 = lHour0 + MillisPerHour; // Round up to the next hour long lResp = lHour1; // Start at the next hour // Find the smallest value that is still greater than the starting point for( int i = mStartingTimes.length - 1; i >= 0; i-- ){ lHour1 = lHour0 + mStartingTimes[i]; if( lHour1 > fromMillis && lHour1 < lResp ){ lResp = lHour1; } } return lResp; } public static void main( String[] args ){ HourlySchedulerTest test = new HourlySchedulerTest( 0, 15, 30, 45 ); final long now = 1426708139391L; // Wed Mar 18 15:48:59 2015 expect( test, now, 1426708800000L ); expect( test, now + 900000L, 1426709700000L ); expect( test, now + 1800000, 1426710600000L ); expect( test, now + 2700000L, 1426711500000L ); expect( test, now + 3600000L, 1426712400000L ); } private static void expect( HourlySchedulerTest test, long fromMillis, long expectedNextTime ){ long actualNextTime = test.getNextTime( fromMillis ); if( actualNextTime != expectedNextTime ){ System.out.println( "Test failed. Expected: " + new Date( expectedNextTime ) + " (" + expectedNextTime + "), but found " + new Date( actualNextTime ) + " (" + actualNextTime + ")" ); } else{ System.out.println( "Test passed. " + new Date( actualNextTime ) ); } } }

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67

  public class HourlySchedulerTest{       private static long MillisPerMinute = 60 * 1000;     private static long MillisPerHour = 60 * 60 * 1000;     private long[] mStartingTimes;       /**      * Accepts the minutes past each hour that an event can start (for example 0, 15, 30, and 45).      * The times may be in any order (15, 45, 0, 30) but must be between 0 and 59.      *      * Note: no checking is performed to ensure values are in the correct range. This is, after all, only a test.      */     public HourlySchedulerTest( int... minutesPastHour ){         int lLen = minutesPastHour.length;         mStartingTimes = new long[ lLen ];         while( lLen > 0 ){             lLen--;             mStartingTimes[lLen] = minutesPastHour[lLen] == 0                                    ? MillisPerHour                                    : minutesPastHour[lLen] * MillisPerMinute;         }     }       /**      * Returns the next start time from the given point in time.      */     public long getNextTime( long fromMillis ){         long lHour0 = fromMillis / MillisPerHour * MillisPerHour; // Round down to the hour         long lHour1 = lHour0 + MillisPerHour; // Round up to the next hour         long lResp = lHour1; // Start at the next hour           // Find the smallest value that is still greater than the starting point         for( int i = mStartingTimes.length - 1; i >= 0; i-- ){             lHour1 = lHour0 + mStartingTimes[i];             if( lHour1 > fromMillis && lHour1 < lResp ){                 lResp = lHour1;             }         }         return lResp;     }       public static void main( String[] args ){           HourlySchedulerTest test = new HourlySchedulerTest( 0, 15, 30, 45 );           final long now = 1426708139391L;  // Wed Mar 18 15:48:59 2015           expect( test, now, 1426708800000L );         expect( test, now + 900000L, 1426709700000L );         expect( test, now + 1800000, 1426710600000L );         expect( test, now + 2700000L, 1426711500000L );         expect( test, now + 3600000L, 1426712400000L );       }       private static void expect( HourlySchedulerTest test, long fromMillis, long expectedNextTime ){         long actualNextTime = test.getNextTime( fromMillis );         if( actualNextTime != expectedNextTime ){             System.out.println( "Test failed.  Expected: "                     + new Date( expectedNextTime ) + " (" + expectedNextTime + "), but found "                     + new Date( actualNextTime ) + " (" + actualNextTime + ")" );         }         else{             System.out.println( "Test passed.  " + new Date( actualNextTime ) );         }     } }

  • 

    By Tomm Carr - March 22, 2015 2:22 AM Reply

    OK, so I don’t know how to post code and there are not any obvious instructions.

    • 

      By Dele Taylor - March 22, 2015 3:45 AM Reply

      No worries. I surrounded your code with the PRE tag and one of the WordPress plugins figured it out.

      Thanks for sharing the fewest lines of code so far Tomm 🙂

• 

  By Philippe FERY - March 22, 2015 4:04 PM Reply

  Just for fun: less lines of code. But I agree, it’s not really readable 🙂

  package hourlyscheduler; import java.util.ArrayList; import java.util.Collections; import java.util.Date; import java.util.List; /** * This class represents a fixed hourly schedule. * * It can tell you the next start time for an event after a given point in time. * * You first define the minutes past each hour that an event can occur (for * example HH:00, HH:15, HH:30, and HH:45). Then you call * {@link #getNextTime(long)} to find the next occurrence from any point in * time. In the above scenario, passing in 4:23 PM today should return 4:30 PM * today. * */ public class HourlySchedulerTest { private List millis; /** * Accepts the minutes past each hour that an event can start (for example * 0, 15, 30, and 45). * */ public HourlySchedulerTest(int... minutesPastHour) { millis = new ArrayList(); for (int mins : minutesPastHour) millis.add((long) mins * 60 * 1000); Collections.sort(millis); } /** * Returns the next start time from the given point in time. */ public long getNextTime(long fromMillis) { long nextTime = 0L; int i=0; for (i = 0; fromMillis % 3600000 >= (nextTime = millis.get(i%millis.size()))+((int)(i/millis.size()))*3600000;i++) {} return fromMillis-fromMillis % 3600000+nextTime+((int)(i/millis.size()))*3600000; } public static void main(String[] args) { HourlySchedulerTest test = new HourlySchedulerTest(0, 15, 30, 45); final long now = 1426708139391L; // Wed Mar 18 15:48:59 2015 expect(test, now, 1426708800000L); expect(test, now + 900000L, 1426709700000L); expect(test, now + 1800000, 1426710600000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426712400000L); test = new HourlySchedulerTest(15, 45); expect(test, now + 900000L, 1426709700000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426713300000L); } private static void expect(HourlySchedulerTest test, long fromMillis, long expectedNextTime) { long actualNextTime = test.getNextTime(fromMillis); if (actualNextTime != expectedNextTime) { System.out.println("Test failed. Expected: " + new Date(expectedNextTime) + " (" + expectedNextTime + "), but found " + new Date(actualNextTime) + " (" + actualNextTime + ")"); } else { System.out.println("Test passed. " + new Date(actualNextTime)); } } }

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

  package hourlyscheduler;   import java.util.ArrayList; import java.util.Collections; import java.util.Date; import java.util.List;   /** * This class represents a fixed hourly schedule. * * It can tell you the next start time for an event after a given point in time. * * You first define the minutes past each hour that an event can occur (for * example HH:00, HH:15, HH:30, and HH:45). Then you call * {@link #getNextTime(long)} to find the next occurrence from any point in * time. In the above scenario, passing in 4:23 PM today should return 4:30 PM * today. * */ public class HourlySchedulerTest { private List millis;   /** * Accepts the minutes past each hour that an event can start (for example * 0, 15, 30, and 45). * */ public HourlySchedulerTest(int... minutesPastHour) { millis = new ArrayList(); for (int mins : minutesPastHour) millis.add((long) mins * 60 * 1000); Collections.sort(millis); }   /** * Returns the next start time from the given point in time. */ public long getNextTime(long fromMillis) { long nextTime = 0L; int i=0; for (i = 0;  fromMillis % 3600000 >= (nextTime = millis.get(i%millis.size()))+((int)(i/millis.size()))*3600000;i++) {} return fromMillis-fromMillis % 3600000+nextTime+((int)(i/millis.size()))*3600000; }   public static void main(String[] args) {   HourlySchedulerTest test = new HourlySchedulerTest(0, 15, 30, 45);   final long now = 1426708139391L; // Wed Mar 18 15:48:59 2015   expect(test, now, 1426708800000L); expect(test, now + 900000L, 1426709700000L); expect(test, now + 1800000, 1426710600000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426712400000L);   test = new HourlySchedulerTest(15, 45); expect(test, now + 900000L, 1426709700000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426713300000L); }   private static void expect(HourlySchedulerTest test, long fromMillis, long expectedNextTime) { long actualNextTime = test.getNextTime(fromMillis); if (actualNextTime != expectedNextTime) { System.out.println("Test failed.  Expected: " + new Date(expectedNextTime) + " (" + expectedNextTime + "), but found " + new Date(actualNextTime) + " (" + actualNextTime + ")"); } else { System.out.println("Test passed.  " + new Date(actualNextTime)); } } }

  • 

    By Dele Taylor - March 23, 2015 12:41 PM Reply

    nice 😉

• 

  By Blake Rogers - March 24, 2015 10:50 AM Reply

  package dev.blake.dele; import java.util.ArrayList; import java.util.Calendar; import java.util.Collections; import java.util.Date; import java.util.List; /** * This class represents a fixed hourly schedule. * * It can tell you the next start time for an event after a given point in time. * * You first define the minutes past each hour that an event can occur (for * example HH:00, HH:15, HH:30, and HH:45). Then you call * {@link #getNextTime(long)} to find the next occurrence from any point in * time. In the above scenario, passing in 4:23 PM today should return 4:30 PM * today. * */ public class HourlySchedulerBadderReduxFix { private List startMinuteList; /** * Accepts the minutes past each hour that an event can start (for example * 0, 15, 30, and 45). * */ public HourlySchedulerBadderReduxFix(int... minutesPastHour) { startMinuteList = new ArrayList(); for(int min:minutesPastHour){ startMinuteList.add(min); } } /** * Returns the next start time from the given point in time. */ public long getNextTime(long fromMillis) { Date d = new Date(fromMillis); Calendar currentTime = Calendar.getInstance(); currentTime.setTime(d); int hour = currentTime.get(Calendar.HOUR); List startTimeList = new ArrayList();; for(int i=0;i<startMinuteList.size();i++){ Calendar target = Calendar.getInstance(); target.setTime(d); target.set(Calendar.HOUR, hour); target.set(Calendar.MINUTE, startMinuteList.get(i)); target.set(Calendar.SECOND, 0); target.set(Calendar.MILLISECOND, 0); if(target.before(currentTime)){ target.set(Calendar.HOUR, hour+1); } startTimeList.add(target); } Collections.sort(startTimeList); return startTimeList.get(0).getTimeInMillis(); } public static void main(String[] args) { HourlySchedulerBadderReduxFix test = new HourlySchedulerBadderReduxFix(0, 15, 30, 45); final long now = 1426708139391L; // Wed Mar 18 15:48:59 2015 1426718939391 expect(test, now, 1426708800000L); expect(test, now + 900000L, 1426709700000L); expect(test, now + 1800000, 1426710600000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426712400000L); test = new HourlySchedulerBadderReduxFix(15, 45); expect(test, now + 900000L, 1426709700000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426713300000L); } private static void expect(HourlySchedulerBadderReduxFix test, long fromMillis, long expectedNextTime) { long actualNextTime = test.getNextTime(fromMillis); if (actualNextTime != expectedNextTime) { System.out.println("Test failed. Expected: " + new Date(expectedNextTime) + " (" + expectedNextTime + "), but found " + new Date(actualNextTime) + " (" + actualNextTime + " diff="+ (actualNextTime - expectedNextTime) + ")"); } else { System.out.println("Test passed. " + new Date(actualNextTime)); } } }

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85

  package dev.blake.dele;   import java.util.ArrayList; import java.util.Calendar; import java.util.Collections; import java.util.Date; import java.util.List;   /** * This class represents a fixed hourly schedule. * * It can tell you the next start time for an event after a given point in time. * * You first define the minutes past each hour that an event can occur (for * example HH:00, HH:15, HH:30, and HH:45). Then you call * {@link #getNextTime(long)} to find the next occurrence from any point in * time. In the above scenario, passing in 4:23 PM today should return 4:30 PM * today. * */ public class HourlySchedulerBadderReduxFix { private List startMinuteList; /** * Accepts the minutes past each hour that an event can start (for example * 0, 15, 30, and 45). * */ public HourlySchedulerBadderReduxFix(int... minutesPastHour) { startMinuteList = new ArrayList(); for(int min:minutesPastHour){ startMinuteList.add(min); } } /** * Returns the next start time from the given point in time. */ public long getNextTime(long fromMillis) { Date d = new Date(fromMillis); Calendar currentTime = Calendar.getInstance(); currentTime.setTime(d); int hour = currentTime.get(Calendar.HOUR); List startTimeList = new ArrayList();; for(int i=0;i<startMinuteList.size();i++){ Calendar target = Calendar.getInstance(); target.setTime(d); target.set(Calendar.HOUR, hour); target.set(Calendar.MINUTE, startMinuteList.get(i)); target.set(Calendar.SECOND, 0); target.set(Calendar.MILLISECOND, 0); if(target.before(currentTime)){ target.set(Calendar.HOUR, hour+1); } startTimeList.add(target); } Collections.sort(startTimeList); return startTimeList.get(0).getTimeInMillis(); }   public static void main(String[] args) { HourlySchedulerBadderReduxFix test = new HourlySchedulerBadderReduxFix(0, 15, 30, 45); final long now = 1426708139391L; // Wed Mar 18 15:48:59 2015  1426718939391 expect(test, now, 1426708800000L); expect(test, now + 900000L, 1426709700000L); expect(test, now + 1800000, 1426710600000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426712400000L); test = new HourlySchedulerBadderReduxFix(15, 45); expect(test, now + 900000L, 1426709700000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426713300000L); }   private static void expect(HourlySchedulerBadderReduxFix test, long fromMillis, long expectedNextTime) { long actualNextTime = test.getNextTime(fromMillis); if (actualNextTime != expectedNextTime) { System.out.println("Test failed.  Expected: " + new Date(expectedNextTime) + " (" + expectedNextTime + "), but found " + new Date(actualNextTime) + " (" + actualNextTime + " diff="+ (actualNextTime - expectedNextTime) + ")"); } else { System.out.println("Test passed.  " + new Date(actualNextTime)); } } }

• 

  By Blake Rogers - March 24, 2015 1:58 PM Reply

  A couple minor tweaks, removed extraneous objects, etc. It doesn’t perform well due to Calendar class calls though.

  import java.util.Arrays; import java.util.Calendar; import java.util.Date; /** * This class represents a fixed hourly schedule. * * It can tell you the next start time for an event after a given point in time. * * You first define the minutes past each hour that an event can occur (for * example HH:00, HH:15, HH:30, and HH:45). Then you call * {@link #getNextTime(long)} to find the next occurrence from any point in * time. In the above scenario, passing in 4:23 PM today should return 4:30 PM * today. * */ public class HourlySchedulerTest { private int[] startMinuteArr; /** * Accepts the minutes past each hour that an event can start (for example * 0, 15, 30, and 45). * */ public HourlySchedulerTest(int... minutesPastHour) { startMinuteArr = minutesPastHour; } /** * Returns the next start time from the given point in time. */ public long getNextTime(long fromMillis) { Calendar currentTime = Calendar.getInstance(); currentTime.setTimeInMillis(fromMillis); int hour = currentTime.get(Calendar.HOUR); Calendar target = (Calendar) currentTime.clone(); target.set(Calendar.SECOND, 0); target.set(Calendar.MILLISECOND, 0); long[] targetTimesInMS = new long[startMinuteArr.length]; for(int i=0;i<startMinuteArr.length;i++){ target.set(Calendar.HOUR, hour); target.set(Calendar.MINUTE, startMinuteArr[i]); if( target.before(currentTime)){ target.set(Calendar.HOUR, hour+1); } targetTimesInMS[i]= target.getTimeInMillis(); } Arrays.sort(targetTimesInMS); return targetTimesInMS[0]; } public static void main(String[] args) { HourlySchedulerTest test = new HourlySchedulerTest(0, 15, 30, 45); final long now = 1426708139391L; // Wed Mar 18 15:48:59 2015 1426718939391 expect(test, now, 1426708800000L); expect(test, now + 900000L, 1426709700000L); expect(test, now + 1800000, 1426710600000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426712400000L); test = new HourlySchedulerTest(15, 45); expect(test, now + 900000L, 1426709700000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426713300000L); } private static void expect(HourlySchedulerTest test, long fromMillis, long expectedNextTime) { long actualNextTime = test.getNextTime(fromMillis); if (actualNextTime != expectedNextTime) { System.out.println("Test failed. Expected: " + new Date(expectedNextTime) + " (" + expectedNextTime + "), but found " + new Date(actualNextTime) + " (" + actualNextTime + " diff="+ (actualNextTime - expectedNextTime) + ")"); } else { System.out.println("Test passed. " + new Date(actualNextTime)); } } }

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79

  import java.util.Arrays; import java.util.Calendar; import java.util.Date;   /** * This class represents a fixed hourly schedule. * * It can tell you the next start time for an event after a given point in time. * * You first define the minutes past each hour that an event can occur (for * example HH:00, HH:15, HH:30, and HH:45). Then you call * {@link #getNextTime(long)} to find the next occurrence from any point in * time. In the above scenario, passing in 4:23 PM today should return 4:30 PM * today. * */ public class HourlySchedulerTest { private int[] startMinuteArr; /** * Accepts the minutes past each hour that an event can start (for example * 0, 15, 30, and 45). * */ public HourlySchedulerTest(int... minutesPastHour) { startMinuteArr = minutesPastHour; } /** * Returns the next start time from the given point in time. */ public long getNextTime(long fromMillis) { Calendar currentTime = Calendar.getInstance(); currentTime.setTimeInMillis(fromMillis); int hour = currentTime.get(Calendar.HOUR); Calendar target = (Calendar) currentTime.clone(); target.set(Calendar.SECOND, 0); target.set(Calendar.MILLISECOND, 0); long[] targetTimesInMS = new long[startMinuteArr.length]; for(int i=0;i<startMinuteArr.length;i++){ target.set(Calendar.HOUR, hour); target.set(Calendar.MINUTE,  startMinuteArr[i]); if( target.before(currentTime)){ target.set(Calendar.HOUR, hour+1); } targetTimesInMS[i]= target.getTimeInMillis(); } Arrays.sort(targetTimesInMS); return targetTimesInMS[0]; }   public static void main(String[] args) { HourlySchedulerTest test = new HourlySchedulerTest(0, 15, 30, 45); final long now = 1426708139391L; // Wed Mar 18 15:48:59 2015  1426718939391 expect(test, now, 1426708800000L); expect(test, now + 900000L, 1426709700000L); expect(test, now + 1800000, 1426710600000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426712400000L); test = new HourlySchedulerTest(15, 45); expect(test, now + 900000L, 1426709700000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426713300000L); } private static void expect(HourlySchedulerTest test, long fromMillis, long expectedNextTime) { long actualNextTime = test.getNextTime(fromMillis); if (actualNextTime != expectedNextTime) { System.out.println("Test failed.  Expected: " + new Date(expectedNextTime) + " (" + expectedNextTime + "), but found " + new Date(actualNextTime) + " (" + actualNextTime + " diff="+ (actualNextTime - expectedNextTime) + ")"); } else { System.out.println("Test passed.  " + new Date(actualNextTime)); } } }

• 

  By Blake Rogers - March 24, 2015 7:44 PM Reply

  Okay, no Calendar. This one performs < 300MS for 1M.

  import java.util.Arrays; import java.util.Date; /** * This class represents a fixed hourly schedule. * * It can tell you the next start time for an event after a given point in time. * * You first define the minutes past each hour that an event can occur (for * example HH:00, HH:15, HH:30, and HH:45). Then you call * {@link #getNextTime(long)} to find the next occurrence from any point in * time. In the above scenario, passing in 4:23 PM today should return 4:30 PM * today. * */ public class HourlySchedulerGo { private static long[] startMillisArr; private static long[] startTargetsMillisArr; /** * Accepts the minutes past each hour that an event can start (for example * 0, 15, 30, and 45). * */ public HourlySchedulerGo(int... minutesPastHour) { startMillisArr = new long[minutesPastHour.length]; for(int i = 0; i < minutesPastHour.length; i++){ startMillisArr[i] = (long) minutesPastHour[i] * 1000 * 60; } startTargetsMillisArr = new long[startMillisArr.length]; } /** * Returns the next start time from the given point in time. */ public long getNextTime(long fromMillis) { long hoursBase = fromMillis - (fromMillis % 3600000L); for(int i=0;i<startMillisArr.length;i++){ long target = hoursBase + startMillisArr[i]; if( target < fromMillis ){ target += 3600000L; } startTargetsMillisArr[i] = target; } Arrays.sort(startTargetsMillisArr); return startTargetsMillisArr[0]; } public static void run(){ HourlySchedulerGo test = new HourlySchedulerGo(0, 15, 30, 45); final long now = 1426708139391L; // Wed Mar 18 15:48:59 2015 1426718939391 expect(test, now, 1426708800000L); expect(test, now + 900000L, 1426709700000L); expect(test, now + 1800000, 1426710600000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426712400000L); test = new HourlySchedulerGo(15, 45); expect(test, now + 900000L, 1426709700000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426713300000L); } public static void main(String[] args) { long start = new Date().getTime(); int iter = 1000000; // reduced 1M to < 300ms for(int i = 0; i< iter; i++){ run(); } long end = new Date().getTime(); long time = end - start; System.out.println("Total time: " + new Date(time).getTime()); } private static void expect(HourlySchedulerGo test, long fromMillis, long expectedNextTime) { long actualNextTime = test.getNextTime(fromMillis); if (actualNextTime != expectedNextTime) { System.out.println("Test failed. Expected: " + new Date(expectedNextTime) + " (" + expectedNextTime + "), but found " + new Date(actualNextTime) + " (" + actualNextTime + " diff="+ (actualNextTime - expectedNextTime) + ")"); } else { //System.out.println("Test passed. " + new Date(actualNextTime)); } } }

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92

  import java.util.Arrays; import java.util.Date;     /** * This class represents a fixed hourly schedule. * * It can tell you the next start time for an event after a given point in time. * * You first define the minutes past each hour that an event can occur (for * example HH:00, HH:15, HH:30, and HH:45). Then you call * {@link #getNextTime(long)} to find the next occurrence from any point in * time. In the above scenario, passing in 4:23 PM today should return 4:30 PM * today. * */ public class HourlySchedulerGo {   private static long[] startMillisArr; private static long[] startTargetsMillisArr;   /** * Accepts the minutes past each hour that an event can start (for example * 0, 15, 30, and 45). * */ public HourlySchedulerGo(int... minutesPastHour) { startMillisArr = new long[minutesPastHour.length]; for(int i = 0; i < minutesPastHour.length; i++){ startMillisArr[i] = (long) minutesPastHour[i] * 1000 * 60; } startTargetsMillisArr = new long[startMillisArr.length]; } /** * Returns the next start time from the given point in time. */ public long getNextTime(long fromMillis) { long hoursBase = fromMillis - (fromMillis % 3600000L); for(int i=0;i<startMillisArr.length;i++){ long target = hoursBase + startMillisArr[i]; if( target < fromMillis ){ target += 3600000L; } startTargetsMillisArr[i] = target; } Arrays.sort(startTargetsMillisArr); return startTargetsMillisArr[0]; }     public static void run(){ HourlySchedulerGo test = new HourlySchedulerGo(0, 15, 30, 45); final long now = 1426708139391L; // Wed Mar 18 15:48:59 2015  1426718939391   expect(test, now, 1426708800000L); expect(test, now + 900000L, 1426709700000L); expect(test, now + 1800000, 1426710600000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426712400000L);   test = new HourlySchedulerGo(15, 45); expect(test, now + 900000L, 1426709700000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426713300000L);     }   public static void main(String[] args) { long start = new Date().getTime(); int iter = 1000000; // reduced 1M to < 300ms for(int i = 0; i< iter; i++){ run(); } long end = new Date().getTime(); long time = end - start; System.out.println("Total time: " + new Date(time).getTime()); }   private static void expect(HourlySchedulerGo test, long fromMillis, long expectedNextTime) { long actualNextTime = test.getNextTime(fromMillis); if (actualNextTime != expectedNextTime) { System.out.println("Test failed.  Expected: " + new Date(expectedNextTime) + " (" + expectedNextTime + "), but found " + new Date(actualNextTime) + " (" + actualNextTime + " diff="+ (actualNextTime - expectedNextTime) + ")"); } else { //System.out.println("Test passed.  " + new Date(actualNextTime)); } } }

  • 

    By Dele Taylor - March 24, 2015 10:30 PM Reply

    Blake – you get points for testing against the 15 and 45 minute cases 🙂

    You get more points for removing the Calendar class, our implementation doesn’t use it (or Date) either. That may make our implementations vulnerable to daylight savings time and leap year cases, but I haven’t tested them yet.

    BTW, your test takes about 170 milliseconds for 1 million calls on my i7, but I know for a fact you can cut it in half 😉 Hint: do you need to call Arrays.sort(startTargetsMillisArr); inside getNextTime?

• 

  By Blake Rogers - March 25, 2015 4:49 PM Reply

  Thanks for the feedback, Dele. Here I do a basic sort during the insert. Results in twice the (relative) speed. My metrics are from an i5. The metric is actually like 8 million calls, since each “run” tests the algorithm 8 times, and each algorithm searching either shorter (2) or longer (4) array.

  package dev.blake.dele; import java.util.Date; /** * This class represents a fixed hourly schedule. * * It can tell you the next start time for an event after a given point in time. * * You first define the minutes past each hour that an event can occur (for * example HH:00, HH:15, HH:30, and HH:45). Then you call * {@link #getNextTime(long)} to find the next occurrence from any point in * time. In the above scenario, passing in 4:23 PM today should return 4:30 PM * today. * */ public class HourlySchedulerGoBetter { private static long[] startMillisArr; private static long[] startTargetsMillisArr; /** * Accepts the minutes past each hour that an event can start (for example * 0, 15, 30, and 45). * */ public HourlySchedulerGoBetter(int... minutesPastHour) { startMillisArr = new long[minutesPastHour.length]; for(int i = 0; i < minutesPastHour.length; i++){ startMillisArr[i] = (long) minutesPastHour[i] * 1000 * 60; } startTargetsMillisArr = new long[startMillisArr.length]; } /** * Returns the next start time from the given point in time. */ public long getNextTime(long fromMillis) { for(int i=0;i<startMillisArr.length;i++){ long target = ( fromMillis - (fromMillis % 3600000L) ) + startMillisArr[i]; if( target < fromMillis ){ target += 3600000L; } startTargetsMillisArr[i]=target; //pre-sorting array during insert doubles performance, since it doesn't need much sorting if(i>0){ for(int j=i;j > 0 ;j--){ if(startTargetsMillisArr[j] < startTargetsMillisArr[j-1]){ long tempNow = startTargetsMillisArr[j]; startTargetsMillisArr[j]= startTargetsMillisArr[j-1]; startTargetsMillisArr[j-1]=tempNow; } } } } //Arrays.sort(startTargetsMillisArr); return startTargetsMillisArr[0]; } public static void run(){ HourlySchedulerGoBetter test = new HourlySchedulerGoBetter(0, 15, 30, 45); final long now = 1426708139391L; // Wed Mar 18 15:48:59 2015 1426718939391 expect(test, now, 1426708800000L); expect(test, now + 900000L, 1426709700000L); expect(test, now + 1800000, 1426710600000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426712400000L); test = new HourlySchedulerGoBetter(15, 45); expect(test, now + 900000L, 1426709700000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426713300000L); } public static void main(String[] args) { long start = new Date().getTime(); int iter = 1000000; for(int i = 0; i< iter; i++){ run(); } long end = new Date().getTime(); long time = end - start; System.out.println("Total time: " + new Date(time).getTime()); } private static void expect(HourlySchedulerGoBetter test, long fromMillis, long expectedNextTime) { //System.out.println("Time : " + new Date(fromMillis)); long actualNextTime = test.getNextTime(fromMillis); if (actualNextTime != expectedNextTime) { System.out.println("Test failed. Expected: " + new Date(expectedNextTime) + " (" + expectedNextTime + "), but found " + new Date(actualNextTime) + " (" + actualNextTime + " diff="+ (actualNextTime - expectedNextTime) + ")"); } else { //System.out.println("Test passed. " + new Date(actualNextTime)); } } }

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103

  package dev.blake.dele;       import java.util.Date;     /** * This class represents a fixed hourly schedule. * * It can tell you the next start time for an event after a given point in time. * * You first define the minutes past each hour that an event can occur (for * example HH:00, HH:15, HH:30, and HH:45). Then you call * {@link #getNextTime(long)} to find the next occurrence from any point in * time. In the above scenario, passing in 4:23 PM today should return 4:30 PM * today. * */ public class HourlySchedulerGoBetter {       private static long[] startMillisArr;     private static long[] startTargetsMillisArr;       /**      * Accepts the minutes past each hour that an event can start (for example      * 0, 15, 30, and 45).      *      */     public HourlySchedulerGoBetter(int... minutesPastHour) {         startMillisArr = new long[minutesPastHour.length];         for(int i = 0; i < minutesPastHour.length; i++){             startMillisArr[i] = (long) minutesPastHour[i] * 1000 * 60;                       }         startTargetsMillisArr = new long[startMillisArr.length];     }     /**      * Returns the next start time from the given point in time.      */     public long getNextTime(long fromMillis) {         for(int i=0;i<startMillisArr.length;i++){             long target =  ( fromMillis - (fromMillis % 3600000L) ) + startMillisArr[i];             if( target < fromMillis ){                 target += 3600000L;             }             startTargetsMillisArr[i]=target;             //pre-sorting array during insert doubles performance, since it doesn't need much sorting             if(i>0){                 for(int j=i;j > 0 ;j--){                     if(startTargetsMillisArr[j] < startTargetsMillisArr[j-1]){                         long tempNow = startTargetsMillisArr[j];                         startTargetsMillisArr[j]= startTargetsMillisArr[j-1];                         startTargetsMillisArr[j-1]=tempNow;                     }                 }             }         }         //Arrays.sort(startTargetsMillisArr);         return startTargetsMillisArr[0];       }         public static void run(){         HourlySchedulerGoBetter test = new HourlySchedulerGoBetter(0, 15, 30, 45);         final long now = 1426708139391L; // Wed Mar 18 15:48:59 2015  1426718939391                 expect(test, now, 1426708800000L);         expect(test, now + 900000L, 1426709700000L);         expect(test, now + 1800000, 1426710600000L);         expect(test, now + 2700000L, 1426711500000L);         expect(test, now + 3600000L, 1426712400000L);           test = new HourlySchedulerGoBetter(15, 45);         expect(test, now + 900000L, 1426709700000L);         expect(test, now + 2700000L, 1426711500000L);         expect(test, now + 3600000L, 1426713300000L);     }       public static void main(String[] args) {         long start = new Date().getTime();         int iter = 1000000;         for(int i = 0; i< iter; i++){             run();         }         long end = new Date().getTime();         long time = end - start;         System.out.println("Total time: " + new Date(time).getTime());     }       private static void expect(HourlySchedulerGoBetter test, long fromMillis,             long expectedNextTime) {         //System.out.println("Time : " + new Date(fromMillis));         long actualNextTime = test.getNextTime(fromMillis);         if (actualNextTime != expectedNextTime) {             System.out.println("Test failed.  Expected: "                     + new Date(expectedNextTime) + " (" + expectedNextTime                     + "), but found " + new Date(actualNextTime) + " ("                     + actualNextTime + " diff="+ (actualNextTime - expectedNextTime) + ")");         } else {               //System.out.println("Test passed.  " + new Date(actualNextTime));         }     } }

  • 

    By Dele Taylor - April 1, 2015 5:01 PM Reply

    Blake – it looks like you’re modifying one of the member arrays inside getNextTime. If you can move this to the constructor, you’d have an thread-safe implementation.

    I used to ask developers to give advantages of immutable types like String and BigDecimal. Thread-safety was always a good answer 🙂

• 

  By Anish K George - March 26, 2015 1:28 AM Reply

  What about a bit of Java 8 APIs?

  public class HourlySchedulerTest { private final SortedSet eventStartableMinutesCollection = new TreeSet(); /** * Accepts the minutes past each hour that an event can start (for example * 0, 15, 30, and 45). * */ public HourlySchedulerTest(int... minutesPastHour) { for (int i : minutesPastHour) { eventStartableMinutesCollection.add(Integer.valueOf(i)); } } /** * Returns the next start time from the given point in time. */ public long getNextTime(long fromMillis) { ZonedDateTime suppliedInstant = Instant.ofEpochMilli(fromMillis).atZone(ZoneId.of("UTC")).truncatedTo(ChronoUnit.MINUTES); SortedSet remainingEventStartableMinutesCollectionForSameHour = eventStartableMinutesCollection .tailSet(suppliedInstant.get(ChronoField.MINUTE_OF_HOUR)); return remainingEventStartableMinutesCollectionForSameHour.isEmpty() ? suppliedInstant.plus(Duration.ofHours(1)).with(ChronoField.MINUTE_OF_HOUR, eventStartableMinutesCollection.first().longValue()).toInstant().toEpochMilli() : suppliedInstant.with(ChronoField.MINUTE_OF_HOUR, remainingEventStartableMinutesCollectionForSameHour.first().longValue()).toInstant().toEpochMilli(); }

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

  public class HourlySchedulerTest {   private final SortedSet eventStartableMinutesCollection = new TreeSet();   /** * Accepts the minutes past each hour that an event can start (for example * 0, 15, 30, and 45). * */ public HourlySchedulerTest(int... minutesPastHour) { for (int i : minutesPastHour) { eventStartableMinutesCollection.add(Integer.valueOf(i)); } }   /** * Returns the next start time from the given point in time. */ public long getNextTime(long fromMillis) { ZonedDateTime suppliedInstant = Instant.ofEpochMilli(fromMillis).atZone(ZoneId.of("UTC")).truncatedTo(ChronoUnit.MINUTES); SortedSet remainingEventStartableMinutesCollectionForSameHour = eventStartableMinutesCollection .tailSet(suppliedInstant.get(ChronoField.MINUTE_OF_HOUR));   return remainingEventStartableMinutesCollectionForSameHour.isEmpty() ? suppliedInstant.plus(Duration.ofHours(1)).with(ChronoField.MINUTE_OF_HOUR, eventStartableMinutesCollection.first().longValue()).toInstant().toEpochMilli() : suppliedInstant.with(ChronoField.MINUTE_OF_HOUR, remainingEventStartableMinutesCollectionForSameHour.first().longValue()).toInstant().toEpochMilli(); }

  • 

    By Dele Taylor - April 1, 2015 4:53 PM Reply

    Thanks for sharing. I’m a big fan of fluent interfaces, but this one seems hard to read…

• 

  By Razvan - April 1, 2015 4:39 PM Reply

  import java.util.Arrays; import java.util.Date; import java.util.List; import java.util.Optional; import java.util.concurrent.TimeUnit; import java.util.stream.Collectors; public class HourlySchedulerTest { static final long HOUR_IN_MILLIS = TimeUnit.HOURS.toMillis(1); final List minutes; /** * Accepts the minutes past each hour that an event can start * (for example 0, 15, 30, and 45). * */ public HourlySchedulerTest(int... minutesPastHour) { this.minutes = Arrays.stream(minutesPastHour) .sorted() .map(HourlySchedulerTest::minutesToMillis) .boxed() .collect(Collectors.toList()); } static int minutesToMillis(int x) { return new Long(TimeUnit.MINUTES.toMillis(x)).intValue(); } /** * Returns the next start time from the given point in time. */ public long getNextTime(long fromMillis) { final long minute = fromMillis % HOUR_IN_MILLIS; final Optional result = minutes.stream() .filter(x -> x > minute) .findFirst() .map(x -> (fromMillis - minute) + x); return result.orElseGet(() -> fromMillis - minute + HOUR_IN_MILLIS + minutes.get(0)); } public static void main(String[] args) { HourlySchedulerTest test = new HourlySchedulerTest(0, 15, 30, 45); final long now = 1426708139391L; // Wed Mar 18 15:48:59 2015 expect(test, now, 1426708800000L); expect(test, now + 900000L, 1426709700000L); expect(test, now + 1800000, 1426710600000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426712400000L); } private static void expect(HourlySchedulerTest test, long fromMillis, long expectedNextTime) { long actualNextTime = test.getNextTime(fromMillis); if (actualNextTime != expectedNextTime) { System.out.println("Test failed. Expected: " + new Date(expectedNextTime) + " (" + expectedNextTime + "), but found " + new Date(actualNextTime) + " (" + actualNextTime + ")"); } else { System.out.println("Test passed. " + new Date(actualNextTime)); } } }

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70

  import java.util.Arrays; import java.util.Date; import java.util.List; import java.util.Optional; import java.util.concurrent.TimeUnit; import java.util.stream.Collectors;   public class HourlySchedulerTest {       static final long HOUR_IN_MILLIS = TimeUnit.HOURS.toMillis(1);       final List minutes;       /**      * Accepts the minutes past each hour that an event can start      * (for example 0, 15, 30, and 45).      *      */     public HourlySchedulerTest(int... minutesPastHour) {         this.minutes = Arrays.stream(minutesPastHour)                 .sorted()                 .map(HourlySchedulerTest::minutesToMillis)                 .boxed()                 .collect(Collectors.toList());     }       static int minutesToMillis(int x) {         return new Long(TimeUnit.MINUTES.toMillis(x)).intValue();     }       /**      * Returns the next start time from the given point in time.      */     public long getNextTime(long fromMillis) {           final long minute = fromMillis % HOUR_IN_MILLIS;         final Optional result = minutes.stream()                 .filter(x -> x > minute)                 .findFirst()                 .map(x -> (fromMillis - minute) + x);           return result.orElseGet(() -> fromMillis - minute + HOUR_IN_MILLIS + minutes.get(0));     }       public static void main(String[] args) {           HourlySchedulerTest test = new HourlySchedulerTest(0, 15, 30, 45);           final long now = 1426708139391L;  // Wed Mar 18 15:48:59 2015           expect(test, now, 1426708800000L);         expect(test, now + 900000L, 1426709700000L);         expect(test, now + 1800000, 1426710600000L);         expect(test, now + 2700000L, 1426711500000L);         expect(test, now + 3600000L, 1426712400000L);       }       private static void expect(HourlySchedulerTest test, long fromMillis, long expectedNextTime) {         long actualNextTime = test.getNextTime(fromMillis);         if (actualNextTime != expectedNextTime) {             System.out.println("Test failed.  Expected: "                     + new Date(expectedNextTime) + " (" + expectedNextTime + "), but found "                     + new Date(actualNextTime) + " (" + actualNextTime + ")");         } else {             System.out.println("Test passed.  "  + new Date(actualNextTime));         }     }   }

  • 

    By Dele Taylor - April 1, 2015 5:10 PM Reply

    Razvan – this is a very sweet use of fluent APIs 🙂 You’d get points for the most readable so far — including against our own — code is for people after all.

    BTW, your minutesToMillis method should probably return a long instead of int. I’d probably also typecast intValue() to a long instead of creating a java.lang.Long instance, but it’d be very hard to measure the slight performance difference.

    Thanks for sharing. Cheers.

• 

  By Nadine - May 13, 2016 10:28 AM Reply

  package com.northconcepts.exception; import java.util.Arrays; import java.util.Date; /** * This class represents a fixed hourly schedule. * * It can tell you the next start time for an event after a given point in time. * * You first define the minutes past each hour that an event can occur (for * example HH:00, HH:15, HH:30, and HH:45). Then you call * {@link #getNextTime(long)} to find the next occurrence from any point in * time. In the above scenario, passing in 4:23 PM today should return 4:30 PM * today. * */ public class HourlySchedulerTest { private final Long[] millisPastHour; /** * Accepts the minutes past each hour that an event can start (for example * 0, 15, 30, and 45). unit is minute; */ public HourlySchedulerTest(final int... minutesPastHour) { millisPastHour = new Long[minutesPastHour.length]; for (int i = 0; i < minutesPastHour.length; i++) { millisPastHour[i] = (long) ((minutesPastHour[i] == 0 ? 60 : minutesPastHour[i]) * 60 * 1000); } Arrays.sort(millisPastHour); } /** * Returns the next start time from the given point in time. */ public long getNextTime(final long fromMillis) { final long millisLessThanHour = fromMillis % (60 * 60 * 1000); final long hoursInMillis = fromMillis - millisLessThanHour; final int result = Arrays.binarySearch(millisPastHour, millisLessThanHour); int index = result millisPastHour.length - 1 ? hoursInMillis + 60 * 60 * 1000 + millisPastHour[0] : hoursInMillis + millisPastHour[index]; return nextTimeInMillis; } public static void main(String[] args) { HourlySchedulerTest test = new HourlySchedulerTest(0, 15, 30, 45); final long now = 1426708139391L; // Wed Mar 18 15:48:59 2015 expect(test, now, 1426708800000L); expect(test, now + 900000L, 1426709700000L); expect(test, now + 1800000, 1426710600000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426712400000L); } private static void expect(HourlySchedulerTest test, long fromMillis, long expectedNextTime) { long actualNextTime = test.getNextTime(fromMillis); if (actualNextTime != expectedNextTime) { System.out.println("Test failed. Expected: " + new Date(expectedNextTime) + " (" + expectedNextTime + "), but found " + new Date(actualNextTime) + " (" + actualNextTime + ")"); } else { System.out.println("Test passed. " + new Date(actualNextTime)); } } }

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71

  package com.northconcepts.exception;   import java.util.Arrays; import java.util.Date;   /** * This class represents a fixed hourly schedule. * * It can tell you the next start time for an event after a given point in time. * * You first define the minutes past each hour that an event can occur (for * example HH:00, HH:15, HH:30, and HH:45). Then you call * {@link #getNextTime(long)} to find the next occurrence from any point in * time. In the above scenario, passing in 4:23 PM today should return 4:30 PM * today. * */ public class HourlySchedulerTest {       private final Long[] millisPastHour;       /**      * Accepts the minutes past each hour that an event can start (for example      * 0, 15, 30, and 45). unit is minute;      */     public HourlySchedulerTest(final int... minutesPastHour) {         millisPastHour = new Long[minutesPastHour.length];         for (int i = 0; i < minutesPastHour.length; i++) {             millisPastHour[i] = (long) ((minutesPastHour[i] == 0 ? 60 : minutesPastHour[i]) * 60 * 1000);         }         Arrays.sort(millisPastHour);     }       /**      * Returns the next start time from the given point in time.      */     public long getNextTime(final long fromMillis) {         final long millisLessThanHour = fromMillis % (60 * 60 * 1000);         final long hoursInMillis = fromMillis - millisLessThanHour;           final int result = Arrays.binarySearch(millisPastHour, millisLessThanHour);         int index = result  millisPastHour.length - 1                 ? hoursInMillis + 60 * 60 * 1000 + millisPastHour[0] : hoursInMillis + millisPastHour[index];           return nextTimeInMillis;     }       public static void main(String[] args) {           HourlySchedulerTest test = new HourlySchedulerTest(0, 15, 30, 45);           final long now = 1426708139391L; // Wed Mar 18 15:48:59 2015           expect(test, now, 1426708800000L);         expect(test, now + 900000L, 1426709700000L);         expect(test, now + 1800000, 1426710600000L);         expect(test, now + 2700000L, 1426711500000L);         expect(test, now + 3600000L, 1426712400000L);       }       private static void expect(HourlySchedulerTest test, long fromMillis, long expectedNextTime) {         long actualNextTime = test.getNextTime(fromMillis);         if (actualNextTime != expectedNextTime) {             System.out.println("Test failed.  Expected: " + new Date(expectedNextTime) + " (" + expectedNextTime                     + "), but found " + new Date(actualNextTime) + " (" + actualNextTime + ")");         } else {             System.out.println("Test passed.  " + new Date(actualNextTime));         }     } }

  • 

    By Nadine - May 17, 2016 6:58 AM Reply

    I’m not sure what happened, but some lines are missing :-P. Here is the complete implementation:

    package com.northconcepts.exception; import java.util.Arrays; import java.util.Date; /** * This class represents a fixed hourly schedule. * * It can tell you the next start time for an event after a given point in time. * * You first define the minutes past each hour that an event can occur (for * example HH:00, HH:15, HH:30, and HH:45). Then you call * {@link #getNextTime(long)} to find the next occurrence from any point in * time. In the above scenario, passing in 4:23 PM today should return 4:30 PM * today. * */ public class HourlySchedulerTest { private Long[] millisPastHour; /** * Accepts the minutes past each hour that an event can start (for example * 0, 15, 30, and 45). unit is minute; */ public HourlySchedulerTest(int... minutesPastHour) { millisPastHour = new Long[minutesPastHour.length]; for (int i = 0; i < minutesPastHour.length; i++) { millisPastHour[i] = (long) ((minutesPastHour[i] == 0 ? 60 : minutesPastHour[i]) * 60 * 1000); } Arrays.sort(millisPastHour); } /** * Returns the next start time from the given point in time. */ public long getNextTime(final long fromMillis) { final long millisLessThanHour = fromMillis % (60 * 60 * 1000); final long hoursInMillis = fromMillis - millisLessThanHour; final int pos = Arrays.binarySearch(millisPastHour, millisLessThanHour); int result = pos millisPastHour.length - 1 ? hoursInMillis + 60 * 60 * 1000 + millisPastHour[0] : hoursInMillis + millisPastHour[result]; return nextTimeInMillis; } public static void main(String[] args) { HourlySchedulerTest test = new HourlySchedulerTest(0, 15, 30, 45); final long now = 1426708139391L; // Wed Mar 18 15:48:59 2015 expect(test, now, 1426708800000L); expect(test, now + 900000L, 1426709700000L); expect(test, now + 1800000, 1426710600000L); expect(test, now + 2700000L, 1426711500000L); expect(test, now + 3600000L, 1426712400000L); } private static void expect(HourlySchedulerTest test, long fromMillis, long expectedNextTime) { long actualNextTime = test.getNextTime(fromMillis); if (actualNextTime != expectedNextTime) { System.out.println("Test failed. Expected: " + new Date(expectedNextTime) + " (" + expectedNextTime + "), but found " + new Date(actualNextTime) + " (" + actualNextTime + ")"); } else { System.out.println("Test passed. " + new Date(actualNextTime)); } } }

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

    package com.northconcepts.exception;   import java.util.Arrays; import java.util.Date;   /** * This class represents a fixed hourly schedule. * * It can tell you the next start time for an event after a given point in time. * * You first define the minutes past each hour that an event can occur (for * example HH:00, HH:15, HH:30, and HH:45). Then you call * {@link #getNextTime(long)} to find the next occurrence from any point in * time. In the above scenario, passing in 4:23 PM today should return 4:30 PM * today. * */ public class HourlySchedulerTest {       private Long[] millisPastHour;       /**      * Accepts the minutes past each hour that an event can start (for example      * 0, 15, 30, and 45). unit is minute;      */     public HourlySchedulerTest(int... minutesPastHour) {         millisPastHour = new Long[minutesPastHour.length];         for (int i = 0; i < minutesPastHour.length; i++) {             millisPastHour[i] = (long) ((minutesPastHour[i] == 0 ? 60 : minutesPastHour[i]) * 60 * 1000);         }         Arrays.sort(millisPastHour);     }       /**      * Returns the next start time from the given point in time.      */     public long getNextTime(final long fromMillis) {         final long millisLessThanHour = fromMillis % (60 * 60 * 1000);         final long hoursInMillis = fromMillis - millisLessThanHour;           final int pos = Arrays.binarySearch(millisPastHour, millisLessThanHour);         int result = pos  millisPastHour.length - 1 ? hoursInMillis + 60 * 60 * 1000 + millisPastHour[0]                 : hoursInMillis + millisPastHour[result];         return nextTimeInMillis;     }       public static void main(String[] args) {         HourlySchedulerTest test = new HourlySchedulerTest(0, 15, 30, 45);           final long now = 1426708139391L; // Wed Mar 18 15:48:59 2015           expect(test, now, 1426708800000L);         expect(test, now + 900000L, 1426709700000L);         expect(test, now + 1800000, 1426710600000L);         expect(test, now + 2700000L, 1426711500000L);         expect(test, now + 3600000L, 1426712400000L);       }       private static void expect(HourlySchedulerTest test, long fromMillis, long expectedNextTime) {         long actualNextTime = test.getNextTime(fromMillis);         if (actualNextTime != expectedNextTime) {             System.out.println("Test failed.  Expected: " + new Date(expectedNextTime) + " (" + expectedNextTime                     + "), but found " + new Date(actualNextTime) + " (" + actualNextTime + ")");         } else {             System.out.println("Test passed.  " + new Date(actualNextTime));         }     } }

    • 

      By Dele Taylor - June 1, 2016 6:03 AM Reply

      Very tight implementation 🙂

      The main difference from ours is we used a loop instead of a binary search.

      Thanks for sharing.