Voglio convertire Stringin Datein diversi formati.

Per esempio,

Sto ricevendo dall'utente,

String fromDate = "19/05/2009"; // i.e. (dd/MM/yyyy) format

Voglio convertirlo fromDatecome un oggetto Date di "yyyy-MM-dd"formato

Come posso fare questo?

Dai un'occhiata SimpleDateFormat. Il codice è qualcosa del genere:

SimpleDateFormat fromUser = new SimpleDateFormat("dd/MM/yyyy");
SimpleDateFormat myFormat = new SimpleDateFormat("yyyy-MM-dd");

try {

    String reformattedStr = myFormat.format(fromUser.parse(inputString));
} catch (ParseException e) {
    e.printStackTrace();
}

tl; dr

LocalDate.parse( 
    "19/05/2009" , 
    DateTimeFormatter.ofPattern( "dd/MM/uuuu" ) 
)

Dettagli

Le altre risposte con java.util.Date, java.sql.Datee SimpleDateFormatsono ormai superate.

LocalDate

Il modo moderno di fare data-ora è lavorare con le classi java.time, in particolare LocalDate. La LocalDateclasse rappresenta un valore di sola data senza ora del giorno e senza fuso orario.

DateTimeFormatter

Per analizzare o generare una stringa che rappresenta un valore di data e ora, utilizzare la DateTimeFormatterclasse.

DateTimeFormatter f = DateTimeFormatter.ofPattern( "dd/MM/uuuu" );
LocalDate ld = LocalDate.parse( "19/05/2009" , f );

Non confondere un oggetto data-ora con una stringa che ne rappresenta il valore. Un oggetto data-ora non ha formato , mentre un oggetto String sì. Un oggetto data-ora, ad esempio LocalDate, può generare una stringa per rappresentarne il valore interno, ma l'oggetto data-ora e la stringa sono oggetti distinti separati.

È possibile specificare qualsiasi formato personalizzato per generare una stringa. Oppure lascia che java.time si occupi della localizzazione automatica.

DateTimeFormatter f = 
    DateTimeFormatter.ofLocalizedDate( FormatStyle.FULL )
                     .withLocale( Locale.CANADA_FRENCH ) ;
String output = ld.format( f );

Scarica su console.

System.out.println( "ld: " + ld + " | output: " + output );

ld: 2009-05-19 | uscita: martedì 19 maggio 2009

Guarda in azione su IdeOne.com .

Informazioni su java.time

Il framework java.time è integrato in Java 8 e versioni successive. Queste classi soppiantare la vecchia fastidiosi legacy classi data-time come java.util.Date, Calendar, e SimpleDateFormat.

Il progetto Joda-Time , ora in modalità di manutenzione , consiglia la migrazione alle classi java.time .

Per saperne di più, vedere il tutorial Oracle . E cerca Stack Overflow per molti esempi e spiegazioni. La specifica è JSR 310 .

Puoi scambiare oggetti java.time direttamente con il tuo database. Utilizza un driver JDBC conforme a JDBC 4.2 o successivo. Non c'è bisogno di stringhe, non c'è bisogno di java.sql.*classi.

Dove ottenere le classi java.time?

• Java SE 8 , Java SE 9 e versioni successive
  • Incorporato.
  • Parte dell'API Java standard con un'implementazione in bundle.
  • Java 9 aggiunge alcune funzionalità e correzioni minori.
• Java SE 6 e Java SE 7
  • Gran parte delle funzionalità java.time sono portate indietro a Java 6 e 7 in ThreeTen-Backport .
• Android
  • Versioni successive delle implementazioni di bundle Android delle classi java.time.
  • Per precedenza Android (<26), il ThreeTenABP progetto si adatta ThreeTen-Backport (di cui sopra). Vedi Come usare ThreeTenABP… .

Il progetto ThreeTen-Extra estende java.time con classi aggiuntive. Questo progetto è un banco di prova per possibili future aggiunte a java.time. Si possono trovare alcune classi utili, come per esempio Interval, YearWeek, YearQuartere altro .

Usa la SimpleDateFormatclasse:

private Date parseDate(String date, String format) throws ParseException
{
    SimpleDateFormat formatter = new SimpleDateFormat(format);
    return formatter.parse(date);
}

Utilizzo:

Date date = parseDate("19/05/2009", "dd/MM/yyyy");

Per maggiore efficienza, ti consigliamo di archiviare i tuoi formattatori in una hashmap. La hashmap è un membro statico della tua classe util.

private static Map<String, SimpleDateFormat> hashFormatters = new HashMap<String, SimpleDateFormat>();

public static Date parseDate(String date, String format) throws ParseException
{
    SimpleDateFormat formatter = hashFormatters.get(format);

    if (formatter == null)
    {
        formatter = new SimpleDateFormat(format);
        hashFormatters.put(format, formatter);
    }

    return formatter.parse(date);
}

Converte una data stringa in java.sql.Date

String fromDate = "19/05/2009";
DateFormat df = new SimpleDateFormat("dd/MM/yyyy");
java.util.Date dtt = df.parse(fromDate);
java.sql.Date ds = new java.sql.Date(dtt.getTime());
System.out.println(ds);//Mon Jul 05 00:00:00 IST 2010

Controlla i javadoc per java.text.SimpleDateFormatDescrive tutto ciò di cui hai bisogno.

Sebbene SimpleDateFormatfunzionerà davvero per le tue esigenze, potresti anche voler dare un'occhiata a Joda Time , che apparentemente è la base per la libreria Date rifatta in Java 7. Anche se non l'ho usata molto, non ho sentito altro che cose buone e se manipoli ampiamente le date nei tuoi progetti, probabilmente varrebbe la pena esaminarlo.

Modo semplice per formattare una data e convertirla in stringa

    Date date= new Date();

    String dateStr=String.format("%td/%tm/%tY", date,date,date);

    System.out.println("Date with format of dd/mm/dd: "+dateStr);

output: Data con formato gg / mm / gg: 21/10/2015

Un Dateoggetto non ha formato , è una rappresentazione. La data può essere presentata da un Stringcon il formato che preferisci .

Ad esempio " yyyy-MM-dd", " yy-MMM-dd", " dd-MMM-yy" e così via.

Per ottenere questo risultato puoi utilizzare il file SimpleDateFormat

Prova questo,

        String inputString = "19/05/2009"; // i.e. (dd/MM/yyyy) format

        SimpleDateFormat fromUser = new SimpleDateFormat("dd/MM/yyyy"); 
        SimpleDateFormat myFormat = new SimpleDateFormat("yyyy-MM-dd");

        try {
            Date dateFromUser = fromUser.parse(inputString); // Parse it to the exisitng date pattern and return Date type
            String dateMyFormat = myFormat.format(dateFromUser); // format it to the date pattern you prefer
            System.out.println(dateMyFormat); // outputs : 2009-05-19

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

Questo esce: 2009-05-19

Supponi di avere una stringa come questa:

String mDate="2019-09-17T10:56:07.827088"

Ora vogliamo modificare questo Stringformato di data e ora separate in Java e Kotlin .

GIAVA:

abbiamo un metodo per la data di estrazione :

public String getDate() {
    try {
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS", Locale.US);
        Date date = dateFormat.parse(mDate);
        dateFormat = new SimpleDateFormat("MM/dd/yyyy", Locale.US);
        return dateFormat.format(date);
    } catch (ParseException e) {
        e.printStackTrace();
    }
    return null;
}

Return è questo: 17/09/2019

E abbiamo un metodo per l'estrazione del tempo :

public String getTime() {

    try {
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS", Locale.US);
        Date date = dateFormat.parse(mCreatedAt);
        dateFormat = new SimpleDateFormat("h:mm a", Locale.US);
        return dateFormat.format(date);
    } catch (ParseException e) {
        e.printStackTrace();
    }
    return null;
}

Returnè questo: 10:56

KOTLIN:

abbiamo una funzione per la data di estrazione :

fun getDate(): String? {

    var dateFormat = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS", Locale.US)
    val date = dateFormat.parse(mDate!!)
    dateFormat = SimpleDateFormat("MM/dd/yyyy", Locale.US)
    return dateFormat.format(date!!)
}

Return è questo: 17/09/2019

E abbiamo un metodo per l'estrazione del tempo :

fun getTime(): String {

    var dateFormat = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS", Locale.US)
    val time = dateFormat.parse(mDate!!)
    dateFormat = SimpleDateFormat("h:mm a", Locale.US)
    return dateFormat.format(time!!)
}

Returnè questo: 10:56