Überprüfen Sie, ob das Datum älter ist als 10 Jahre und neuer als 20 Jahre

Ich versuche zu prüfen, die in Java 8, wenn ein Datum älter als 10 Jahre und neuer als 20 Jahre. Ich bin mit Date.before() Und Date.after() und Weitergabe currentDate-10 Jahren currentDate-20 Jahren als Argumente.

Kann mir bitte jemand vorschlagen, was wird das reinste Weg, um ein Datum ist 10 Jahre alt und 20 Jahre alt-in Datum-format, um es zu übergeben, die in meinem before() und after() Methoden?

Ich bin mir nicht 100% sicher über diese (nie verwendet, Datum vor/nach), aber Sie haben versucht, einen Vergleich mit einem Datum initialisiert heute, legen Sie dann zwei weitere Termine, die mit Bezug auf diese (10 Jahre und 20 Jahre vor), dann verwenden Sie diese Methoden?
hier ein Lesetipp: oracle.com/technetwork/articles/java/...
stackoverflow.com/questions/883060/...
Dringend zu empfehlen nicht mit java.util.Datum und zugehörige Klassen. Verwenden Sie java.Zeit.*
warum nicht ?
kurze Antwort: java.util.Datum et al haben viel über Veränderlichkeit und Vererbung Fragen; java.time ist seine offizielle Ersatz, von den Autoren der Joda Time. lange Antwort: verdient eine Frage ALSO, wenn es nicht bereits vorhanden ist.

InformationsquelleAutor Andy897 | 2015-12-01

18

Mit Calendar Sie können leicht 10-jährige date-und die 20-jährige das Datum vom aktuellen Datum ab.
```
Calendar calendar  = Calendar.getInstance();
calendar.add(Calendar.YEAR, -10);
Date d1 = calendar.getTime();
calendar.add(Calendar.YEAR, -10);
Date d2 = calendar.getTime();
```
Als Sie der Verwendung von Java 8 Sie können auch LocalDate
```
    LocalDate currentDate = LocalDate.now();
    Date d1 = Date.from(currentDate.minusYears(10).atStartOfDay(ZoneId.systemDefault()).toInstant());
    Date d2 = Date.from(currentDate.minusYears(20).atStartOfDay(ZoneId.systemDefault()).toInstant());
```
Für den Vergleich können Sie die date.after() und date.before() Methoden, wie Sie sagte.
```
    if(date.after(d1) && date.before(d2)){  //date is the Date instance that wants to be compared
        ////
    }
```
Den before() und after() Methoden implementiert, in Calendar und LocalDate zu. Sie können diese Methoden in jenen Fällen, ohne Sie zu konvertieren in java.util.Date Instanzen.
- Obwohl diese Werke in java 8, ich würde empfehlen, mit der neuen Datum-und Zeit-api.
- Wenn Sie ein LocalDate, gibt es keine Notwendigkeit, um wieder ein Datum...
- Ich dachte, der OP will Date.after() und Date.before() Methoden
InformationsquelleAutor Ramesh-X
32

Können Sie java.Zeit.LocalDate, dies zu tun.
Beispiel: Wenn Sie brauchen, um zu überprüfen, ob 01/01/2005 ist, dass zwischen der Dauer, die Sie verwenden können,
```
LocalDate date = LocalDate.of(2005, 1, 1); //Assign date to check
LocalDate today = LocalDate.now();

if (date.isBefore(today.minusYears(10)) && date.isAfter(today.minusYears(20))) {
  //Do Something
}
```
- Ich habe mir die Freiheit genommen, von der Erstellung einer separaten Variablen, um das Problem @SpaceTrucker angehoben. Fühlen Sie sich frei, zurück zu Rollen, wenn Sie es wünschen. Beachten Sie auch, dass diese Antwort ignoriert die Probleme der Zeit und Zeitzone. Ich würde wahrscheinlich kürzen Sie die Zeit, zuerst mit atStartOfDay und Zeitzone Handhabung würde, hängt von den spezifischen Anwendungsfall.
InformationsquelleAutor dkulkarni
4

Andere Möglichkeit ist, um die Jahre zu zählen, die zwischen dem Datum, zu überprüfen und die Ober-Datum. Wenn die Anzahl der Jahre ist größer als 0 und kleiner als 10 ist, bedeutet es, das Datum zu überprüfen, ist älter als 10 Jahre und neuer als 20 Jahre.

Dieser code ermittelt werden soll, ob das Datum in dem Intervall ]now - 20 years ; now - 10 years[:
```
public static void main(String[] args) {
    LocalDate dateToCheck = LocalDate.now().minusYears(20).plusDays(1);

    LocalDate upperYear = LocalDate.now().minusYears(10);
    long yearCount = ChronoUnit.YEARS.between(dateToCheck, upperYear);
    if (yearCount > 0 && yearCount < 10) {
        System.out.println("date is older than 10 years and newer than 20 years");
    }
}
```
- Ich würde nur verwenden long l=LocalDate.now().until(dateToCheck, ChronoUnit.YEARS); if(l<=-10 && l>-20) wenn die Aufgabe "überprüfen, ob das Alter ist in diesem Intervall". Aber deine Antwort ist doch der einzige, der nicht fehlgeleitet durch die XY-Stil von der Frage, konzentriert sich auf die Verwendung before und after anstatt die eigentliche Aufgabe. Beachten Sie, dass x.until(y, YEARS) ist das gleiche wie YEARS.between(x, y) aber der letztere die Delegierten der ehemaligen.
- Es gibt ein kleines detail, aber ich denke, das wird überprüfen Sie die Intervall ]now - 20 years ; now - 10 years] (Hinweis: die inclusive gebunden für den oberen Teil). Aber der OP hat nicht gesagt, wenn das die Grenzen waren vorhanden sein soll oder nicht.
- Gut, Sie können wählen Sie die Operatoren > oder >= resp. < oder <= wie Sie möchten, aber Sie brauchen nicht intermediate LocalDate Instanzen...
- Ich denke, es ist schwieriger. Mit l<=-10 && l>-20 ist die Obere Grenze enthalten. Aber mit l<-10 && l>-20 dann zum Beispiel ein Datum, einen Tag, bevor die Obere Grenze nicht berücksichtigt werden (weil until oder between gibt die Anzahl der vollen Jahre zwischen den beiden Daten).
InformationsquelleAutor Tunaki

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.