L'analyse de différents formats de la date en une chaîne de caractères en Java

J'ai une chaîne de caractères qui peut éventuellement contenir une date dans l'un des formats suivants:

2001-01-05 (yyyy-mm-dd)
2001/01/05 (yyyy/mm/dd)
01/05/2001 (dd/mm/yyyy)
01-05-2001 (dd-mm-yyyy)
2001 january 5
2001 5 january
january 5 2001
5 january 2001
january 5
5 january

Je veux être en mesure d'analyser la chaîne de caractères et l'extrait de l'objet Date.

Mon approche était comme suit:

String[] date_formats = {
                            "yyyy-MM-dd",
                            "yyyyy/MM/dd", 
                            "dd/MM/yyyyy",
                            "dd-MM-yyyy",
                            "yyyy MMM dd",
                            "yyyy dd MMM",
                            "dd MMM yyyy",
                            "dd MMM",
                            "MMM dd",
                            "dd MMM yyyy"};

String output_date = null;
for (String formatString : date_formats)
{
     try
     {    
         Date mydate = new SimpleDateFormat(formatString).parse(token);
         SimpleDateFormat outdate = new SimpleDateFormat("yyyyMMdd");
         output_date = outdate.format(mydate);
         break;
     }
     catch (ParseException e) {
         System.out.println("Next!");
     }
 }

Cela ne semble pas fonctionner comme prévu. Surtout pour les dates comme 5 janvier 2001, etc. Comment dois-je faire?

Quel est le problème avec les motifs? docs.oracle.com/javase/7/docs/api/java/text/...
Toujours fournir des paramètres régionaux de votre format de date lorsque vous souhaitez analyser date dans une langue particulière. (new SimpleDateFormat("{format}", Locale.ENGLISH);)
Rien maintenant que vous avez fixé.
Cela ne fonctionne toujours pas correctement les dates comme 5 janvier 2001. Il satisfait le MMM jj aaaa motif et la date je finis par obtenir est 00100624 qui est totalement arbitraire.
Voir ma réponse.

OriginalL'auteur Alagappan Ramu | 2013-10-02

6

Utilisation SimpleDateFormat.setLenient(false). De cette façon, il ne tente pas d'analyser les dates qui ne sont pas au même format qu'il veut.

Bon à savoir, mais inutile dans ce cas. L'OP est d'essayer chaque format d'une instruction try/catch jusqu'à la fin de l'instruction try est rencontré.
Inutile? Son problème était que, dans certains cas, la non-correction des modèles ont été de l'analyse les valeurs, en donnant des valeurs arbitraires. Une situation corrigée par la mise en clémente faux.
À mon humble avis, la mauvaise motif de fin de l'instruction catch et la prochaine aura essayé.
Ce qui m'a aidé à éviter les faux positifs lorsque je lis les dates.
OK, j'ai eu une confusion sur le sens de l'indulgence. +1 pour Kayaman.

OriginalL'auteur Kayaman
1

Vous avez besoin d'avoir tous les formats du date_formats tableau pour le type de format que vous anticiper serait à venir.

Ont un look à la SimpleDateFormat la documentation javadoc.

Avoir un oeil sur les exemples de la documentation javadoc.
```
2001-01-05      - yyyy-MM-dd 
2001/01/05      - yyyy/MM/dd
01/05/2001      - dd/MM/yyyy 
01-05-2001      - dd-MM-yyyy 
2001 january 5  - yyyy MMMMM d
2001 5 january  - yyyy d MMMMM
january 5 2001  - MMMMM d yyyy 
5 january 2001  - d MMMMM yyyy
january 5       - MMMMM d
5 january       - d MMMMM
```
J'ai été voir la doc. Ne sont pas les modèles que je l'ai mentionné correct?
Oui. Votre formats sont mauvais. J'ai ajouté les formats dont vous avez besoin.
Cela ne fonctionne toujours pas correctement les dates comme 5 janvier 2001. Il doit avant tout répondre à la MMM jj aaaa motif et la date je finis par obtenir est 00100624 qui est totalement arbitraire.
Réglage setLenient à faux, comme suggéré par Kayaman, a aidé à éviter l'erreur ci-dessus.
Mais votre liste de "date_formats" n'aurait pas du MMM. Il n'y a pas de date dans votre "possibilité" de la liste (liste) pour le match.

OriginalL'auteur JHS
1

Au lieu de tester "aaaa-MM-jj", puis "aaaa/MM/jj", puis "aaaa.MM.dd" (utilisé dans de nombreux pays), etc., vous pouvez commencer par
```
token = token.replaceAll("-|\\.", "/");
```
De cette façon, tous les points et les tirets sont remplacés par des "/", et vous pouvez réduire le nombre de formats et de tente.

OriginalL'auteur Andrei Volgin

Est-ce ce que vous recherchez?

String[] date_formats = {
                        "y-M-d",
                        "y/M/d", 
                        "d/M/y",
                        "d-M-y",
                        "y M d",
                        "y d M",
                        "d M y",
                        "d M",
                        "M d",
                        "d M y"};

String output_date = null;
for (String formatString : date_formats)
{
     try
     {    
         SimpleDateFormat sf = new SimpleDateFormat(formatString);  
         output_date = "5 January 2001"; 
         Date yourDate = sf.parse(output_date);
         break;
     }
     catch (ParseException e) {
         System.out.println("Next!");
     }
 }

OriginalL'auteur kai

Vous pouvez extraire de la Chaîne de Date à l'aide de

String mydate = new SimpleDateFormat(formatString).format(new Date());

new Date() sera de retour courant en date de ce jour, vous pouvez modifier toutes les dates que vous désirez.

Donc, si vous changez votre code comme ceci:

String[] date_formats = {
        "y-M-d",
        "y/M/d", 
        "d/M/y",
        "d-M-y",
        "y M d",
        "y d M",
        "d M y",
        "d M",
        "M d",
        "d M y"};

for (String formatString : date_formats)
    {
        String mydate = new SimpleDateFormat(formatString).format(new Date());
        System.out.println(mydate);
    }

Vous allez vous retrouver avec ces:

OriginalL'auteur Mehmet Sedat Güngör

0

Ajouter ce format de date "dd MMMMM YYYY" pour "5 janvier 2001"

OriginalL'auteur serj

SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
    String dateInString = formatter.format(date);

    LOG.warn("date in String "+dateInString);

Assurez-vous que le MM est capital

OriginalL'auteur Anil M

Kayamans réponse œuvres, c'est à quoi il ressemble dans un extrait de code de sorte que vous pouvez facilement tester par vous-même (directement copier coller de mon propre code):

static String[] date_formats = {
        "yyyy-MM-dd",
        "yyyy/MM/dd",
        "dd/MM/yyyy",
        "dd-MM-yyyy",
        "yyyy MMM dd",
        "yyyy dd MMM",
        "dd MMM yyyy",
        "dd MMM yyyy"};

static String[] dates = {
        "21/02/2012",
        "21-02-2012",
        "21-2-2012",
        "21 Feb 2012",
        "Feb 21 2012",//will not be parsed
        "21 februari 2012" //Dutch
};

@Test
public void test(){
    for(String date : dates) {
        parseDate(date);
        System.out.print("----------------");
    }
}

private void parseDate(String token){
    Locale dutch = new Locale("nl", "NL");
    for (String formatString : date_formats)
    {
        try
        {
            SimpleDateFormat format = new SimpleDateFormat(formatString, dutch);
            format.setLenient(false);
            Date mydate = format.parse(token);
            System.out.println(mydate.toString());
            break;
        }
        catch (ParseException e) {
            System.out.println("Next!");
        }
    }
}

OriginalL'auteur Ben

Vous devez vous connecter pour publier un commentaire.