Exception sur date

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

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

.

**JohnNC** · 24/03/2009, 12h07

+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.

**tchize_** · 24/03/2009, 12h19

et c'est quoi ce

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

class zzzz throws DatesException {

?

**cashmoney** · 24/03/2009, 12h35

Enfait, je me suis tromper, je voulais tester ainsi

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
if (inputFormat.equals(format)//

voilà

**tchize_** · 24/03/2009, 13h22

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

**JohnNC** · 24/03/2009, 13h30

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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) ;
}

**Astartee** · 24/03/2009, 14h14

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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...

**cashmoney** · 24/03/2009, 16h29

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

**tchize_** · 24/03/2009, 16h43

Va falloir revoir les base de la programmation

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**JohnNC** · 24/03/2009, 17h04

Oui, tu devrais plutôt faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

public static boolean test_date(String str)

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**Astartee** · 24/03/2009, 18h07

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...

**le y@m's** · 24/03/2009, 18h36

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

si ce n'est que la partie

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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)

.

**Astartee** · 24/03/2009, 18h40

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

**cashmoney** · 24/03/2009, 18h44

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

**le y@m's** · 24/03/2009, 19h30

Envoyé par Astartee

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

Oui pardon, j'avais oublié ce point

.
Mais pour le corrigé il suffit d'utiliser la méthode DateFormat.setLenient() en lui passant false en paramètre.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
SimpleDateFormat sdf = new SimpleDateFormat(format);
sdf.setLenient(false);

Plus propre

.

**Astartee** · 24/03/2009, 20h30

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

Envoyé par le y@m's

Oui pardon, j'avais oublié ce point

. Mais pour le corrigé il suffit d'utiliser la méthode [...] Plus propre

.

Ah ouais, beaucoup plus propre, en effet

Je dis toujours de lire la Javadoc mais visiblement je ne lis pas tout en entier moi-même

Bon, j'aurai au moins appris quelque chose aujourd'hui...

**cashmoney** · 25/03/2009, 10h19

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Ps : ya pa moyen de voir le code en entier sans la barre de défilement?? merci

**JohnNC** · 25/03/2009, 10h38

(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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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).

**cashmoney** · 25/03/2009, 10h55

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
date = df.parse(str_format);

Quand j'affiche date, il me sort ce format là

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**JohnNC** · 25/03/2009, 11h04

Pour vérifier si la date est correct, il suffit de faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?)

Exception sur date

Collection et Stream Java

Discussions similaires

Partager

Partager