webentwicklung-frage-antwort-db.com.de

Wie kann man zwei String-Daten in Java vergleichen?

Ich habe zwei Daten im String-Format wie folgt: 

String startDate = "2014/09/12 00:00";

String endDate = "2014/09/13 00:00";

Ich möchte sicherstellen, dass startDate weniger als endDate ist. startDate sollte nicht größer als endDate sein.

Wie kann ich diese beiden Daten vergleichen und entsprechend boolesch zurückgeben?

6
john

Konvertieren Sie sie in ein aktuelles Date-Objekt und rufen Sie dann before auf.

SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd h:m");
System.out.println(sdf.parse(startDate).before(sdf.parse(endDate)));

Erinnern Sie sich daran, dass parse eine ParseException auslöst, also sollten Sie es entweder in diesem Codeblock fangen oder es als Teil Ihrer Methodensignatur erklären.

28
Makoto

Hier ist eine voll funktionsfähige Demo. Informationen zur Datumsformatierung finden Sie unter - http://docs.Oracle.com/javase/6/docs/api/Java/text/SimpleDateFormat.html

import Java.text.ParseException;
import Java.text.SimpleDateFormat;
import Java.util.Date;
import Java.util.Locale;

public class Dating {

    public static void main(String[] args) {

        String startDate = "2014/09/12 00:00";
        String endDate = "2014/09/13 00:00";

        try {
            Date start = new SimpleDateFormat("yyyy/MM/dd HH:mm", Locale.ENGLISH)
                    .parse(startDate);
            Date end = new SimpleDateFormat("yyyy/MM/dd HH:mm", Locale.ENGLISH)
                    .parse(endDate);

            System.out.println(start);
            System.out.println(end);

            if (start.compareTo(end) > 0) {
                System.out.println("start is after end");
            } else if (start.compareTo(end) < 0) {
                System.out.println("start is before end");
            } else if (start.compareTo(end) == 0) {
                System.out.println("start is equal to end");
            } else {
                System.out.println("Something weird happened...");
            }

        } catch (ParseException e) {
            e.printStackTrace();
        }

    }

}
8
sid smith

Verwenden Sie SimpleDateFormat zum Konvertieren in Date zum Vergleichen:

SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm");
Date start = sdf.parse(startDate);
Date end = sdf.parse(endDate);
System.out.println(start.before(end));
3
Jean Logeart

Der einfachste und sicherste Weg wäre wahrscheinlich, diese beiden Zeichenfolgen als Datumsangaben zu analysieren und sie zu vergleichen. Sie können mit einem SimpleDateFormat in ein Datum konvertieren. Verwenden Sie die Methode before oder after für das date-Objekt, um sie zu vergleichen.

2
Kenny Hung

Ich denke, es könnte einfacher sein,

Joda Time verwenden

Sie können versuchen, diese Daten einfach zu analysieren:

import org.joda.time.DateTime;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;

DateTimeFormatter formatter = DateTimeFormat.forPattern("yyyy/MM/dd HH:mm");
DateTime d1 = formatter.parseDateTime(startDate);
DateTime d2 = formatter.parseDateTime(endDate);

Assert.assertTrue(d1.isBefore(d2));
Assert.assertTrue(d2.isAfter(d1));
2
Atais

tl; dr

Verwenden Sie moderne Java.time -Klassen, um die Eingaben in LocalDateTime -Objekte zu analysieren, indem Sie ein Formatierungsmuster mit DateTimeFormatter und Vergleichen durch Aufrufen von isBefore .

Java.time

Der moderne Ansatz verwendet die Java.time -Klassen.

Definieren Sie ein Formatierungsmuster, das Ihren Eingaben entspricht.

Analysieren Sie als LocalDateTime -Objekte, da Ihren Eingaben ein Indikator für die Zeitzone oder den Versatz von UTC fehlt.

String startInput = "2014/09/12 00:00";
String stopInput = "2014/09/13 00:00";

DateTimeFormatter f = DateTimeFormatter.ofPattern( "uuuu/MM/dd HH:mm" );

LocalDateTime start = LocalDateTime.parse( startInput , f ) ;
LocalDateTime stop = LocalDateTime.parse( stopInput , f ) ;
boolean isBefore = start.isBefore( stop ) ;

Dump zur Konsole.

System.out.println( start + " is before " + stop + " = " + isBefore );

Siehe dies Code wird live auf IdeOne.com ausgeführt .

2014-09-12T00: 00 ist vor 2014-09-13T00: 00 = wahr

Table of date-time types in Java, both modern and legacy.


Über Java.time

Das Java.time Framework ist in Java 8 und höher eingebaut. Diese Klassen verdrängen das lästige alte legacy Datum/Uhrzeit-Klassen wie Java.util.Date , Calendar , & SimpleDateFormat .

Weitere Informationen finden Sie im Oracle Tutorial . Durchsuchen Sie Stack Overflow nach vielen Beispielen und Erklärungen. Spezifikation ist JSR 31 .

Das Projekt Joda-Time , das sich jetzt im Wartungsmodus befindet, rät zur Migration auf Java.time = Klassen.

Sie können Java.time Objekte direkt mit Ihrer Datenbank austauschen. Verwenden Sie einen JDBC-Treiber , der JDBC 4.2 oder höher entspricht. Keine Notwendigkeit für Zeichenfolgen, keine Notwendigkeit für Java.sql.* Klassen.

Woher bekommen Sie die Java.time-Klassen?

Table of which Java.time library to use with which version of Java or Android.

Das Projekt ThreeTen-Extra erweitert Java.time um zusätzliche Klassen. Dieses Projekt ist ein Testfeld für mögliche zukünftige Ergänzungen von Java.time. Hier finden Sie möglicherweise einige nützliche Klassen wie Interval , YearWeek , YearQuarter , und mehr .

2
Basil Bourque

öffentliche Klasse DateComparision {

public static void main(String args[]) throws AssertionError, ParseException
{

    DateFormat df = new SimpleDateFormat("dd-MM-yyyy");

    //comparing date using compareTo method in Java
    System.out.println("Comparing two Date in Java using CompareTo method");

    compareDatesByCompareTo(df, df.parse("01-01-2012"), df.parse("01-01-2012"));
    compareDatesByCompareTo(df, df.parse("02-03-2012"), df.parse("04-05-2012"));
    compareDatesByCompareTo(df, df.parse("02-03-2012"), df.parse("01-02-2012"));

    //comparing dates in Java using Date.before, Date.after and Date.equals
    System.out.println("Comparing two Date in Java using Date's before, after and equals method");

    compareDatesByDateMethods(df, df.parse("01-01-2012"), df.parse("01-01-2012"));
    compareDatesByDateMethods(df, df.parse("02-03-2012"), df.parse("04-05-2012"));
    compareDatesByDateMethods(df, df.parse("02-03-2012"), df.parse("01-02-2012"));

    //comparing dates in Java using Calendar.before(), Calendar.after and Calendar.equals()

    System.out.println("Comparing two Date in Java using Calendar's before, after and equals method");
    compareDatesByCalendarMethods(df, df.parse("01-01-2012"), df.parse("01-01-2012"));
    compareDatesByCalendarMethods(df, df.parse("02-03-2012"), df.parse("04-05-2012"));
    compareDatesByCalendarMethods(df, df.parse("02-03-2012"), df.parse("01-02-2012"));

}

public static void compareDatesByCompareTo(DateFormat df, Date oldDate, Date newDate)
{
    //how to check if date1 is equal to date2
    if (oldDate.compareTo(newDate) == 0)
    {
        System.out.println(df.format(oldDate) + " and " + df.format(newDate) + " are equal to each other");
    }

    //checking if date1 is less than date 2
    if (oldDate.compareTo(newDate) < 0)
    {
        System.out.println(df.format(oldDate) + " is less than " + df.format(newDate));
    }

    //how to check if date1 is greater than date2 in Java
    if (oldDate.compareTo(newDate) > 0)
    {
        System.out.println(df.format(oldDate) + " is greater than " + df.format(newDate));
    }
}

public static void compareDatesByDateMethods(DateFormat df, Date oldDate, Date newDate)
{
    //how to check if two dates are equals in Java
    if (oldDate.equals(newDate))
    {
        System.out.println(df.format(oldDate) + " and " + df.format(newDate) + " are equal to each other");
    }

    //checking if date1 comes before date2
    if (oldDate.before(newDate))
    {
        System.out.println(df.format(oldDate) + " comes before " + df.format(newDate));
    }

    //checking if date1 comes after date2
    if (oldDate.after(newDate))
    {
        System.out.println(df.format(oldDate) + " comes after " + df.format(newDate));
    }
}

public static void compareDatesByCalendarMethods(DateFormat df, Date oldDate, Date newDate)
{

    //creating calendar instances for date comparision
    Calendar oldCal = Calendar.getInstance();
    Calendar newCal = Calendar.getInstance();

    oldCal.setTime(oldDate);
    newCal.setTime(newDate);

    //how to check if two dates are equals in Java using Calendar
    if (oldCal.equals(newCal))
    {
        System.out.println(df.format(oldDate) + " and " + df.format(newDate) + " are equal to each other");
    }

    //how to check if one date comes before another using Calendar
    if (oldCal.before(newCal))
    {
        System.out.println(df.format(oldDate) + " comes before " + df.format(newDate));
    }

    //how to check if one date comes after another using Calendar
    if (oldCal.after(newCal))
    {
        System.out.println(df.format(oldDate) + " comes after " + df.format(newDate));
    }
}

}

AUSGABE:......

Der Vergleich zweier Datumsangaben in Java mithilfe der CompareTo-Methode 01-01-2012 und 01-01-2012 ist gleich. 02.03-2012 ist kleiner als 04-05-2012 02-03- 2012 ist größer als der 01-02-2012

Der Vergleich zweier Datumsangaben in Java mit der Methode Date, Before und Equals 01-01-2012 und 01-01-2012 sind einander gleich 02-03-2012 liegt vor dem 04-05-2012 02-03-2012 kommt nach dem 01-02-2012

Vergleicht man zwei Datumsangaben in Java mit der Methode Before, After und Equals 01-01-2012 und 01-01-2012 des Kalenders sind einander gleich 02-03-2012 liegt vor dem 04-05-2012 02-03-2012 kommt nach dem 01-02-2012

0
Creditto

Verwenden Sie SimpleDateFormat, um Ihre Zeichenfolgendarstellung in der Instanz von Date zu analysieren. Der Aufruf von getTime(), um Millisekunden zu erhalten. Vergleichen Sie dann die Millisekunden.

0
AlexR