Ob die aktuelle Zeit, falls innerhalb einer bestimmten Zeitspanne, in der der aktuelle Tag in Java

dies ist alles, was Sie benötigen sollten zu tun, diese Methode ist lose gekoppelt, von den Eingangs-und sehr stimmig.

boolean isNowBetweenDateTime(final Date s, final Date e)
{
    final Date now = new Date();
    return now.after(s) && now.before(e);
}

wie bekommst du die Date-Objekte für den Anfang und das Ende ist irrelevant für den Vergleich. Sie machen Dinge viel mehr kompliziert, als Sie brauchen, um mit übergeben String Darstellungen um.

Hier ist ein besserer Weg, um die start-und Endtermine, wieder lose gekoppelte und sehr stimmig.

private Date dateFromHourMinSec(final String hhmmss)
{
    if (hhmmss.matches("^[0-2][0-9]:[0-5][0-9]:[0-5][0-9]$"))
    {
        final String[] hms = hhmmss.split(":");
        final GregorianCalendar gc = new GregorianCalendar();
        gc.set(Calendar.HOUR_OF_DAY, Integer.parseInt(hms[0]));
        gc.set(Calendar.MINUTE, Integer.parseInt(hms[1]));
        gc.set(Calendar.SECOND, Integer.parseInt(hms[2]));
        gc.set(Calendar.MILLISECOND, 0);
        return gc.getTime();
    }
    else
    {
        throw new IllegalArgumentException(hhmmss + " is not a valid time, expecting HH:MM:SS format");
    }
}

Können Sie jetzt machen zwei gut benannte Methode Aufrufe, wird sich wohl selbst zu dokumentieren.

InformationsquelleAutor

Die folgende Klasse ist etwas, das ich erstellt habe aus dem code von anderen Antworten. Es kapselt das Verhalten einer "Zeit" ohne Bezug zu bestimmten Tagen. Unser system verwendet diese Klasse, um zu überprüfen, ob die aktuelle Zeit innerhalb einer von uns bestimmten Wartungsfenster. also 05:00:00 - 07:00:00

import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

/**
*
* @author Adam Yocum
*/
public class ExclusionTimePeriod {
    private String timeStart;
    private String timeEnd;

    /**
    * @return the timeStart
    */
    public String getTimeStart() {
        return timeStart;
    }

    /**
    * @param timeStart the timeStart to set
    */
    public void setTimeStart(String timeStart) {
        if (timeStart.matches("^([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$"))
        {
            this.timeStart = timeStart;
        }
        else
        {
            throw new IllegalArgumentException(timeStart + " is not a valid time, expecting HH:MM:SS format");
        }

    }

    /**
    * @return the timeEnd
    */
    public String getTimeEnd() {
        return timeEnd;
    }

    /**
    * @param timeEnd the timeEnd to set
    */
    public void setTimeEnd(String timeEnd) {
        if (timeEnd.matches("^([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$"))
        {
            this.timeEnd = timeEnd;
        }
        else
        {
            throw new IllegalArgumentException(timeEnd + " is not a valid time, expecting HH:MM:SS format");
        }
    }

    private Date toDate(String hhmmss){
        final String[] hms = hhmmss.split(":");
        final GregorianCalendar gc = new GregorianCalendar();
        gc.set(Calendar.HOUR_OF_DAY, Integer.parseInt(hms[0]));
        gc.set(Calendar.MINUTE, Integer.parseInt(hms[1]));
        gc.set(Calendar.SECOND, Integer.parseInt(hms[2]));
        gc.set(Calendar.MILLISECOND, 0);
        Date date = gc.getTime();
        return date;
    }

    public boolean isNowInPeriod()
    {
        final Date now = new Date();
        return now.after(toDate(getTimeStart())) && now.before(toDate(getTimeEnd()));
    }

    public static void main(String[] args){

        //Test All possible hours
        for(int hour=0;hour<=23;hour++){

            String hourStr = "";
            if(hour<=9){
                hourStr = "0"+hour;
            }else{
                hourStr = ""+hour;
            }

            for(int min=0;min<60;min++){
                String minStr = "";
                if(min<=9){
                    minStr = "0"+min;
                }else{
                    minStr = ""+min;
                }

                for(int sec=0;sec<60;sec++){
                    String secStr = "";
                    if(sec<=9){
                        secStr = "0"+sec;
                    }else{
                        secStr = ""+sec;
                    }

                    String hhmmss = hourStr+":"+minStr+":"+secStr;

                    ExclusionTimePeriod period = new ExclusionTimePeriod();
                    period.setTimeStart(hhmmss);
                    period.setTimeEnd(hhmmss);

                    System.out.println(hhmmss+" Ok");
                }
            }
        }


        //Test isInPeriod functionality
        ExclusionTimePeriod isInTest = new ExclusionTimePeriod();
        isInTest.setTimeStart("10:00:00");
        isInTest.setTimeEnd("10:43:00");

        System.out.println((new Date())+" is between "+isInTest.getTimeStart()+" and "+isInTest.getTimeEnd()+" = "+isInTest.isNowInPeriod());

    }
}

InformationsquelleAutor Adam Yocum

tl;dr

LocalTime now = ZonedDateTime.now( ZoneId.of( "America/Montreal" ) )
                             .toLocalTime() ;
Boolean isBetween = ( ! now.isBefore( LocalTime.of( 18 , 0 ) )  //"not before" means "is equal to OR after".
                    && 
                    now.isBefore( LocalTime.of( 18 , 30 ) ) ;  //Half-Open, beginning is *inclusive* while ending is *exclusive*.

Mit java.Zeit

Sind Sie mit alten Datum-Zeit-Klassen, die haben sich schlecht entwickelt, verwirrend und lästig. Sie sind jetzt Vermächtnis, überlagert von der java.Zeit-Klassen.

LocalTime

Nicht bestehen, bloße Zeichenfolgen, die Zeit-von-Tag-Werte. Wir haben jetzt einen Typ, der LocalTime Klasse.

LocalTime start = LocalTime.of( 18 , 0 );
LocalTime stop = LocalTime.of( 18 , 30 );

Passieren die Instanzen, um Ihre utility-Methode. Diese Methode sollte nicht jedem Parsen, so dass keine Notwendigkeit zu werfen, die parsing-exception.

public static  boolean isCurrentTimeBetween( LocalTime start , LocalTime stop ) {
…

ZonedDateTime

Einer Zeitzone ist entscheidend für die Bestimmung des aktuellen Datums und der Uhrzeit. Für jeden gegebenen Augenblick, das Datum variiert rund um den Globus durch die zone. Zum Beispiel, ein paar Minuten nach Mitternacht in Paris Frankreich ist ein neuer Tag, während immer noch "gestern" in Montréal Québec.

Angeben die richtige Zeit zone name im format continent/region wie Amerika/Montreal, Africa/Casablanca, oder Pacific/Auckland. Verwenden Sie niemals die 3-4 Buchstaben-Abkürzung wie EST oder IST wie Sie sind nicht wahr, Zeitzonen, nicht standardisierten und nicht sogar einzigartig(!).

ZoneId z = ZoneId.of( "America/Montreal" );
ZonedDateTime zdt = ZonedDateTime.now( z );

Vergleichen Sie die time-of-Tag, der nun, wir könnten Sie einfach extrahieren Sie eine LocalTime aus, dass ZonedDateTime. Aber wir haben das problem der Anomalien, wie die Daylight Saving Time (DST) und Politiker der Neudefinition von Zeit-Zonen. Es kann nicht jeder 6 Uhr Stunde an einem bestimmten Datum. Die Lösung für dieses Problem hängt von Ihrem business-Kontext und Ihr Unternehmen zu Regeln. Entweder Sie ignorieren das Problem, und bleiben buchstäblich zu Fragen, ob die aktuelle Zeit zwischen Ihrem Ziel-start-stop-Zeit. Oder konnte Sie die Zeitzone auf Ihrem start-stop-Zeiten-Tag für Tag und lassen ZonedDateTime Klasse Anpassungen vornehmen, wie Sie es für richtig hält. Schauen wir uns die beiden Ansätze.

Ignorieren Anomalien

Zuerst ignorieren Sie eventuelle Abweichungen. Fragen Sie einfach und wörtlich, wenn die aktuelle Uhrzeit zwischen der Ziel-start-und stop-Zeiten-Tag.

Können wir extrahieren ein time-of-day-Objekt aus der Zonen-Datum /Uhrzeit-Objekt.

LocalTime localTimeNow = zdt.toLocalTime(); //Extract a time-of-day from the zoned date-time object.

Vergleichen, die auf unserer start-stop-Zeiten-Tag. Beachten Sie, dass wir hier die Halb-Offene Ansatz zur Definition einer Zeitspanne. In diesem Ansatz, der Anfang ist inclusive, während das Ende exklusive. Dieser Ansatz ist üblich in den Datum-Zeit-Arbeit und in der Regel ist der Weise Weg zu gehen.

Boolean isNowOnOrAfterStart = ( ! localTimeNow.isBefore( start ) ) ;  //A briefer way of asking "is equal to OR is after" is "is not before". 
Boolean isNowBeforeStop = localTimeNow.isBefore( stop );
Boolean isNowInTargetZone = ( isNowOnOrAfterStart && isNowBeforeStop ); //Half-Open: beginning is inclusive while ending is exclusive.

Betrachten Anomalien

Als nächsten betrachten wir irgendwelche Anomalien. Wir übernehmen die start-und stop-Zeiten-Tag, um das aktuelle Datum innerhalb der gleichen Zeitzone. Wir extrahieren Sie die Datum-nur von der Zonen-Datum /Uhrzeit-Objekt.

LocalDate localDateToday = zdt.toLocalDate();
ZonedDateTime zdtStart = ZonedDateTime.of( localDateToday , start , z );
ZonedDateTime zdtStop = ZonedDateTime.of( localDateToday , stop , z );

Studie der Klasse-Dokumentation zu verstehen, das Verhalten von ZonedDateTime. bei der Lösung von ungültigen Zeit-von-Tag-Werte. Es gibt keine perfekte Art und Weise zu lösen nicht vorhandene Zeit-von-Tag-Werte, so müssen Sie entscheiden, ob diese Klasse' Weg, erfüllt Ihre business-Regeln.

ZonedDateTime.der

public static ZonedDateTime of(LocalDate date,
LocalTime time,
ZoneId zone)

Erhält eine Instanz von ZonedDateTime von einem lokalen Datum und Zeit.
Dies schafft eine zonierte Datum-Zeit-matching-die Eingabe lokale Zeit und Datum so genau wie möglich. Time-zone-Regeln, wie die Zeitumstellung, bedeuten, dass nicht jede lokale Datum- /Uhrzeit ist gültig für die angegebene zone, also dem lokalen Datum-Zeit eingestellt werden kann.

Dem lokalen Datum-Zeit und erste verbinden sich zu einem lokalen Datum-Zeit. Die lokalen Datum-Zeit wird dann beschlossen, einen Augenblick auf der Zeit-Linie. Dies wird erreicht, indem Sie eine gültige offset von UTC/Greenwich für die lokalen Datum-Zeit, wie definiert durch die Regeln der zone-ID.

In den meisten Fällen, es ist nur ein Gültiger offset für einen lokalen Datum-Zeit. Im Falle einer überschneidung, wenn die Uhren werden zurück, es gibt zwei gültige offsets. Diese Methode verwendet die früheren offset der Regel entsprechend "Sommer".

Im Fall einer Lücke, wenn die Uhren vorwärts springen, es gibt keine gültigen offset. Stattdessen werden die lokalen Datum-Zeit ist angepasst, um später die Länge der Lücke. Für einen typischen eine Stunde Sommerzeit ändern, die lokalen Datum-Zeit-verschoben werden eine Stunde später in der offset in der Regel entsprechend "Sommer".

Gelten die gleichen Vergleich Logik, wie wir oben gesehen haben.

Boolean isNowOnOrAfterStart = ( ! zdt.isBefore( zdtStart ) ) ;  //A briefer way of asking "is equal to OR is after" is "is not before". 
Boolean isNowBeforeStop = zdt.isBefore( zdtStop );
Boolean isNowInTargetZone = ( isNowOnOrAfterStart && isNowBeforeStop ); //Half-Open: beginning is inclusive while ending is exclusive.

Alternative Möglichkeit, um den Vergleich ist die Verwendung der handlichen Interval - Klasse aus dem ThreeTen-Extra-Projekt. Diese Klasse nimmt einen Schmerz der Instant Objekte, die Sie extrahieren können von Ihrem ZonedDateTime Objekte. Die Instant Klasse repräsentiert einen moment auf der Zeitachse, UTC mit einer Auflösung von Nanosekunden (bis zu neun (9) Ziffern eines dezimalbruchs).

Interval interval = Interval.of( zdtStart.toInstant() , zdtStop.toInstant() );
Boolean isNowInTargetZone = interval.contains( zdt.toInstant() );

Über java.Zeit

Den java.Zeit framework ist in Java 8 und höher. Diese Klassen verdrängen die lästige alte Vermächtnis Datum-Zeit-Klassen wie java.util.Date, Calendar, & " = SimpleDateFormat.

Den Joda-Time Projekt, jetzt in Wartungsmodus, rät der migration auf die java.Zeit Klassen.

Um mehr zu erfahren, siehe die Oracle Tutorial. Und die Suche Stack Overflow für viele Beispiele und Erklärungen. Spezifikation JSR 310.

Wo erhalten Sie die java.Zeit-Klassen?

• Java SE 8 und SE 9 und später
  • Eingebaut.
  • Teil der standard-Java-API mit einer gebündelten Umsetzung.
  • Java 9 fügt einige kleine features und behebt.
• Java SE 6 und SE 7
  • Viel von java.Funktionalität ist zurück-portiert auf Java 6 & 7 in ThreeTen-Backport.
• Android
  • Die ThreeTenABP Projekt passt ThreeTen-Backport (oben erwähnt) für Android-spezifisch.
  • Sehen die How to use ThreeTenABP....

Den ThreeTen-Extra Projekt erweitert die java.mal mit zusätzlicher Klassen. Dieses Projekt ist ein Testgelände für mögliche künftige Erweiterungen zu java.Zeit. Sie finden möglicherweise einige nützliche Klassen, die hier wie Interval, YearWeek, YearQuarter, und mehr.

InformationsquelleAutor Basil Bourque