Exception sur date

Version imprimable

Voir 40 message(s) de cette discussion en une page

24/03/2009, 11h30
le y@m's

Ben ça compile même pas, et je ne vois pas vraiment ce que tu veux faire avec ce code.
Honnêtement je ne comprends pas pourquoi tu cherche midi à 14 heures alors que tu as déjà la solution :roll:.
24/03/2009, 12h07
JohnNC

+1
Tu ne peux pas comparer un String avec un DateFormat par la méthode "inputFormat.equals(defineFormat)", ça n'a pas de sens.

Si tu cherches des précisions sur les formats de date, autre que le code que Le y@m's t'a donné (faire tes propres expériences, savoir comment ça fonctionne, ...), il faudra copier/coller le code que tu utilises, pour que nous puissions ne serait-ce que tester.
24/03/2009, 12h19
tchize_

et c'est quoi ce

Code:

class zzzz throws DatesException {

?
24/03/2009, 12h35
cashmoney
Enfait, je me suis tromper, je voulais tester ainsi
Code:

1 2 if (inputFormat.equals(format)//
voilà
24/03/2009, 13h22
tchize_
Code:

1 2 DateFormat defineFormat = new SimpleDateFormat("dd-MMM-yyyy"); String format = DateFormat.getDateInstance().format(defineFormat );
Ce code compilera jamais, format() attend une date en paramètre et tu lui passe un DateFormat, ca a strictement rien à voir. Faut lire la javadoc pour voir quels paramètre prennent les méthode avant d'écrire le code.

Pour tester ton format, le y@m's t'as donné le code suivant :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
String inputFormat = "18-décembre-2008";
DateFormat dateFormat = new SimpleDateFormat("dd-MMM-yyyy");
try {
    Date date = dateFormat.parse(inputFormat);    // ok, date au bon format
} catch(ParseException ex) {
    throw new DatesException(inputFormat,ex) ;
}
inputFormat = "18-12-2008";
try {
    Date date = dateFormat.parse(inputFormat );    // date au mauvais format -> lève une ParseException
} catch(ParseException ex) {
    throw new DatesException(inputFormat,ex) ;
}

Ce que je vois depuis le début de cette discussion, c'est que cashmoney semble ne pas avoir compris comment se servir de la classe DateFormat (d'où les propositions de code "absurdes" avec confusions entre String, Date et DateFormat, entre date et pattern, etc).
Ce n'est pas bien grave ;) mais peut-être qu'une petite remise à plat permettrait de mettre les choses au clair.

DateFormat permet de passer d'une date à une représentation en chaîne de caractères, et vice-versa, en fonction d'un format défini.
Les deux méthodes principales sont donc :

format : Date => String ; on part d'une date et on en obtient la représentation selon le format prédéfini
parse : String => Date ; on part d'une chaîne de caractère et on essaie d'en déduire la date représentée selon le format prédéfini (il est alors possible que la chaîne ne corresponde pas du tout au format, ce qui lèvera une exception)

Dans le cas de la classe SimpleDateFormat, on définit le format par une chaîne de caractère (par exemple "dd/MM/yyyy") dans le constructeur. Cette chaîne n'est qu'un pattern[*] permettant de décrire le format à utiliser selon certaines conventions, elle ne peut pas être utilisée telle quelle pour être comparée a des dates !
Tout cela est évidemment décrit dans la javadoc.

Maintenant, pour en revenir au problème :
Le but est de tester si une chaîne de caractères donnée représente bien une date dans un format donné.
Pour cela, comme ça a déjà été dit, il suffit d'essayer de transformer la chaîne donnée en date selon le format donné, grâce à la méthode parse, qui va donc lever une exception si la chaîne de respecte pas le format. Il n'y a pas plus simple.

A la rigueur, on peut compléter un peu ce test.
En effet si je parse selon le format "dd/MM/yyyy" la chaîne "55/02/1985" ou "001/02/1985" je vais obtenir respectivement les dates du 27 mars 1985 et du 1er février 1985 sans qu'aucune erreur ne soit levée... ce qui n'est pas forcément le résultat attendu : les chaînes de caractères étaient certes "interprétables" selon le format donné mais on ne peut pas vraiment dire qu'elles étaient correctement formatées...
On peut alors procéder comme suit : d'abord transformer la chaîne en date (=> éventuelle exception si cette transformation n'est pas possible) puis re-transformer la date obtenue en chaîne (=> on obtiendra alors bien la chaîne correctement formatée, donc "27/03/1985" ou "01/02/1985" dans mon exemple), puis comparaison de la chaîne de départ et de la chaîne finale.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 public static void checkDateFormat(String date, String format) throws DateException { SimpleDateFormat sdf = new SimpleDateFormat(format); try { Date parsedDate = sdf.parse(date); String formattedDate = sdf.format(parsedDate); if (!formattedDate.equals(date)) { throw new DateException(); } } catch (ParseException e) { throw new DateException(); } }
=> checkDateFormat("17/02/1985", "dd/MM/yyyy") ne fait rien puisque la date est bien formatée...
=> checkDateFormat("55/02/1985", "dd/MM/yyyy") lève une exception de type DateException
=> checkDateFormat("001/02/1985", "dd/MM/yyyy") lève une exception de type DateException

[*] "motif" pour les francophones, mais quand toute la doc est en anglais je trouve que les traductions ne font qu'embrouiller tout le monde...

Merci, pour vos proposition, ce que je voulais c'était juste ce petit bout de code

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
public static void test_date(String str, boolean good){
 
        Pattern datePattern;
        Matcher matcher;
        String jj;
        String mm;
        String yyyy;
 
        datePattern = Pattern.compile("^(\\d{2})-(\\d{2})-(\\d{4})$");
 
        matcher = datePattern.matcher(str.trim());
 
        if(!matcher.find()) 
        {
	Afficher("format date invalide");
		good = false;// là, je lève mon DatesException            
        }
 
         if(matcher.find()) {// on teste les champs precisement
                jj = matcher.group(1);
                mm = matcher.group(2);
                yyyy = matcher.group(3);
 
                if( (Integer.valueOf(jj) <0) || (Integer.valueOf(jj)>31) 
                	|| (Integer.valueOf(mm) <0) || (Integer.valueOf(mm)>12)	
                	|| (Integer.valueOf(yyyy) <1970))
			{
              Afficher("Mauvaise date");
              good = false;// ici aussi, je lève mon DatesException
			}
              good = true;
         }
 
}

j'ai fais un Main de teste pour vérifier avec une boucle, mais j'ai un soucis

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
public static void main(String[] args) throws IOException, ParseException,
			java.text.ParseException {
		// TODO Auto-generated method stub
		boolean check_date = false;
		Date date = new Date();
		String str_date;
 
		do{
		Afficher("Entrer une date - (dd-MM-yyy)");
		Scanner sc = new Scanner(System.in);
		str_date = sc.nextLine();
		test_date(str_date, check_date);
		}
                         while(check_date == false);
		DateFormat df = new SimpleDateFormat("dd-MM-yyyy", Locale.FRENCH);
		date = df.parse(str_date);
		String format = DateFormat.getDateInstance().format(date);
		Afficher("Format US: " + date);
		Afficher("Format FR: " + format);
 
	}
 
	public static void test_date(String str, boolean good){
             ...
 
 
             private static <T> void Afficher(T e) {
		System.out.println(e.toString());
		// TODO Auto-generated method stub
 
	}
 
}

quand je rentre une date "12/12/2008" il marche nikel il m'afficher " format date invalide", mais quand je rentre cette date "32-12-2008" il m'affiche encore format date invalide au lieu de "Mauvaise Date" et je tourne en rond quand j'ai une bonne date. C'est bizarre que je me perds en boucle, merci pour votre aide.

Va falloir revoir les base de la programmation :)
Code:

1 2 3 4 5 6 do{ Afficher("Entrer une date - (dd-MM-yyy)"); Scanner sc = new Scanner(System.in); str_date = sc.nextLine(); test_date(str_date, check_date); } while(check_date == false);
Ne risque pas de finir un jour, tu ne modifie jamais check_date

Oui, tu devrais plutôt faire :
Code:

1 2 3 4 5 6 7 boolean dateOK = false; do{ Afficher("Entrer une date - (dd-MM-yyy)"); Scanner sc = new Scanner(System.in); str_date = sc.nextLine(); dateOK = test_date(str_date); } while(!dateOK);
En remplacant la méthode test_date :

Code:

public static boolean test_date(String str)

Ensuite, je ne connais pas trop les pattern, mais si j'ai bien lu la doc :

Code:

matcher.find()

renvoie un boolean si la pattern est de nouveau trouvé (un peu comme nextLine(), qui renvoi null quand il n'y a plus de ligne).

Essai ceci :
Code:

1 2 3 4 5 6 7 if(!matcher.find()) { Afficher("format date invalide"); good = false;// là, je lève mon DatesException } // if(matcher.find()) {// on teste les champs precisement else {// on teste les champs precisement

24/03/2009, 18h07
Astartee

Citation:

Envoyé par cashmoney

quand je rentre cette date "32-12-2008" il m'affiche encore format date invalide au lieu de "Mauvaise Date"

Tu es sûr ? parce que chez moi Pattern.compile("^(\\d{2})-(\\d{2})-(\\d{4})$").matcher("32-12-2008").find() renvoie bien true...

Et, si je puis me permettre, je trouve quand même ma solution (parse puis format puis comparaison avec la chaîne initiale) bien plus facile à mettre en place, et surtout bien plus complète puisqu'elle prend également en compte des subtilités non traitées dans ton code comme par exemple le fait que tous les mois n'ont pas 31 jours... ;)
24/03/2009, 18h36
le y@m's
Citation:

Envoyé par Astartee

Et, si je puis me permettre, je trouve quand même ma solution (parse puis format puis comparaison avec la chaîne initiale) bien plus facile à mettre en place, et surtout bien plus complète puisqu'elle prend également en compte des subtilités non traitées dans ton code comme par exemple le fait que tous les mois n'ont pas 31 jours... ;)

+1 pourquoi s'embêter avec des expressions régulières 8O

si ce n'est que la partie
Code:

1 2 3 4 String formattedDate = sdf.format(parsedDate); if (!formattedDate.equals(date)) { throw new DateException(); }
est inutile puisque tu utilises le même format pour parser/formatter, les deux chaînes sont forcement égales (à condition que le parsing n'ai pas levé d'exception bien entendu) ;).
24/03/2009, 18h40
Astartee

Citation:

Envoyé par le y@m's

si ce n'est que la partie [...] est inutile puisque tu utilises le même format pour parser/formatter, les deux chaînes sont forcement égales (à condition que le parsing n'ai pas levé d'exception bien entendu) ;).

NON les deux chaînes ne sont pas forcément identiques, voir les deux exemples que j'ai cités :P
24/03/2009, 18h44
cashmoney

Merci, mais je ne m'embête pas, en fait je le fait pour approfondir mes connaissances en java, alors il n'y a pas de mal à utiliser des expressions régulières. Je suis là, pour que vous puissiez m'aider dans ma quête de connaissance. Enfin, si je maîtrise comme vous, je pourrais utiliser la facilité.
Merci
24/03/2009, 19h30
le y@m's
Citation:

Envoyé par Astartee

NON les deux chaînes ne sont pas forcément identiques, voir les deux exemples que j'ai cités :P

Oui pardon, j'avais oublié ce point :oops:.
Mais pour le corrigé il suffit d'utiliser la méthode DateFormat.setLenient() en lui passant false en paramètre.
Code:

1 2 SimpleDateFormat sdf = new SimpleDateFormat(format); sdf.setLenient(false);
Plus propre :P.
24/03/2009, 20h30
Astartee

Citation:

Envoyé par cashmoney

Merci, mais je ne m'embête pas, en fait je le fait pour approfondir mes connaissances en java, alors il n'y a pas de mal à utiliser des expressions régulières. Je suis là, pour que vous puissiez m'aider dans ma quête de connaissance. Enfin, si je maîtrise comme vous, je pourrais utiliser la facilité.

Pas de problème, c'est juste que quand on voit quelqu'un ré-inventer la roue on n'imagine pas toujours que c'est fait exprès ;)

Citation:

Envoyé par le y@m's

Oui pardon, j'avais oublié ce point :oops:. Mais pour le corrigé il suffit d'utiliser la méthode [...] Plus propre :P.

Ah ouais, beaucoup plus propre, en effet :aie: Je dis toujours de lire la Javadoc mais visiblement je ne lis pas tout en entier moi-même :oops:
Bon, j'aurai au moins appris quelque chose aujourd'hui...

Merci, à tous j'ai trouver mon bonheur. j'ai juste encore modifier ma petite méthode et fait des testes et tout est nikel. il suffit d'utiliser cette méthod epour vérifier le format des dates dans mon constructeur pour lever mon exception.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
public class EssaiDate {
 
	/**
         * @param args
         * @throws IOException,
         *             ParseException, java.text.ParseException
         * @throws ParseException
         */
	public static void main(String[] args) throws IOException, ParseException,
			java.text.ParseException {
		// TODO Auto-generated method stub
		boolean check_format = true;
		Date date = new Date();
		String str_format;
 
		do{
		Afficher("Entrer une date - (dd-MM-yyy)");
		Scanner sc = new Scanner(System.in);
		str_format = sc.nextLine();
		check_format = test_format(str_format);
		}
		while(!check_format);
		DateFormat df = new SimpleDateFormat("dd-MM-yyyy", Locale.FRENCH);
                          df.setLenient(false);
		date = df.parse(str_format);
		String format = DateFormat.getDateInstance().format(date);
		Afficher("Format US: " + date);
		Afficher("Format FR: " + format);
 
	}
 
	public static boolean test_format(String str){
 
		boolean good = false;
		Pattern datePattern;
        Matcher matcher;
        String jj;
        String mm;
        String yyyy;
 
        datePattern = Pattern.compile("^(\\d{2})-(\\d{2})-(\\d{4})$");
 
        matcher = datePattern.matcher(str.trim());
 
        if(!matcher.find()) 
        {
	Afficher("Format date invalide");
		good = false;             
        }
 
        else {
        	good = true;
 
                jj = matcher.group(1);
                mm = matcher.group(2);
                yyyy = matcher.group(3);
 
                if( (Integer.valueOf(jj) <0) || (Integer.valueOf(jj)>31) 
                	|| (Integer.valueOf(mm) <0) || (Integer.valueOf(mm)>12)	
                	|| (Integer.valueOf(yyyy) <1970))
			{
              Afficher("Mauvais Date");
              good = false;
			}
 
         } return good;
 
}
 
	private static <T> void Afficher(T e) {
		System.out.println(e.toString());
		// TODO Auto-generated method stub
 
	}
 
}

Merci encore à tous, c'est excellent ce forum:king:
Ps : ya pa moyen de voir le code en entier sans la barre de défilement?? merci

(Pour le "PS") Non, il faut utiliser au pire plusieurs balises CODE.
Sinon, il y a toujours la remarque des dates incorrects : "30-02-2009" va passer avec ton code. Mais pour celà, il suffit de vérifier la date, une fois le test sur le pattern effectué.
Autre chose :
Code:

1 2 3 4 5 DateFormat df = new SimpleDateFormat("dd-MM-yyyy", Locale.FRENCH); date = df.parse(str_format); String format = DateFormat.getDateInstance().format(date); Afficher("Format US: " + date); Afficher("Format FR: " + format);
Tu déclare df avec "Locale.FRENCH", puis tu affiche "Format US". C'est pas très logique ;) Même si date est un objet Date. C'est donc le date.toString() qui va s'appliquer (et donc donner probablement le même format que "format".
Et pareil, "format" affichera la date dans le format local, donc dans la langue de l'utilisateur (de son système d'exploitation).

25/03/2009, 10h55
cashmoney
Merci, mais pour vérifier la date après le test patern, je fais comment?? En fait le locale.FRENCH, quand je parse le format ( ex : 25-02-2005) de ma date
Code:

1 2 date = df.parse(str_format);
Quand j'affiche date, il me sort ce format là
Code:

1 2 Fri Feb 25 00:00:00 CET 2005
alors que j'ai locale.FRENCH alors pour le lire en français, je le rend en String et là il m'affiche
Code:

1 2 25 févr. 2005
Peux-tu m'expliquer pourquoi il ne met pas directement en Français du 1er coup? Et aussi j'ai remarqué que mon patern ("^(\\d{2})-(\\d{2})-(\\d{4})$") n'aime pas les points "." comme séparateur. Pourquoi?
Merci pour vos reponses
25/03/2009, 11h04
JohnNC
Pour vérifier si la date est correct, il suffit de faire
Code:

1 2 3 DateFormat df = new SimpleDateFormat("dd-MM-yyyy", Locale.FRENCH); df.setLenient(false); date = df.parse(str_format);
Il y aura alors une exception.

Pour les formats, tu fais un "Afficher("Format US: " + date);". Il affiche donc "date.toString()". Pour changer ça, il faut faire "Afficher("Format US: " + df.format(date));". Mais là, tu n'es plus en format US.

Pour le pattern, le caractère "." correspond à un caractère à échapper, comme le "\". Mais là, je ne sais pas comment les échapper (peut être en mettant "\" devant ?)

Voir 40 message(s) de cette discussion en une page