Comparación de tiempo

Tengo un tiempo en hh:mm y el usuario debe ingresarlo en ese formato.

Sin embargo, quiero comparar el tiempo (por ej., 11:22) ¿es entre las 10am y las 6pm? ¿Pero cómo lo comparo?

Java todavía (todavía) tiene una buena clase de Time incorporada (tiene una para las consultas JDBC, pero eso no es lo que desea).

Una opción sería usar las API JodaTime y su clase LocalTime .

Siguiendo solo con las API Java incorporadas, estás atascado con java.util.Date . Puede usar un SimpleDateFormat para analizar la hora, luego las funciones de comparación de Date para ver si es antes o después de otro momento:

 SimpleDateFormat parser = new SimpleDateFormat("HH:mm"); Date ten = parser.parse("10:00"); Date eighteen = parser.parse("18:00"); try { Date userDate = parser.parse(someOtherDate); if (userDate.after(ten) && userDate.before(eighteen)) { ... } } catch (ParseException e) { // Invalid date was entered } 

O simplemente podría usar algunas manipulaciones de cadena, quizás una expresión regular para extraer solo la hora y las porciones de minutos, convertirlas en números y hacer una comparación numérica:

 Pattern p = Pattern.compile("(\d{2}):(\d{2})"); Matcher m = p.matcher(userString); if (m.matches() ) { String hourString = m.group(1); String minuteString = m.group(2); int hour = Integer.parseInt(hourString); int minute = Integer.parseInt(minuteString); if (hour >= 10 && hour <= 18) { ... } } 

Realmente todo depende de lo que estás tratando de lograr.

Con Java 8+, puede usar la nueva API de tiempo de Java:

  • para analizar el tiempo:

     LocalTime time = LocalTime.parse("11:22") 
  • para hacer comparaciones de fechas, tiene LocalTime::isBefore y LocalTime::isAfter – tenga en cuenta que estos métodos son estrictos

Entonces tu problema sería tan simple como:

 public static void main(String[] args) { LocalTime time = LocalTime.parse("11:22"); System.out.println(isBetween(time, LocalTime.of(10, 0), LocalTime.of(18, 0))); } public static boolean isBetween(LocalTime candidate, LocalTime start, LocalTime end) { return !candidate.isBefore(start) && !candidate.isAfter(end); // Inclusive. } 

Para inicio inclusivo pero final exclusivo (semiabierto), use esta línea.

 return !candidate.isBefore(start) && candidate.isBefore(end); // Exclusive of end. 

ejemplo:

 import java.util.*; import java.lang.Object; import java.text.Collator; public class CurrentTime{ public class CurrentTime { public static void main( String[] args ) { Calendar calendar = new GregorianCalendar(); String am_pm; int hour = calendar.get( Calendar.HOUR ); int minute = calendar.get( Calendar.MINUTE ); // int second = calendar.get(Calendar.SECOND); if( calendar.get( Calendar.AM_PM ) == 0 ){ am_pm = "AM"; if(hour >=10) System.out.println( "welcome" ); } else{ am_pm = "PM"; if(hour<6) System.out.println( "welcome" ); } String time = "Current Time : " + hour + ":" + minute + " " + am_pm; System.out.println( time ); } } 

Fuente

Según su statement, parece que simplemente desea escribir:

 if (10 >= hh && hh < 18) { ... } 

Esto es trivial si ya te han dado las horas. Pero seguramente estás preguntando algo más?

 import java.util.Calendar; Calendar cal = Calendar.getInstance(); int currentHour = cal.get(Calendar.HOUR); if (currentHour > 10 && currentHour < 18) { //then rock on } 
 package javaapplication4; import java.text.*; import java.util.*; /** * * @author Stefan Wendelmann */ public class JavaApplication4 { private static SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS"); /** * @param args the command line arguments */ public static void main(String[] args) throws ParseException { SimpleDateFormat parser = new SimpleDateFormat("dd.MM.YYYY HH:mm:ss.SSS"); Date before = parser.parse("01.10.1990 07:00:00.000"); Date base = parser.parse("01.10.1990 08:00:00.000"); Date after = parser.parse("01.10.1990 09:00:00.000"); printCompare(base, base, "=="); printCompare(base, before, "=="); printCompare(base, before, "<"); printCompare(base, after, "<"); printCompare(base, after, ">"); printCompare(base, before, ">"); printCompare(base, before, "<="); printCompare(base, base, "<="); printCompare(base, after, "<="); printCompare(base, after, ">="); printCompare(base, base, ">="); printCompare(base, before, ">="); } private static void printCompare (Date a, Date b, String operator){ System.out.println(sdf.format(b)+"\t"+operator+"\t"+sdf.format(a)+"\t"+compareTime(a, b, operator)); } protected static boolean compareTime(Date a, Date b, String operator) { if (a == null) { return false; } try { //Zeit aus Datum holen // The Magic happens here i only get the Time out of the Date Object SimpleDateFormat parser = new SimpleDateFormat("HH:mm:ss.SSS"); a = parser.parse(parser.format(a)); b = parser.parse(parser.format(b)); } catch (ParseException ex) { System.err.println(ex); } switch (operator) { case "==": return b.compareTo(a) == 0; case "<": return b.compareTo(a) < 0; case ">": return b.compareTo(a) > 0; case "<=": return b.compareTo(a) <= 0; case ">=": return b.compareTo(a) >= 0; default: throw new IllegalArgumentException("Operator " + operator + " wird für Feldart Time nicht unterstützt!"); } } } 

 run: 08:00:00.000 == 08:00:00.000 true 07:00:00.000 == 08:00:00.000 false 07:00:00.000 < 08:00:00.000 true 09:00:00.000 < 08:00:00.000 false 09:00:00.000 > 08:00:00.000 true 07:00:00.000 > 08:00:00.000 false 07:00:00.000 <= 08:00:00.000 true 08:00:00.000 <= 08:00:00.000 true 09:00:00.000 <= 08:00:00.000 false 09:00:00.000 >= 08:00:00.000 true 08:00:00.000 >= 08:00:00.000 true 07:00:00.000 >= 08:00:00.000 false BUILD SUCCESSFUL (total time: 0 seconds) 

Adam explica bien en su respuesta, pero lo usé de esta manera. Creo que esta es la forma más fácil de entender la comparación de tiempo en Java

Primero crea 3 objetos de calendario con solo tu hora, hora y minuto.

luego obtenga milisegundos GMT de ese tiempo y simplemente compare.

Ex.

 Calendar chechDateTime = Calendar.getInstance(); chechDateTime.set(Calendar.MILLISECOND, 0); chechDateTime.set(Calendar.SECOND, 0); chechDateTime.set(Calendar.HOUR, 11); chechDateTime.set(Calendar.MINUTE, 22); Calendar startDateTime = Calendar.getInstance(); startDateTime.set(Calendar.MILLISECOND, 0); startDateTime.set(Calendar.SECOND, 0); startDateTime.set(Calendar.HOUR, 10); startDateTime.set(Calendar.MINUTE, 0); Calendar endDateTime = Calendar.getInstance(); endDateTime.set(Calendar.MILLISECOND, 0); endDateTime.set(Calendar.SECOND, 0); endDateTime.set(Calendar.HOUR, 18); endDateTime.set(Calendar.MINUTE, 22); long chechDateTimeMilliseconds=chechDateTime.getTime().getTime(); long startDateTimeMilliseconds=startDateTime.getTime().getTime(); long endDateTimeMilliseconds=endDateTime.getTime().getTime(); System.out.println("chechDateTime : "+chechDateTimeMilliseconds); System.out.println("startDateTime "+startDateTimeMilliseconds); System.out.println("endDateTime "+endDateTimeMilliseconds); if(chechDateTimeMilliseconds>=startDateTimeMilliseconds && chechDateTimeMilliseconds <= endDateTimeMilliseconds ){ System.out.println("In between "); }else{ System.out.println("Not In between "); } 

La salida se verá así:

 chechDateTime : 1397238720000 startDateTime 1397233800000 endDateTime 1397263920000 In between 

Lo siguiente asume que sus horas y minutos se almacenan como entradas en variables llamadas hh y mm respectivamente.

 if ((hh > START_HOUR || (hh == START_HOUR && mm >= START_MINUTE)) && (hh < END_HOUR || (hh == END_HOUR && mm <= END_MINUTE))) { ... } 

Estoy utilizando esta clase por tiempo en este formato “hh: mm: ss” u puede usarlo con “hh: mm: 00” (cero segundos) para su ejemplo. Aquí está el código completo. Se ha comparado y entre funciones y también comprueba el formato de tiempo (en caso de tiempo no válido y arroja TimeException). Espero que pueda usarlo o modificarlo para sus necesidades.

Clase de tiempo:

 package es.utility.time; import java.util.regex.Matcher; import java.util.regex.Pattern; /** * * @author adrian */ public class Time { private int hours; //Hours of the day private int minutes; //Minutes of the day private int seconds; //Seconds of the day private String time; //Time of the day /** * Constructor of Time class * * @param time * @throws TimeException if time parameter is not valid */ public Time(String time) throws TimeException { //Check if valid time if (!validTime(time)) { throw new TimeException(); } //Init class parametars String[] params = time.split(":"); this.time = time; this.hours = Integer.parseInt(params[0]); this.minutes = Integer.parseInt(params[1]); this.seconds = Integer.parseInt(params[2]); } /** * Constructor of Time class * * @param hours * @param minutes * @param seconds * @throws TimeException if time parameter is not valid */ public Time(int hours, int minutes, int seconds) throws TimeException { //Check if valid time if (!validTime(hours, minutes, seconds)) { throw new TimeException(); } this.time = timeToString(hours, minutes, seconds); this.hours = hours; this.minutes = minutes; this.seconds = seconds; } /** * Checks if the sting can be parsed as time * * @param time (correct from hh:mm:ss) * @return true if ok 
false if not ok */ private boolean validTime(String time) { String regex = "([01]?[0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]"; Pattern p = Pattern.compile(regex); Matcher m = p.matcher(time); return m.matches(); } /** * Checks if the sting can be parsed as time * * @param hours hours * @param minutes minutes * @param seconds seconds * @return true if ok
false if not ok */ private boolean validTime(int hours, int minutes, int seconds) { return hours >= 0 && hours <= 23 && minutes >= 0 && minutes <= 59 && seconds >= 0 && seconds <= 59; } /** * From Integer values to String time * * @param hours * @param minutes * @param seconds * @return String generated from int values for hours minutes and seconds */ private String timeToString(int hours, int minutes, int seconds) { StringBuilder timeBuilder = new StringBuilder(""); if (hours < 10) { timeBuilder.append("0").append(hours); } else { timeBuilder.append(hours); } timeBuilder.append(":"); if (minutes < 10) { timeBuilder.append("0").append(minutes); } else { timeBuilder.append(minutes); } timeBuilder.append(":"); if (seconds < 10) { timeBuilder.append("0").append(seconds); } else { timeBuilder.append(seconds); } return timeBuilder.toString(); } /** * Compare this time to other * * @param compare * @return -1 time is before
0 time is equal
time is after */ public int compareTime(Time compare) { //Check hours if (this.getHours() < compare.getHours()) { //If hours are before return -1 return -1; } if (this.getHours() > compare.getHours()) { //If hours are after return 1 return 1; } //If no return hours are equeal //Check minutes if (this.getMinutes() < compare.getMinutes()) { //If minutes are before return -1 return -1; } if (this.getMinutes() > compare.getMinutes()) { //If minutes are after return 1 return 1; } //If no return minutes are equeal //Check seconds if (this.getSeconds() < compare.getSeconds()) { //If minutes are before return -1 return -1; } if (this.getSeconds() > compare.getSeconds()) { //If minutes are after return 1 return 1; } //If no return seconds are equeal and return 0 return 0; } public boolean isBetween(Time before, Time after) throws TimeException{ if(before.compareTime(after)== 1){ throw new TimeException("Time 'before' is after 'after' time"); } //Compare with before and after if (this.compareTime(before) == -1 || this.compareTime(after) == 1) { //If time is before before time return false or time is after after time return false; } else { return true; } } public int getHours() { return hours; } public void setHours(int hours) { this.hours = hours; } public int getMinutes() { return minutes; } public void setMinutes(int minutes) { this.minutes = minutes; } public int getSeconds() { return seconds; } public void setSeconds(int seconds) { this.seconds = seconds; } public String getTime() { return time; } public void setTime(String time) { this.time = time; } /** * Override the toString method and return all of the class private * parameters * * @return String Time{" + "hours=" + hours + ", minutes=" + minutes + ", * seconds=" + seconds + ", time=" + time + '}' */ @Override public String toString() { return "Time{" + "hours=" + hours + ", minutes=" + minutes + ", seconds=" + seconds + ", time=" + time + '}'; } }

Clase TimeException:

 package es.utility.time; /** * * @author adrian */ public class TimeException extends Exception { public TimeException() { super("Cannot create time with this params"); } public TimeException(String message) { super(message); } }