Discussion :

[tsahal87]

bonjour à tous je me demande pourquoi le premier code suivant:
while( j < T1.length &&(T1[j] == T2[j]))
marche,

tandisque
celui-ci :
while( (T1[j] == T2[j]) && j < T1.length)
me produit une erreur
Je code en java avec Eclipse, et le JRE 1.8;

[austin57]

Bonsoir,

Je suis débutant en Java.
Mais je pense que c'est l'ordre d'évaluation qui pose problème.
Dans le premier cas, tu testes la longueur de la chaine, si le test est concluant, il évalue l'égalité et effectue la boucle. Sinon, fin de la boucle.

Dans le second, il regarde d'abord si tu as égalité entre les deux éléments de ton tableau. Problème, tu peux avoir déjà dépassé la longueur de ton tableau (j venant d'être incrémenté à la boucle précédente) car tu ne testes pas encore la longueur...d'où plantage ArrayIndexOutOfBound.
Pour que cela fonctionne, il faudrait tester si j<T1.length en fin de boucle.


Je pense que c'est ça.
Cordialement,
Damien

[joel.drigo]

Salut,

C'est effectivement un problème d'ordre d'évaluation, mais aussi que pour les combinaisons logiques && et ||, si une première sous-condition évaluée permet de déterminer le résultat complet de la condition sans avoir à évaluer un autre sous-condition, alors les autres ne sont pas évaluées. Dans ces expressions, les sous-conditions sont évaluées dans l'ordre de gauche à droite pour chaque groupe parenthèsé.

Rappels d'algère de Boole :

• vrai || a est toujours vrai, quel que soit a (qu'il soit vrai ou faux)
• faux && a est toujours faux, quel que soit a

(
entre parenthèses, au passage, pour @austin57, il n'y a pas de chaîne de caractères qui intervient dans le code de tashal87. T1.length est la taille d'un tableau (si T1 était une chaîne, alors ce serait T1.length(), et de toute manière on ne pourrait pas écrire T1[j] (ça n'aurait aucun sens). T1 et/ou T2 pourraient être des tableaux de chaines (String[]) mais ce n'est pas pertinent pour l'extrait de code et la problématique posée.
)

Avec, while( j < T1.length &&(T1[j] == T2[j])), on évalue d'abord j <T1.length : si c'est vrai, alors on évalue (T1[j] == T2[j]). Mais c'est faux, alors on n'évalue pas (T1[j] == T2[j]) et c'est justement ce qui permet d'écrire ce genre de boucle facilement.

Alors qu'avec (T1[j] == T2[j]) && j < T1.length), on évalue d'abord (T1[j] == T2[j]), et si j >= T1.length, alors on ne peut obtenir t1[j] sans erreur (ArrayIndexOutOfBoundException = index de tableau en dehors des limites).

A noter qu'il vaudrait mieux écrire : while ( j<T1.length() && j<T2.length && (T1[ j] == T2[j]) {, sinon on a un risque d'exception sur T2[j] (en supposant bien sûr que que j est bien initialisé à une valeur positive non nulle (sans parler d'une condition d'arrêt valide pour la boucle, mais ça, c'est une autre histoire).

Autre cas très utile dans le genre : le test de nullité.

if ( monCapitaine!=null && monCapitaine.getAge()>n ) {Evitera une NullPointerException si monCapitaine vaut null.

[tsahal87]

Merci beaucoup @joel.drigo et @austin57, Si j'ai bien compris tes explications problème était le suivant: quant le compteur (j) de la boucle arrive à j=T1.length alors l'expression T1[j]==T2[j] qui est évaluée en 1er dans le deuxème cas ( (T1[j]==T2[j]) && j<T1.length) se retouve avec un index tableau qui est supérieur à la valeur de l'indexe de la dernière case du tableau qui est égal à T1.length-1 ce qui produit l'erreur, tandisque dans le 1er code ( j<T1.length &&(T1[j]==T2[j])) quant le compteur (j) de la boucle arrive à j=T1.length, la vérification partant de la gauche vers le droite , on teste j<T1.length qui devient faux, et cela évite de tester T1[j]==T2[j], et on sort de la boucle.
Merci beaucoup

[joel.drigo]

C'est bien ça.