Java: tekenreeks converteren naar tijdstempel

Ik heb een probleem terwijl ik probeer een tekenreeks naar een tijdstempel te converteren. Ik heb een array met de datum in het formaat yyyy-MM-dden ik wil het formaat wijzigen in yyyy-MM-dd HH:mm:ss.SSS. Dus ik gebruik deze code:

final String OLD_FORMAT = "yyyy-MM-dd";
final String NEW_FORMAT = "yyyy-MM-dd HH:mm:ss.SSS";
String oldDateString = createdArray[k];
String newDateString;
DateFormat formatter = new SimpleDateFormat(OLD_FORMAT);
Date d = formatter.parse(oldDateString);
((SimpleDateFormat) formatter).applyPattern(NEW_FORMAT);
newDateString = formatter.format(d);
System.out.println(newDateString);
Timestamp ts = Timestamp.valueOf(newDateString);
System.out.println(ts);

en ik krijg het volgende resultaat.

2009-10-20 00:00:00.000

2009-10-20 00:00:00.0

maar als ik het gewoon probeer te doen

String text = "2011-10-02 18:48:05.123";
ts = Timestamp.valueOf(text);
System.out.println(ts);

Ik krijg het juiste resultaat:

2011-10-02 18:48:05.123

Weet je wat ik misschien verkeerd doe?
Bedankt voor de hulp.

Antwoord 1, autoriteit 100%

Volg deze stappen voor een correct resultaat:

try {
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss.SSS");
    Date parsedDate = dateFormat.parse(yourString);
    Timestamp timestamp = new java.sql.Timestamp(parsedDate.getTime());
} catch(Exception e) { //this generic but you can control another types of exception
    // look the origin of excption 
}

Houd er rekening mee dat .parse(String)kan een ParseException.

Antwoord 2, autoriteit 17%

import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Util {
  public static Timestamp convertStringToTimestamp(String strDate) {
    try {
      DateFormat formatter = new SimpleDateFormat("dd/MM/yyyy");
       // you can change format of date
      Date date = formatter.parse(strDate);
      Timestamp timeStampDate = new Timestamp(date.getTime());
      return timeStampDate;
    } catch (ParseException e) {
      System.out.println("Exception :" + e);
      return null;
    }
  }
}

Antwoord 3, autoriteit 12%

Ik zou graag een modern antwoord willen geven. Toen deze vraag in 2013 werd gesteld, was het gebruik van de klasse timestampjuist, bijvoorbeeld voor het opslaan van een datum-tijd in uw database. Tegenwoordig is de klas al lang achterhaald. De moderne Java date and time API kwam met Java 8 uit in het voorjaar van 2014, drieënhalf jaar geleden. Ik raad je aan dit in plaats daarvan te gebruiken.

Afhankelijk van uw situatie en exacte vereisten, zijn er twee natuurlijke vervangingen voor timestamp:

• Instantis een punt op de tijdlijn. Voor de meeste doeleinden zou ik het het veiligst vinden om dit te gebruiken. Een Instantis onafhankelijk van de tijdzone en werkt meestal goed, zelfs in situaties waarin uw clientapparaat en uw databaseserver verschillende tijdzones gebruiken.
• LocalDateTimeis een datum en tijd van de dag zonder tijdzone, zoals 2011-10-02 18: 48: 05.123 (om de vraag te citeren).

Een moderne JDBC-stuurprogramma (JDBC 4.2 of hoger) en andere moderne hulpmiddelen voor databasetoegang is blij om een ​​Instantof een LocalDateTimein uw databasekolom van te bewaren DataType timestamp. Beide klassen als de andere datum-tijdslessen die ik in dit antwoord gebruik, behoren tot de moderne API die bekend staat als java.timeof JSR-310.

Het is het gemakkelijkst om uw tekenreeks te converteren naar LocalDateTime, dus laten we die eerste nemen:

   DateTimeFormatter formatter
            = DateTimeFormatter.ofPattern("uuuu-MM-dd HH:mm:ss.SSS");
    String text = "2011-10-02 18:48:05.123";
    LocalDateTime dateTime = LocalDateTime.parse(text, formatter);
    System.out.println(dateTime);

Deze prints

2011-10-02T18:48:05.123

Als uw string in YYYY-MM-DD-formaat was, doe dan:

   String text = "2009-10-20";
    LocalDateTime dateTime = LocalDate.parse(text).atStartOfDay();
    System.out.println(dateTime);

Deze prints

2009-10-20T00:00

of nog beter, neem de uitvoer van LocalDate.parse()en bewaar deze in een databasekolom van datatype date.

In beide gevallen de procedure voor het converteren van een LocalDateTimenaar een Instantis:

   Instant ts = dateTime.atZone(ZoneId.systemDefault()).toInstant();
    System.out.println(ts);

Ik heb een conversie gespecificeerd met behulp van de standaardtijdzone van de JVM, omdat dit is wat de verouderde klasse zou hebben gebruikt. Dit is echter kwetsbaar, omdat de tijdzone-instelling onder onze voeten kan worden gewijzigd door andere delen van uw programma of door andere programma’s die in dezelfde JVM draaien. Geef indien mogelijk een tijdzone op in de notatie regio/stad, bijvoorbeeld:

   Instant ts = dateTime.atZone(ZoneId.of("Europe/Athens")).toInstant();

Antwoord 4, autoriteit 5%

De gemakkelijke manier om String te converteren naar java.sql.Timestamp:

Timestamp t = new Timestamp(DateUtil.provideDateFormat().parse("2019-01-14T12:00:00.000Z").getTime());

DateUtil.java:

import java.text.SimpleDateFormat;
import java.util.TimeZone;
public interface DateUtil {
  String ISO_DATE_FORMAT_ZERO_OFFSET = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'";
  String UTC_TIMEZONE_NAME = "UTC";
  static SimpleDateFormat provideDateFormat() {
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat(ISO_DATE_FORMAT_ZERO_OFFSET);
    simpleDateFormat.setTimeZone(TimeZone.getTimeZone(UTC_TIMEZONE_NAME));
    return simpleDateFormat;
  }
}

Antwoord 5, autoriteit 2%

DateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
Date date = formatter.parse(dateString);
Timestamp timestamp = new Timestamp(date.getTime());
System.out.println(timestamp);

Antwoord 6, autoriteit 2%

Voor de volledigheid is hier een oplossing met lambda- en methodereferentie:

ISO-formaat?

Beschrijving :
De volgende methode

• Converteert een Stringmet het patroon yyyy-MM-ddin een timestamp, als een geldige invoer wordt gegeven,
• retourneert een null, als een nullwaarde wordt gegeven,
• Werpt een DateTimeParseException, als een ongeldige invoer wordt gegeven

code :

static Timestamp convertStringToTimestamp(String strDate) {
    return Optional.ofNullable(strDate) // wrap the String into an Optional
                   .map(str -> LocalDate.parse(str).atStartOfDay()) // convert into a LocalDate and fix the hour:minute:sec to 00:00:00
                   .map(Timestamp::valueOf) // convert to Timestamp
                   .orElse(null); // if no value is present, return null
}

Validatie :
Deze methode kan worden getest met die eenheidstests:
(Met Junit5 en HAMCREST )

@Test
void convertStringToTimestamp_shouldReturnTimestamp_whenValidInput() {
    // given
    String strDate = "2020-01-30";
    // when
    final Timestamp result = convertStringToTimestamp(strDate);
    // then
    final LocalDateTime dateTime = LocalDateTime.ofInstant(result.toInstant(), ZoneId.systemDefault());
    assertThat(dateTime.getYear(), is(2020));
    assertThat(dateTime.getMonthValue(), is(1));
    assertThat(dateTime.getDayOfMonth(), is(30));
}
@Test
void convertStringToTimestamp_shouldReturnTimestamp_whenInvalidInput() {
    // given
    String strDate = "7770-91-30";
    // when, then
    assertThrows(DateTimeParseException.class, () -> convertStringToTimestamp(strDate));
}
@Test
void convertStringToTimestamp_shouldReturnTimestamp_whenNullInput() {
    // when
    final Timestamp result = convertStringToTimestamp(null);
    // then
    assertThat(result, is(nullValue()));
}

Nog een formaat?

Meestal komt de tekenreeks met een ander formaat. Een manier om ermee om te gaan is om een ​​formatter te gebruiken om het naar een ander formaat te converteren. Hier is een voorbeeld:

Invoer: 20200130 11:30

Patroon: yyyyMMdd HH:mm

Uitgang: tijdstempel van deze ingang

code :

static Timestamp convertStringToTimestamp(String strDate) {
    final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd HH:mm");
    return Optional.ofNullable(strDate) //
                   .map(str -> LocalDateTime.parse(str, formatter))
                   .map(Timestamp::valueOf) //
                   .orElse(null);
}

Test :

@Test
void convertStringToTimestamp_shouldReturnTimestamp_whenValidInput() {
    // given
    String strDate = "20200130 11:30";
    // when
    final Timestamp result = convertStringToTimestamp(strDate);
    // then
    final LocalDateTime dateTime = LocalDateTime.ofInstant(result.toInstant(), ZoneId.systemDefault());
    assertThat(dateTime.getYear(), is(2020));
    assertThat(dateTime.getMonthValue(), is(1));
    assertThat(dateTime.getDayOfMonth(), is(30));
    assertThat(dateTime.getHour(), is(11));
    assertThat(dateTime.getMinute(), is(30));
}

Antwoord 7, Autoriteit 2%

DateFormat formatter;
formatter = new SimpleDateFormat("dd/MM/yyyy");
Date date = (Date) formatter.parse(str_date);
java.sql.Timestamp timeStampDate = new Timestamp(date.getTime());

Antwoord 8

converteer eerst uw datumreeks naar dateen converteer deze vervolgens naar timestampmet behulp van de volgende reeks regels

Date date=new Date();
Timestamp timestamp = new Timestamp(date.getTime());//instead of date put your converted date
Timestamp myTimeStamp= timestamp;

Antwoord 9

Ik weet zeker dat de oplossing is dat je oldDateString zoiets is als “2009-10-20”. Uiteraard bevat dit geen tijdgegevens lager dan dagen. Als u deze tekenreeks opmaakt met uw nieuwe formatter, waar moeten de minuten, seconden en milliseconden dan vandaan komen?

Het resultaat is dus absoluut correct: 2009-10-20 00:00:00.000

Wat je nodig hebt om dit op te lossen, is de originele tijdstempel (incl. tijdgegevens) vóór je eerste opmaak.

Antwoord 10

kun je het een keer proberen…

String dob="your date String";
String dobis=null;
final DateFormat df = new SimpleDateFormat("yyyy-MMM-dd");
final Calendar c = Calendar.getInstance();
try {
    if(dob!=null && !dob.isEmpty() && dob != "")
    {
    c.setTime(df.parse(dob));
    int month=c.get(Calendar.MONTH);
    month=month+1;
    dobis=c.get(Calendar.YEAR)+"-"+month+"-"+c.get(Calendar.DAY_OF_MONTH);
    }
}

Antwoord 11

Dit is wat ik deed:

Timestamp timestamp = Timestamp.valueOf(stringValue);

waarbij stringValueelk formaat van Datum/Tijd kan zijn.