Compréhension de code

Version imprimable

Bonjour,
J'aimerais comprendre ce code qui calcule un hashCode :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
public int hashCode()   
       { 
           // On choisit les deux nombres impairs 
           int resultat = 7; 
           final int multiplier = 17; 
    
           // Pour chaque attribut, on calcule le hashcode 
           // que l’on ajoute au résultat après l’avoir multiplié 
           // par le nombre "multiplieur" : 
           resultat = multiplier*resultat + (nom==null ? 0 :
           nom.hashCode());

Je voudrais savoir ce que veut dire ce que j'ai mise en gras
Si quelqu'un a la réponse Merci

20/02/2020, 03h50
foetus
Je ne vois pas sur quoi tu bloques :koi: ... mais ce sont des choses triviales.

le nom==null est un test pour savoir si la variable nom est initialisée/ pointe vers un objet valide. Ce test est obligatoire parce que tu vas appeler la méthode hashCode.

Ou alors c'est sur le test ternaire (()?:). C'est un test qui est équivalent à un test classique sauf 1) qu'il est plus compact et donc on ne peut pas mettre plusieurs lignes de code 2) il produit un résultat - ici on peut mettre le test dans une opération ... ou autre cas classique le mettre à droite d'une affectation (<- hashcode = ((nom==null)? 0: nom.hashCode()).

Donc
Code:

1 2 3 4 5 6 7 8 9 if (TEST) { CODE1 } else { CODE2 } // or ((TEST)? CODE1: CODE2)
PS: :whistle: parenthéser le test n'est pas forcément nécessaire
20/02/2020, 08h01
joel.drigo
Salut,

Citation:

Envoyé par foetus

PS: :whistle: parenthéser le test n'est pas forcément nécessaire

Attention : tout est dans le "forcément" !

En l'occurrence, ici, à cause de la précédence du + sur l'opérateur ternaire, c'est indispensable :
Code:

1 2 3 String nom="x"; System.out.println(10 + (nom==null ? 0 : 10)); // => donne 20 System.out.println(10 + nom==null ? 0 : 10); // => donne 10
20/02/2020, 12h48
foetus

Citation:

Envoyé par joel.drigo

Attention : tout est dans le "forcément" !

En l'occurrence, ici, à cause de la précédence du + sur l'opérateur ternaire, c'est indispensable :

Tu as raison de soulever ce point :mrgreen:
Mais moi je parlais de parenthéser juste le test du test (et éventuellement 1 ou les 2 expressions) pour des questions de lisibilité (quoique lorsqu'il y a trop de parenthèses :whistle:) ... mais ce n'est pas obligatoire.
Mais parenthéser le test en entier ou pas effectivement peut avoir des interprétations différentes : ici on a un cas précis :mrgreen:
22/02/2020, 01h55
xeron33
Citation:
Envoyé par joel.drigo

Salut,

Attention : tout est dans le "forcément" !

En l'occurrence, ici, à cause de la précédence du + sur l'opérateur ternaire, c'est indispensable :

Code:

1 2 3 String nom="x"; System.out.println(10 + (nom==null ? 0 : 10)); // => donne 20 System.out.println(10 + nom==null ? 0 : 10); // => donne 10
****************************
Merci pour ton aide, pourquoi la 2ème ligne donne 10 ?
22/02/2020, 01h56
xeron33
Citation:
Envoyé par foetus

Je ne vois pas sur quoi tu bloques :koi: ... mais ce sont des choses triviales.

le nom==null est un test pour savoir si la variable nom est initialisée/ pointe vers un objet valide. Ce test est obligatoire parce que tu vas appeler la méthode hashCode.

Ou alors c'est sur le test ternaire (()?:). C'est un test qui est équivalent à un test classique sauf 1) qu'il est plus compact et donc on ne peut pas mettre plusieurs lignes de code 2) il produit un résultat - ici on peut mettre le test dans une opération ... ou autre cas classique le mettre à droite d'une affectation (<- hashcode = ((nom==null)? 0: nom.hashCode()).

Donc

Code:

1 2 3 4 5 6 7 8 9 if (TEST) { CODE1 } else { CODE2 } // or ((TEST)? CODE1: CODE2)

PS: :whistle: parenthéser le test n'est pas forcément nécessaire
********************************
Merci pour ton aide je vois maintenant OK
22/02/2020, 15h13
joel.drigo
Citation:

Envoyé par xeron33

****************************
Merci pour ton aide, pourquoi la 2ème ligne donne 10 ?

Je l'ai écrit : à cause de la précédence de l'opérateur + sur l'opérateur ternaire. La précédence va déterminer dans quel ordre Java évalue les calculs intermédiaires et comment ils vont être combinés pour obtenir le résultat final.
- Selon le type d'opérateur, on fait toujours un calcul sur un nombre déterminé d'opérandes :
  1. opérateur unaire : un seule opérande (par exemple l'opérateur !)
  2. opérateur binaire : deux opérandes (par exemple l'opérateur +).
  3. opérateur ternaire : trois opérandes
  S'il y a plusieurs opérateurs dans une expression, plus d'opérandes que l'opérateur peut traiter, on fait des calculs intermédiaires, par association , comme si on introduisait des parenthèses pour regrouper des calculs qui sont évaluables par Java, pour revenir au nombre d'opérandes que l'opérateur peut traiter, quand c'est possible bien sûr. De la même manière, s'il y a plusieurs opérateurs différents.
  
  Par exemple, pour 5 + 1 + 3, on va faire une somme entre 2 opérandes, puis une somme entre cette somme intermédiaire et le troisième opérande. A cause de l'associativité, l'ordre des opérations intermédiaires compte, en particulier si les opérateurs sont différents, comme dans 5 + 1 * 3, par exemple.
- Lorsqu'on écrit une expression avec plusieurs opérateurs le résultat tient compte de la précédence : on ne fait pas les opérations dans un ordre quelconque.
  La précédence et l'ordre des opérandes sont importants :
  - Mathématiquement, déjà, tous les opérateurs ne sont pas commutatifs ( x op y n'est pas égale à y op x )..
  - Le type des opérandes compte en Java
    
    Code:
    
    1 2 3 4 int x = 5; int y = 2; int r = x / y; // 2
    
    Code:
    
    1 2 3 double x = 5; double y = 2; double r = x / y; // 2.5
  - L'associativité ou la non associativité est déterminante. En particulier si les types des opérandes sont différents. Surtout qu'un calcul entre deux opérandes de types différents va effectuer une conversion.
    Par exemple :
    
    Code:
    
    1 2 String s0 = "a" + 1 + 2; // a12 parce qu'on calcule d'abord "a" + 1 puis "a1" + 2 String s1 = "a" + (1 + 2); // a3 parce qu'on calcule d'abord 1 + 2 puis "a" + 3
  Prenons l'expression : x op y op z. On peut faire le calcul
  - de cette manière : (x op y) op z
    
    d'abord r₀ ← x op y
    puis r₁ ← r₀ op z
  - de cette manière : x op ( y op z )
    
    d'abord r₀ ← y op z
    puis r₁ ← x op r₀
  1. lorsque l'opérateur est le même, l'ordre est de gauche à droite (si l'opérateur est mathématiquement commutatif ça ne compte pas, mais s'il ne l'est pas l'ordre a une importance)
    
    int i = 5 + 1 + 3; // i vaut 9.
    5 + 1 + 3 = 1 + 3 + 5 → 9
    
    Code:
    
    1 2 3 4 int x = 12; int y = 2; int z = 3; int r = x / y / z; // r vaut 2
    
    Si on contraint l'ordre par des parenthèses, le résultat sera différent selon la position de ces parenthèses :
    
    Code:
    
    1 2 3 4 int x = 12; int y = 3; int z = 2; int r = (x / y) / z; // r vaut 2, on fait 12 / 3, ce qui fait 4, puis 4 / 2, ce qui fait 2
    
    Code:
    
    1 2 3 4 int x = 12; int y = 3; int z = 2; int r = x / ( y / z); // r vaut 12, on fait 3 / 2, ce qui fait 1, puis 12 / 1, ce qui fait 12
  2. Lorsque l'opérateur est différent, la précédence intervient aussi :
    
    Code:
    
    1 2 3 System.out.println(12 + 3 * 2); // 18 : la précédence fait qu'on traite le * avant le + System.out.println(12 + (3 * 2)); // 12 + 6 → 18 System.out.println((12 + 3) * 2); // 15 * 2 → 30
Donc pour résumer, quand Java traite System.out.println(10 + nom==null ? 0 : 10);, il considère que, + étant précédent à l'opérateur ternaire, il doit calculer le résultat du +, un opérateur binaire, donc un + entre les deux opérandes de part et d'autre du +, donc 10 et nom. 10+"x" donc "10x". Puis on évalue la condition, "10x" == null, qui vaut false, donc le résultat de l'évaluation par l'opérateur ternaire est la valeur après le :, donc 10. CQFD.

Alors que dans l'autre cas, System.out.println(10 + (nom==null ? 0 : 10));, les parenthèses imposent qu'on évolue le résultat de l'opérateur ternaire en premier, qui donne 10, puisque nom n'est pas null, puis on calcule 10 + 10, donc ça fait 20.
26/02/2020, 20h10
xeron33

Citation:

Envoyé par joel.drigo

Donc pour résumer, quand Java traite System.out.println(10 + nom==null ? 0 : 10);, il considère que, + étant précédent à l'opérateur ternaire, il doit calculer le résultat du +, un opérateur binaire, donc un + entre les deux opérandes de part et d'autre du +, donc 10 et nom. 10+"x" donc "10x". Puis on évalue la condition, "10x" == null, qui vaut false, donc le résultat de l'évaluation par l'opérateur ternaire est la valeur après le :, donc 10. CQFD.

Alors que dans l'autre cas, System.out.println(10 + (nom==null ? 0 : 10));, les parenthèses imposent qu'on évolue le résultat de l'opérateur ternaire en premier, qui donne 10, puisque nom n'est pas null, puis on calcule 10 + 10, donc ça fait 20.

**************************************************
Ok maintenant je vois bien MErci encore pour toutes ces infos
A+