Discussion :

[benjamalin]

Hello,

J'ai créé une petite librairie en LGPL qui permet de créer ces méthodes de base java en évitant de coder des règles parfois complexe et souvent rébarbatives.

L'idée est de d'écrire en premier lieu ce qu'est une égalité pour un type d'objet. et après d'écrire en un ligne ces méthodes.

Plus d'info su http://code.google.com/p/equaliz/

Qu'en pensez vous ? Aimeriez vous participer à ce projet ?

[thelvin]

Ça a l'air très bien mais bon... Eclipse et NetBeans le font déjà, il me semble. C'est à utiliser dans quel contexte ?

[professeur shadoko]

comme en témoigne les discussions sur le net l'écriture de equals est complexe et dépend de pleins d'options qui dépendent des propriétés que l'on veut donner aux objets..... Quelle stratégie pour écrire un code qui fasse plaisir à tout le monde?

[Heimdal]

Eclipse et netbeans te génère des méthodes toutes moches après avoir choisi les attributs à prendre en compte... Ça ne passe ni checkstyle, ni pmd, c'est verbeux. Par contre le contrat est bien rempli.

Le plus comparable c'est les EqualsBuilder, HashCodeBuilder, ToStringBuilder de apache commons-lang.

Démarche intéressante cela dit meme si j'aime bien les méthodes equals et hashcode de Object.

[adiGuba]

Salut,

Tu sors quand même l'artillerie lourde non ?

• Une Map en static qui contient toutes la configuration.
• Beaucoup de reflection...
• Des Proxy, qui de plus neccessite une librairie annexe (les Proxy standards ne suffisent pas ?)

Pour equals/hashCode tu peux faire quelques choses de très simple en utilisant un tableau et les méthodes Arrays.deepHashCode() et Arrays.deepEquals().


Exemple :

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 class MyObject {
 
	private String str;
	private Date date;
	private int value;
	private double dbl;
	private int ignored;
 
	/**
         * Méthode privé renvoyant l'identité de l'instance courante,
         * et qui servira à générer les hashCode et vérifier les égalités :
         */
	private Object[] identity() {
		// On retourne uniquement les attributs à utiliser
		// pour identifier l'instance courante :
		return new Object[]{str, value, date, dbl};
	}
 
	@Override
	public int hashCode() {
		return Arrays.deepHashCode(identity());
	}
 
	@Override
	public boolean equals(Object obj) {
		if (obj == this)
			return true;
		if (obj instanceof MyObject) {
			MyObject other = (MyObject) obj;
			return Arrays.deepEquals(this.identity(), other.identity());
		}
		return false;
	}
 
}

a++

[benjamalin]

Hello,

Salut,

Tu sors quand même l'artillerie lourde non ?

• Une Map en static qui contient toutes la configuration.
• Beaucoup de reflection...
• Des Proxy, qui de plus neccessite une librairie annexe (les Proxy standards ne suffisent pas ?)

Sur la map en static ce n'est clairement pas optimal, on pourrait evisager une instance equalize par classe. un peu comme les logger de log4j. C'est effectivement nettement mieux.

La reflexion je ne vois pas trop comment l'éviter.

les proxy standard ne suffisent pas puisque qu'il ne proxy que les interfaces.

Pour equals/hashCode tu peux faire quelques choses de très simple en utilisant un tableau et les méthodes Arrays.deepHashCode() et Arrays.deepEquals().

Excellent, je ne connaissais pas



Merci pour ces points de vue je sens que je vais faire quelques mises à jour

[tchize_]

Salut,

Tu sors quand même l'artillerie lourde non ?

+1, ça risque d'etre très lent, ce qui est dommage quand on considère que les méthodes equals et hashcode doivent être rapides si on veux des collections performantes.

Exemple :

Que je me permet de corriger:

Code :

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

protected Object[] identity()

Sinon tu aura des incohérence dans la méthode equals si tu compare un MyObject avec un MyObjectChild qui l'étends, sans compter que tu aura besoin de recoder equals et hashcode dans chaque fille