Bonsoir, j'ai un programme avec une classe groupe et etudiants 

public class Etudiant extends Personne  implements Comparable<Etudiant> {
      private Groupe groupe = null;
      private String adresseParents;
      private ArrayList<Note> notes = new ArrayList<>(); 
   /* constructeurs */
    
    Etudiant(String nom, String prenom, String login) {
        super (nom, prenom, login);
    }
    
    Etudiant(String nom, String prenom, String login, Groupe groupe) {
        super (nom, prenom, login);
        this.groupe = groupe;
        
        groupe.addEtudiant(this);
    }
    
    Etudiant(String nom, String prenom, String login, Note note) {
        super (nom, prenom, login);
        this.notes.add(note);
        
    }
    
    Etudiant(String nom, String prenom, String login, String adresseE, String adresseP) {
       super (nom, prenom, login);
       
       setAdresse(adresseE ,adresseP);
    }
    
    /* interface comparable */
    
  
    
    
    /* getters */
    
    public Groupe getGroupe() {
        return groupe;
    }

    @Override
    public String getEmail() {
        return (this.getPrenom()+"." + this.getNom() + "@outlook.fr").toLowerCase();
    }

    public String getAdresseParents() {
        return this.adresseParents;
    }
    /* setters */

    public void setGroupe(Groupe groupe) {
        if (this.groupe == null) {
            this.groupe = groupe;
            
            groupe.addEtudiant(this);
        }
    }
    
    
    public void setAdresse(String adresseParent, String adresseEtudiant) {
        setAdresse(adresseEtudiant);
        this.adresseParents = adresseParent;
    }

    public ArrayList<Note> getNotes() {
        return notes;
    }
    
    public Note getNoteI(int i) { /* return la n eme note */
        return this.notes.get(i);
    }
    
    
    /* méthodes */
    
 
      @Override
    public void Affiche() {
        System.out.println("Informations étudiant");
        System.out.println("Prénom: " + this.getPrenom());
        System.out.println("Nom: " + this.getNom());
        System.out.println("login: " + this.getLogin());
        System.out.println("Adresse :" + this.getAdresse());
        System.out.println("Adresse des parents :" + this.getAdresseParents());
        System.out.println("Email: " + this.getEmail());

    } 
    
    public void addNote(Note n) {
        this.notes.add(n);
    }
    
    public void SuppNoteI(int i) { /* la methode va supprimer la note d'indice i */
        this.notes.remove(i);
    }
    
    public void AfficherNotes() {
        for (Note n : notes) {
            System.out.println("note:" + n);
        }
    }
    
    public boolean estDansLeGroupe (Groupe groupe ) {
        if (this.groupe == groupe ) {
            return true;
        }
        else {
            return false;
        }
    }
  
   
    @Override
    public int compareTo(Etudiant t) {
       if ((this.getNom().compareTo(t.getNom())) > 1) {
           return 1;
       }
       else if ((this.getNom().compareTo(t.getNom())) < -1) {
           return -1;
       }
       else if ((this.getNom().compareTo(t.getNom())) == 0) { /* meme nom */
           if ((this.getPrenom().compareTo(t.getPrenom())) > 1) {
               return 1;
           }
           else if ((this.getPrenom().compareTo(t.getPrenom())) < 1) {
               return -1;
           }
       }
       return 0; /* meme nom ET meme prenom */
    }   
}

public class Groupe {
    private String libelle;
    private TreeSet<Etudiant> etudiants = new TreeSet<Etudiant>();  

    Groupe(String libelle) {
        this.libelle = libelle;
    }
    
    /* getters et setters */

    public String getLibelle() {
        return libelle;
    }

    public void setLibelle(String libelle) {
        this.libelle = libelle;
    }
    
    /* méthodes */
    
     public void afficherEtudiants() {
        Iterator itr = this.etudiants.iterator();
        
        while (itr.hasNext()) {
            Etudiant etu = (Etudiant) itr.next();
            
            etu.Affiche();
            System.out.println("---------------------------------");
        }
    }
    
    public void addEtudiant(Etudiant etudiant) {
        this.etudiants.add(etudiant);
        etudiant.setGroupe(this);
    }
    
    public boolean contientEtudiant(Etudiant etudiant) {
        return this.etudiants.contains(etudiant);
    }
    
    public TreeSet getEtudiants () {
        return this.etudiants;
    }
    
 }

avec mon main 

 public static void main(String[] args) {
        Groupe G1 = new Groupe("G1");
        Groupe G2 = new Groupe("G2");
        
        Etudiant e1 = new Etudiant ("Voiture", "Robert", "voiturer");
        Etudiant e2 = new Etudiant ("Bateau", "Alice", "bateaub");
        Etudiant e3 = new Etudiant ("Froussard", "Noe", "froussardd");
        Etudiant e4 = new Etudiant ("Valise", "Marion", "valisev", G1);
        Etudiant e5 = new Etudiant ("Table", "Patrick", "tablep", G2);
        Etudiant e6 = null;
        
        e1.setGroupe(G1);
        e2.setGroupe(G1);
        e3.setGroupe(G2);
        e5.setGroupe(G1);
        
        /* On affiche les etudiants de chaque groupe */
        
        /* Groupe G1 */
        
        G1.afficherEtudiants();
        
        System.out.println("");
        /* Groupe G2 */

        G2.afficherEtudiants();

        G1.addEtudiant(e5);
        G1.addEtudiant(e5);
        G1.addEtudiant(e5);
        G1.addEtudiant(e5);
        G1.addEtudiant(e5);
        G1.addEtudiant(e5);

        G2.afficherEtudiants(); /* pas de doublon car TreeSet */
        
        /* Test voir si setGroupe() ajoute bien l'étudiant dans le groupe  */
        
        e6 = new Etudiant("fluo", "julie", "login");
        
        G2.addEtudiant(e6);
        
       System.out.println(G2.getEtudiants().contains(e6));
    }

Normalement, quand j'ajoute un étudiant a un groupe, le groupe auquel l'étudiant a été ajouté va être affecté  dans l'attribut groupe de la classe étudiante et si j'ajoute un groupe a un étudiant, ça va automatique ajouter l'étudiant au groupe.

Même si ça fonctionne, en gros quand j'attribue un groupe a un étudiant, l'étudiant est bien ajouté dans le groupe, sauf que même si il est présent dans le groupe, quand j'utilise la méthode contains, ça me renvoie false ... Du coup j'arrive pas à comprendre pourquoi.

Genre si j'ai ajouté l'étudiant e1 au groupe G1, si je fais un G1.getEtudiants().contains(e1), ça me retourne false alors que l'étudiant est bien dans le groupe. 

Si quelqu'un pourrait m'aider je lui en serait reconnaissant. 

-
Edité par VxcvxcCvxwxv 14 novembre 2020 à 20:03:52

Salut,

Si tu regardes la javadoc de la classe Collection, tu verras que contains appelle la méthode equals pour déterminer si un élément appartient à la liste. Il faut donc que tu redéfinisses cette méthode pour l'adapter à ton cas

salut, c'est ce que j'avais fait mais ça marchait toujours pas, j'avais @Override equals dans la classe Etudiant mais rien n'y fait :( 

Melin Alexandre a écrit:

N'hésite pas à poster ta méthode equals pour qu'on puisse vérifier

  @Override
    public boolean equals(Object o) {
    if (!(o instanceof Etudiant))
    return false;
    
    Etudiant e = (Etudiant) o;
    
    return this == e; 
    }

Play50hz a écrit:

Faut aussi la méthode hashcode, jamais d'equals sans hashcode

C'est faux, on a besoin du hash d'un objet que dans certains cas

VxcvxcCvxwxv a écrit:

Melin Alexandre a écrit:

N'hésite pas à poster ta méthode equals pour qu'on puisse vérifier

  @Override
    public boolean equals(Object o) {
    if (!(o instanceof Etudiant))
    return false;
    
    Etudiant e = (Etudiant) o;
    
    return this == e; 
    }

Bonjour, j'avais mis ce code dans la classe étudiant. Je voulais juste faire une comparaison par adresse 

-
Edité par Splintz 15 novembre 2020 à 16:43:30

Splintz a écrit:

Play50hz a écrit:

Faut aussi la méthode hashcode, jamais d'equals sans hashcode

C'est faux, on a besoin du hash d'un objet que dans certains cas

VxcvxcCvxwxv a écrit:

Melin Alexandre a écrit:

N'hésite pas à poster ta méthode equals pour qu'on puisse vérifier

  @Override
    public boolean equals(Object o) {
    if (!(o instanceof Etudiant))
    return false;
    
    Etudiant e = (Etudiant) o;
    
    return this == e; 
    }

Bonjour, j'avais mis ce code dans la classe étudiant. Je voulais juste faire une comparaison par adresse 

le problème ici c'est qu'en faite ta méthode equals ne fait rien de nouveau, tu dois comparer les attributs de ta classe Etudiant, tout en vérifiant que ces attributs ont aussi leurs méthode equals de redéfinie

-
Edité par Splintz il y a 12 minutes

-
Edité par VxcvxcCvxwxv 15 novembre 2020 à 17:18:31

Re,

Apres avoir regardé un peu ton code, ton problème vient de la méthode compareto.

Certaines valeurs devraient être négatives alors qu'elles sont positives (notamment pour la comparaison des prénoms). Un conseil, quand tu fais une méthode compareTo raisonne par rapport à 0 pour éviter les pièges des valeurs incluses/excluses (on vite mettre un '<' au lieu d'un '<=').

 @Override
    public int compareTo(Etudiant t) {
       
     if ((this.getNom().compareTo(t.getNom()) == 0) && (this.getPrenom().compareTo(t.getPrenom())) == 0)
       return 0; //mm nom + mm prenom
     else if (this.getNom().compareTo(t.getNom()) > 0)
             return 1;
     else if (this.getNom().compareTo(t.getNom()) < 0)
            return -1;
     else if ((this.getNom().compareTo(t.getNom()) == 0) && (this.getPrenom().compareTo(t.getPrenom()) > 0))
         return 1;
     else if ((this.getNom().compareTo(t.getNom()) == 0) && (this.getPrenom().compareTo(t.getPrenom()) < 0))
         return -1;
    } 

Melin Alexandre a écrit:

Re,

Apres avoir regardé un peu ton code, ton problème vient de la méthode compareto.

Certaines valeurs devraient être négatives alors qu'elles sont positives (notamment pour la comparaison des prénoms). Un conseil, quand tu fais une méthode compareTo raisonne par rapport à 0 pour éviter les pièges des valeurs incluses/excluses (on vite mettre un '<' au lieu d'un '<=').

-
Edité par VxcvxcCvxwxv 15 novembre 2020 à 19:12:08

Splintz a écrit:

C'est faux, on a besoin du hash d'un objet que dans certains cas

Play50hz a écrit:

Faut aussi la méthode hashcode, jamais d'equals sans hashcode

La Javadoc est pourtant claire à ce sujet, le contrat de hashcode est qu'il doit toujours retourner la même valeur entre 2 objets dès lors que ces objets sont égaux, si la méthode equals est redéfinie(autrement que par son implémentation d'origine il s'entend), il faudra donc nécessairement redéfinir hashcode.

Ce n'est ni vrai, ni faux, c'est un contrat, l'ignorer est clairement une mauvaise pratique.

La doc officielle d'Oracle à ce sujet:

By definition, if two objects are equal, their hash code must also be equal. If you override the equals() method, you change the way two objects are equated and Object's implementation of hashCode() is no longer valid. Therefore, if you override the equals() method, you must also override the hashCode() method as well.

La javadoc d'equals:

Note that it is generally necessary to override the hashCode method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.

Divers sites (stackoverflow, baeldung...)

hashCode() returns an integer representing the current instance of the class. We should calculate this value consistent with the definition of equality for the class. Thus if we override the equals() method, we also have to override hashCode().

L'analyseur statique de code Sonarqube considère cette pratique comme un critical issue.

-
Edité par P.X.L 16 novembre 2020 à 0:20:56

Bonjour,

Un petit mot d'explication concernant equals et hashCode.

equals sert à tester l'égalité entre deux objets. Il n'a pas besoin d'hashCode pour fonctionner correctement.

hashCode sert à permettre l'utilisation des HashSet et HashMap. Ces deux collections dépendent aussi de la méthode equals pour fonctionner correctement.

Moralité : Si on veut pouvoir mettre ses objets dans des HashSet ou des HashMap, on doit implémenter equals ET hashCode.

Si on veut juste tester l'égalité entre objets, ça dépend du contexte.

Dans un contexte professionnel, on se doit d'implémenter aussi hashCode par souci de complétude.

Pour un projet scolaire/personnel, tu peux implémenter hashCode pour t'habituer à respecter les bonnes pratiques mais ça ne sert strictement à rien. Ton code fonctionnera très bien sans hashCode.

@Override
public int compareTo(Etudiant t) {
    int compareNom = this.getNom().compareTo(t.getNom());
    if(compareNom != 0) //les deux noms ne sont pas égaux
        return compareNom;
    //les deux noms sont égaux, on compare donc le prénom
    int comparePrenom = this.getPrenom().compareTo(t.getPrenom());
    return comparePrenom;
}

public void setGroupe(Groupe groupe) {
    if (this.groupe == null) {
        this.groupe = groupe;         
        groupe.addEtudiant(this);
    }
}

-
Edité par ArgAur 19 novembre 2020 à 4:27:32