Intervalle au moyen d'un tableau

Version imprimable

24/08/2015, 17h01
uqerfromfrance

Intervalle au moyen d'un tableau

Bonjour,

J'ai une question surement très simple pour vous, comment peut-on représenter un intervalle au moyen d'un tableau?

Voila, c'est tout!

Merci d'avance
24/08/2015, 17h26
thelvin

Hello,

Eh bien, un intervalle est défini avec deux données : sa borne inférieure et sa borne supérieure.

Du coup, avec un tableau, il suffit d'un tableau à deux entrées qui contient ces deux nombres.
Mais il serait plus propre de créer une classe Intervalle que d'utiliser un tableau.
24/08/2015, 19h38
uqerfromfrance

D'accord, merci!
Mais quelle serait la syntaxe employée?

int tableauEntier[] = {0,1} par exemple, pour l'intervalle [0,1]?

Salut,

thelvin te propose de créer une classe.

Perso, j'ai tenté un classe Intervalle à ma manière, je ne sais pas si cela conviendra à tes besoins et surement que Thelvin va faire mieux :oops:.
Merci aux pros de corriger si j'écris des bêtises :)
Code:

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 import java.util.HashSet; import java.util.Set; public class Intervalle { //DECLARATIONS private int borneMin; private int borneMax; private Integer[] tableau; //CONSTRUCTEURS public Intervalle(int borneMin, int borneMax) { if(borneMin < borneMax){ setBorneMin(borneMin); setBorneMax(borneMax); } } public Intervalle(int longueurTableau, int borneMin, int borneMax) { if(borneMin < borneMax){ setBorneMin(borneMin); setBorneMax(borneMax); setTableau(new Integer[longueurTableau]); } } public Intervalle(Integer[] tableau, int borneMin, int borneMax) { if(borneMin < borneMax){ setBorneMin(borneMin); setBorneMax(borneMax); setTableau(tableau); } } //METHODES public Integer[] getIntervalle(int borneMin, int borneMax){ if(tableau != null){ Set<Integer> tableSet = new HashSet<Integer>(); Integer[] tableauRestreint; for(int rank = borneMin; rank < borneMax; rank++){ tableSet.add(getTableau()[rank]); } tableauRestreint = (Integer[]) tableSet.toArray(); return tableauRestreint; } else { return null; } } //ACCESSEURS public int getBorneMin() {return borneMin;} public void setBorneMin(int borneMin) {this.borneMin = borneMin;} public int getBorneMax() {return borneMax;} public void setBorneMax(int borneMax) {this.borneMax = borneMax;} public Integer[] getTableau() {return tableau;} public void setTableau(Integer[] tableau) {this.tableau = tableau;} }
j'ai créé une classe ayant trois constructeurs qui sont protégés d'une borneMin plus grande qu'une borneMax.

Un premier constructeur ne prenant en paramètres que les bornes. Ce constructeur ne créé pas de tableau et tu devras donc faire un setTableau() avant d'appeler la méthode getIntervalle().
un constructeur prenant en paramètres une longueur de tableau et les bornes. Ce constructeur créera le tableau tout seul.
Un troisième constructeur prenant en paramètres un tableau que tu aurais déjà créé.

Ensuite, j'ai ajouté une méthode qui te renvoie un tableau en fonction de bornes que tu auras entrées en paramètres à cette
te fonction. Pour cette méthode getIntervalle(), j'ai essayé de la protéger d'un appel de tableau dans le cas où le tableau n'aurait pas encore été instancié mais je ne sais pas quoi retourner à part un return null dans le cas où on passe par le else (ce qui finalement reviens à ne pas sécuriser mais c'est à toi de savoir ce que tu veux renvoyer dans ce cas là) mais tu peux aussi choisir de renvoyer un tableau vide en le créant à la volée.

Par contre, le tableau est un tableau d'objets (Integer) et non pas un tableau du type primitif (int).

J'ai aussi créé des accesseurs qui te permettrons de manier les attributs de la classe.
Je pense que si cette classe te plaît et que tu souhaites l'utiliser, tu peux transformer tes anciens tableaux d'int en tableaux d'Integers !

plus de précisions entre int et Integer ici ou là

:D

26/08/2015, 04h33
joel.drigo
Salut,

@Francky74, quelques remarques :
1. Une classe qui représente un intervalle doit représenter un intervalle, ni plus, ni moins. Un intervalle, c'est un minimum et un maximum. Il n'y a aucune notion de tableau. Eventuellement, on pourrait avoir des notions d'inclusion ou exclusion de bornes.
  On peut bien sûr fournir une méthode utilitaire qui produit l'ensemble des valeurs comprises entre les 2 bornes, mais pas besoin de tableau en entrée (et encore moins de le stocker en attribut — si on a besoin d'une telle méthode, passer le tableau en paramètre de la méthode).
  Mais il me semble plus utile par ailleurs d'avoir des méthodes qui permettent de tester si des valeurs sont dans l'intervalle ou pas, ou si un intervalle est inclus dans un autre, ou s'il y a intersection, etc.
2. tant qu'à faire, autant avoir les bornes déclarées final, coder hashCode() et equals() (et accessoirement toString()), ce qui permettrait d'utiliser la classe comme clef dans une Map, d'autant que l'intérêt de modifier les bornes est très limité (et on peut toujours créer une nouvelle instance au besoin)
3. Attention : un Set ne garantit pas l'ordre des éléments qui s'y trouvent. Construire le tableau comme tu le fais en passant par un Set intermédiaire va avoir comme conséquence que le tableau obtenu sera "mélangé" par rapport au tableau source : c'est plutôt génant.
4. tableauRestreint = (Integer[]) tableSet.toArray(); va planter (ClassCastException) : un Object[] n'est pas castable en Integer[] !
5. Déclare toujours tes variables au plus près de leur usage :
  Code:
  
  1 2 3 4 5 Integer[] tableauRestreint; for(int rank = borneMin; rank < borneMax; rank++){ tableSet.add(getTableau()[rank]); } tableauRestreint = (Integer[]) tableSet.toArray();
  Pourquoi déclarer tableauRestreint avant le for ?
6. Attention à ce genre de constructeur :
  Code:
  
  1 2 3 4 5 6 public Intervalle(int borneMin, int borneMax) { if(borneMin < borneMax){ setBorneMin(borneMin); setBorneMax(borneMax); } }
  Si les bornes ne respectent pas la condition, on créé une instance "inconsistante", silencieusement, qui ne correspond pas aux paramètrex. C'est plutôt déroutant pour celui qui va utiliser la classe, pour peu qu'il n'est pas accès au source (rare sont ceux qui le regarde d'ailleurs). Il vaudrait mieux soulever une exception que de rien faire (une IllegalArgumentException par exemple).
7. A noter, par ailleurs, que pour extraire un intervalle
  - d'un tableau, on peut utiliser Arrays.copyOfRange(tab, from, to), ce qui permet en plus de pouvoir le faire sur un int[] (sans faire de manipulation diverses) ;
  - d'une List, on peut utiliser List.sublist(from, to).

Bonjour Joel et merci pour ces précieux conseils ;)

En suivant vos conseils, voici ce que j'ai créé :

Une classe Intervalle suivie d'une classe InterMain qui m'a permi de tester la classe Intervalle :

Code:

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
import java.util.Arrays;
 
public class Intervalle {
	//**************************DECLARATIONS
	private int borneMin;
	private int borneMax;
	private boolean isMinIncluded, isMaxIncluded;
 
	//**************************CONSTRUCTEURS
	//constructeur dont les bornes sont toutes incluses par défaut
	public Intervalle(int borneMin, int borneMax){
		this(borneMin, true, borneMax, true);
	}
 
	//constructeur permettant d'inclure ou exclure les deux bornes en même temps
	public Intervalle(int borneMin, int borneMax, boolean isAllIncluded) {
		this(borneMin, isAllIncluded, borneMax, isAllIncluded);
	}
 
	//constructeur permettant d'inclure ou exclure chaque borne séparément
	public Intervalle(int borneMin, boolean isMinIncluded, int borneMax, boolean isMaxIncluded){
		if(borneMin > borneMax){
			throw new IllegalArgumentException(" borneMin > borneMax ");
		}
 
		setBorneMin(borneMin);
		setBorneMax(borneMax);
		setMinIncluded(isMinIncluded);
		setMaxIncluded(isMaxIncluded);
	}
 
	//**************************METHODES
	public int[] rangeTabInt(int[] tableau){
 
		int[] tab;
		int min = 0, max = 0;
 
		//on définit la longueur du tableau selon si les bornes sont inclues ou exclues
		//on en profite pour initialiser le bornes 
		if(isMinIncluded == true && isMaxIncluded == true){
			tab = new int[(borneMax - borneMin)];
			min = borneMin;
			max = borneMax;
		} else if (isMinIncluded == false && isMaxIncluded == false){
			tab = new int[(borneMax - borneMin - 2)];
			min = ++borneMin;
			max = --borneMax;
		} else if (isMinIncluded == false && isMaxIncluded == true){
			tab = new int[(borneMax - borneMin - 1)];
			min = ++borneMin;
			max = borneMax;
		} else if (isMinIncluded == true && isMaxIncluded == false){
			tab = new int[(borneMax - borneMin - 1)];
			min = borneMin;
			max = --borneMax;			
		} else {
			throw new IllegalArgumentException(" problème d'inclusion exclusion des bornes ");
		}
 
		tab = Arrays.copyOfRange(tableau, min, max);
 
		return tab;
	}
 
	//**************************ACCESSEURS
	public int getBorneMin() {return borneMin;}
	public void setBorneMin(int borneMin) {this.borneMin = borneMin;}
 
	public int getBorneMax() {return borneMax;}
	public void setBorneMax(int borneMax) {this.borneMax = borneMax;}
 
	public boolean isMinIncluded() {return isMinIncluded;}
	public void setMinIncluded(boolean isMinIncluded) {this.isMinIncluded = isMinIncluded;}
 
	public boolean isMaxIncluded() {return isMaxIncluded;}
	public void setMaxIncluded(boolean isMaxIncluded) {this.isMaxIncluded = isMaxIncluded;}
}

classe de test InterMain :

Code:

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
public class InterMain {
 
	public static void main(String[] args) {
		//définitions des intervalles
		int interMin = 3, interMax = 7;
		Intervalle intervalleTT = new Intervalle(interMin, interMax);
		Intervalle intervalleFF = new Intervalle(interMin, interMax, false);
		Intervalle intervalleTF = new Intervalle(interMin, false, interMax, true);
		Intervalle intervalleFT = new Intervalle(interMin, true, interMax, false);
		System.out.println("borne max : " + intervalleTT.getBorneMax() + " / borne min : " + intervalleTT.getBorneMin() + "\n");
 
		//création d'un tableau de test
		int[] tab = {1,2,3,4,5,6,7,8};
 
 
		System.out.println("*********************************\n");
		int[] tabRangedtt = intervalleTT.rangeTabInt(tab);
 
		System.out.println("\ttoutes bornes incluses : ");
		for(int rank = 0; rank < tabRangedtt.length; rank++){
			System.out.println(tabRangedtt[rank]);
		}
		System.out.println("*********************************\n");
		int[] tabRangedff = intervalleFF.rangeTabInt(tab);
 
		System.out.println("\ttoutes bornes exluses : ");
		for(int rank = 0; rank < tabRangedff.length; rank++){
			System.out.println(tabRangedff[rank]);
		}
		System.out.println("*********************************\n");
		int[] tabRangedtf = intervalleFT.rangeTabInt(tab);
 
		System.out.println("\t borne min inclue, borne max exclue : ");
		for(int rank = 0; rank < tabRangedtf.length; rank++){
			System.out.println(tabRangedtf[rank]);
		}
		System.out.println("*********************************\n");
		int[] tabRangedft = intervalleTF.rangeTabInt(tab);
 
		System.out.println("\t borne min exclue, borne max inclue : ");
		for(int rank = 0; rank < tabRangedft.length; rank++){
			System.out.println(tabRangedft[rank]);
		}
		System.out.println("*********************************\n");
	}
 
 
}

Voilà, j'ai essayé de suivre vos conseils au mieux !

Voici le résultat d la console :

Code:

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
borne max : 7 / borne min : 3
 
*********************************
 
	toutes bornes incluses : 
4
5
6
7
*********************************
 
	toutes bornes exluses : 
5
6
*********************************
 
	 borne min inclue, borne max exclue : 
4
5
6
*********************************
 
	 borne min exclue, borne max inclue : 
5
6
7
*********************************

Par contre, je n'ai pas compris ceci :

Citation:

tant qu'à faire, autant avoir les bornes déclarées final, coder hashCode() et equals() (et accessoirement toString()), ce qui permettrait d'utiliser la classe comme clef dans une Map, d'autant que l'intérêt de modifier les bornes est très limité (et on peut toujours créer une nouvelle instance au besoin)

Merci ;)

Citation:

Envoyé par francky74

Par contre, je n'ai pas compris ceci :

Citation:

tant qu'à faire, autant avoir les bornes déclarées final, coder hashCode() et equals() (et accessoirement toString()), ce qui permettrait d'utiliser la classe comme clef dans une Map, d'autant que l'intérêt de modifier les bornes est très limité (et on peut toujours créer une nouvelle instance au besoin)

Bah, tiens, justement, modifie ton code comme çà :
Code:

1 2 3 4 5 6 7 8 public class Intervalle { private final int borneMin; private final int borneMax; private final boolean isMinIncluded; private final boolean isMaxIncluded; /* ... le reste demeure inchangé ... */
Et tu vas voir ce qu'il se passe.

Je te donnerai des explications plus complètes plus tard.

26/08/2015, 19h36
francky74

8O

Des erreurs de partout !!!!

Il m'est demandé d'initialiser mes final et ensuite, il m'est demandé d'enlever le mot clé final dans les setters et dans les endroits ou j'incrémente puisqu'il ne faut pas modifier les final.

En fait je ne peux tout simplement pas instancier mes variables dans le constructeur !

Si quelqu'un m'avais demandé de passer ces variables en final, ma réponse aurait été qu'il ne faut surtout pas ! Mais comme comme vous êtes bien plus expérimenté que moi, je tape en touche et je vous demande des explications car je ne comprends pas l'utilité :)

Merci ;)

Citation:

Envoyé par francky74

Il m'est demandé d'initialiser mes final et ensuite, il m'est demandé d'enlever le mot clé final dans les setters

ça c'est juste parce que tu as mis des setters : l'idée quand on met ses attributs final, c'est justement de ne pas mettre de setters, parce qu'on ne veut pas qu'on puisse modifier les valeurs.
tu peux très bien écrire :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 public class Intervalle { private final int max; private final int min; public Intervalle(int min, int max) { if ( min>max ) throw new IllegalArgumentException("min must be lesser and equals than max: "+mix+">"+max); this.min=min; this.max=max; } /*...*/ }
En plus dans ton cas, si on appelle les setters après la construction, on peut faire n'importe quoi (faire des intervalles avec un min>max).

Il peut y avoir des raisons fonctionnelles de modifier un intervalle après sa création, mais je pense que le cas général fonctionnel, c'est plutôt l'inverse : si je définis un intervalle, en théorie, ses bornes ne doivent pas changer n'importe quand. Si elles devaient quand même changer, il serait préférable, à mon avis, de récréer un nouvel intervalle avec les nouvelles bornes. L'avantage, déjà, c'est que tu es sûr que ton intervalle reste cohérent (si l'instance existe, l'intervalle est valide et reste toujours le même), donc le code qui l'utilise l'est (du moins vis-à-vis de l'intervalle), y compris en multi-thread (une même instance d'intervalle peut être utilisée par plusieurs threads sans risque).
Ensuite, le fait que la classe soit immutable la rend candidate pour servir de clef pour une map (aussi faut-il implémenter hashCode() et equals()) : c'est très intéressant de pouvoir faire une map, ou l'on associe à des intervalles, quelque chose (par exemple, une fonction).

Citation:

Envoyé par francky74

et dans les endroits ou j'incrémente puisqu'il ne faut pas modifier les final.

Et oui : justement, là, ça te permet de voir que tu as fait une grossière erreur : tu modifies tes bornes à chaque fois que tu extrais une partie d'un tableau, donc tu dégrades ton intervalle.
Personnellement, si on utilise une API qui propose une classe de gestion d'intervalle et que quand on créé un intervalle [0, 100[ par exemple, et qu'il suffit que on appelle rangeTabInt() une première fois et que ça renvoie les valeurs de 0 à 99, puis lors d'un second appel sur le même tableau et ça renvoie les valeurs de 0 à 98, avoue qu'il y a de quoi être décontenancé. Le but d'une telle méthode est de se comporter de manière cohérente : si je créé un intervalle [0, 100[, il n'y aucune raison qu'il devienne [0,99[ parce que j'ai extrait des données d'un tableau.

Il y a un autre avantage à rendre des variables final : c'est une indication que le compilateur utilise pour faire certaine optimisation. Ce type d'optimisation est d'autant plus intéressant que la classe est une classe de base, fonctionnellement parlant : je veux dire dont on peut gérer des dizaines, voire des centaines d'instances. C'est le cas d'ailleurs pour Integer, Double ou String.

NB. pour l'implémentation de hashCode et equals() il suffit de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 public int hashCode() { return Objects.hash(min, max); } public boolean equals(Object obj) { if ( obj!=null && Intervalle.class.equals(obj.getClass()) ) { return equals((Intervalle)obj); } else { return false; } } protected final boolean equals(Intervalle intervalle) { return intervalle.min == min && intervalle.max == max; }

26/08/2015, 21h03
francky74

Citation:

En plus dans ton cas, si on appelle les setters après la construction, on peut faire n'importe quoi

C'est vrai que ce n'est pas très sécurisé .... :oops:

Citation:

c'est une indication que le compilateur utilise pour faire certaine optimisation

Intéressant à connaitre pour coder dans ce sens !

Bonsoir,

Donc, suivant les conseils de Joel, je poste la classe Intervalle remaniée avec des finals et méthodes hashCode puis equals qui sont effectivement intéressantes.

Je n'ai pas compris la méthode hashCode, elle renvoie toujours 1061 dans mon exemple, et ce quelque soit l'intervalle ... :koi:

Toutefois, Joel, j'ai l'impression que dans votre dernier code, il y a un dead code. Je m'explique et vous me contredirez si j'ai tort : :whistle:

Citation:

NB. pour l'implémentation de hashCode et equals() il suffit de

Code:

1
2
3
4
5
6
7
8
9
10
11
public boolean equals(Object obj) {
     if ( obj!=null && Intervalle.class.equals(obj.getClass()) ) {
         return equals((Intervalle)obj);
     }
     else { 
         return false;
     }
}
protected final boolean equals(Intervalle intervalle) {
      return intervalle.min == min && intervalle.max == max;
}

En fait, nous ne rentrons jamais dans le premier "if" if ( obj!=null && Intervalle.class.equals(obj.getClass()) de la première méthode equals puisque si les deux objets sont de classe Intervalle ont rentre dans l'autre méthode equals.
:weird:

Bon, ceci mis à part, voilà la classe Intervalle que j'ai écrite (remarquez que la méthode equals prend en compte l'inclusion ou l'exclusion des bornes :mrgreen:

Code:

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
78
import java.util.Arrays;
import java.util.Objects;
 
public class Intervalle {
	//**************************DECLARATIONS
	private final int BORNE_MIN;
	private final int BORNE_MAX;
	private final boolean IS_MIN_INCLUDED, IS_MAX_INCLUDED;
 
	//**************************CONSTRUCTEURS
	//constructeur dont les bornes sont toutes incluses par défaut
	public Intervalle(int borneMin, int borneMax){
		this(borneMin, true, borneMax, true);
	}
 
	//constructeur permettant d'inclure ou exclure les deux bornes en même temps
	public Intervalle(int borneMin, int borneMax, boolean isAllIncluded) {
		this(borneMin, isAllIncluded, borneMax, isAllIncluded);
	}
 
	//constructeur permettant d'inclure ou exclure chaque borne séparément
	public Intervalle(int borneMin, boolean isMinIncluded, int borneMax, boolean isMaxIncluded){
		if(borneMin > borneMax){throw new IllegalArgumentException(" borneMin > borneMax ");}
 
		this.BORNE_MIN = borneMin;
		this.BORNE_MAX = borneMax;
		this.IS_MIN_INCLUDED = isMinIncluded;
		this.IS_MAX_INCLUDED = isMaxIncluded;
	}
 
	//**************************METHODES
	public int hashCode() {
	    return Objects.hash(BORNE_MIN, BORNE_MAX);
	}
 
	public boolean equals(Object obj) {
	     if ( obj!=null && Intervalle.class.equals(obj.getClass()) ) {
	         return equals((Intervalle)obj);
	     }
	     else { 
	         return false;
	     }
	}
 
	protected final boolean equals(Intervalle intervalle) {
	      return intervalle.BORNE_MIN == this.BORNE_MIN && intervalle.BORNE_MAX == this.BORNE_MAX && intervalle.IS_MIN_INCLUDED == this.IS_MIN_INCLUDED && intervalle.IS_MAX_INCLUDED == this.IS_MAX_INCLUDED;
	}
 
	public int[] rangeTabInt(int[] tableau){
 
		int[] tab;
 
		//on définit la longueur du tableau selon si les bornes sont inclues ou exclues
		if(IS_MIN_INCLUDED == true && IS_MAX_INCLUDED == true){
			tab = new int[(BORNE_MAX - BORNE_MIN)];
			tab = Arrays.copyOfRange(tableau, BORNE_MIN, BORNE_MAX);
		} else if (IS_MIN_INCLUDED == false && IS_MAX_INCLUDED == false){
			tab = new int[(BORNE_MAX - BORNE_MIN - 2)];
			tab = Arrays.copyOfRange(tableau, BORNE_MIN + 1, BORNE_MAX - 1);
		} else if (IS_MIN_INCLUDED == false && IS_MAX_INCLUDED == true){
			tab = new int[(BORNE_MAX - BORNE_MIN - 1)];
			tab = Arrays.copyOfRange(tableau, BORNE_MIN + 1, BORNE_MAX);
		} else if (IS_MIN_INCLUDED == true && IS_MAX_INCLUDED == false){
			tab = new int[(BORNE_MAX - BORNE_MIN - 1)];
			tab = Arrays.copyOfRange(tableau, BORNE_MIN, BORNE_MAX - 1);
		} else {
			throw new IllegalArgumentException(" problème d'inclusion exclusion des bornes ");
		}
 
		return tab;
	}
 
	//**************************GETTERS
	public int getBorneMin() {return BORNE_MIN;}
	public int getBorneMax() {return BORNE_MAX;}
	public boolean isMinIncluded() {return IS_MIN_INCLUDED;}
	public boolean isMaxIncluded() {return IS_MAX_INCLUDED;}
}

puis une classe contenant le main qui permet de tester les méthodes de la classe Intervalle :

Code:

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
 
public class InterMain {
 
	public static void main(String[] args) {
		//définitions des intervalles
		int interMin = 3, interMax = 7;
		Intervalle intervalleTT = new Intervalle(interMin, interMax);
		Intervalle intervalleFF = new Intervalle(interMin, interMax, false);
		Intervalle intervalleTF = new Intervalle(interMin, false, interMax, true);
		Intervalle intervalleFT = new Intervalle(interMin, true, interMax, false);
		System.out.println("borne max : " + intervalleTT.getBorneMax() + " / borne min : " + intervalleTT.getBorneMin() + "\n");
 
		//création d'un tableau de test
		int[] tab = {1,2,3,4,5,6,7,8};
 
 
		System.out.println("*********************************\n");
		int[] tabRangedtt = intervalleTT.rangeTabInt(tab);
 
		System.out.println("\ttoutes bornes incluses : ");
		for(int rank = 0; rank < tabRangedtt.length; rank++){
			System.out.println(tabRangedtt[rank]);
		}
		System.out.println("*********************************\n");
		int[] tabRangedff = intervalleFF.rangeTabInt(tab);
 
		System.out.println("\ttoutes bornes exluses : ");
		for(int rank = 0; rank < tabRangedff.length; rank++){
			System.out.println(tabRangedff[rank]);
		}
		System.out.println("*********************************\n");
		int[] tabRangedtf = intervalleFT.rangeTabInt(tab);
 
		System.out.println("\t borne min inclue, borne max exclue : ");
		for(int rank = 0; rank < tabRangedtf.length; rank++){
			System.out.println(tabRangedtf[rank]);
		}
		System.out.println("*********************************\n");
		int[] tabRangedft = intervalleTF.rangeTabInt(tab);
 
		System.out.println("\t borne min exclue, borne max inclue : ");
		for(int rank = 0; rank < tabRangedft.length; rank++){
			System.out.println(tabRangedft[rank]);
		}
		System.out.println("*********************************\n");
 
		System.out.println("hashCode TT : " + intervalleTT.hashCode());
		System.out.println("hashCode FF : " + intervalleFF.hashCode());
		System.out.println("hashCode TF : " + intervalleTF.hashCode());
		System.out.println("hashCode FT : " + intervalleFT.hashCode() + "\n");
 
		System.out.println("FT equals TF : " + intervalleTF.equals(intervalleFT));
		System.out.println("TT equals TT : " + intervalleTT.equals(intervalleTT));
		System.out.println("TT equals String : " + intervalleTT.equals("blabla") + "\n");
 
		System.out.println("FT equals TF : " + intervalleTF.equals(intervalleFT));
		System.out.println("TT equals TT : " + intervalleTT.equals(intervalleTT));
	}
 
 
}

et le résultat issu de la console :

Code:

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
borne max : 7 / borne min : 3
 
*********************************
 
	toutes bornes incluses : 
4
5
6
7
*********************************
 
	toutes bornes exluses : 
5
6
*********************************
 
	 borne min inclue, borne max exclue : 
4
5
6
*********************************
 
	 borne min exclue, borne max inclue : 
5
6
7
*********************************
 
hashCode TT : 1061
hashCode FF : 1061
hashCode TF : 1061
hashCode FT : 1061
 
FT equals TF : false
TT equals TT : true
TT equals String : false
 
FT equals TF : false
TT equals TT : true

Citation:

Envoyé par francky74

Toutefois, Joel, j'ai l'impression que dans votre dernier code, il y a un dead code. Je m'explique et vous me contredirez si j'ai tort : :whistle:

En fait, nous ne rentrons jamais dans le premier "if" if ( obj!=null && Intervalle.class.equals(obj.getClass()) de la première méthode equals puisque si les deux objets sont de classe Intervalle ont rentre dans l'autre méthode equals.
:weird:

Attention : il est important de connaitre les mécanismes de sélection de méthodes.

1) Déjà, essaye :

Code:

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
package p1;
 
public class Demo {
 
	private final int value;
 
	public Demo(int value) {
		this.value=value;
	}
 
	@Override
	public int hashCode() {
		return value;
	}
 
	@Override
	public boolean equals(Object obj) {
		System.out.println("equals(Object)");
		if ( obj!=null && Demo.class.equals(obj.getClass()) ) {
			return equals((Demo)obj);
		}
		return super.equals(obj);
	}
 
	protected boolean equals(Demo demo) {
		System.out.println("equals(Demo)");
		return value==demo.value;
	}
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package p2;
 
import p1.Demo;
 
public class Test {
 
	public static void main(String[] args) {
 
		Demo demo1 = new Demo(42);
		Demo demo2 = new Demo(42);
 
		System.out.println(demo1.equals(demo2));
 
	}
 
 
}

Que voit-on dans la console ? Pourquoi, à ton avis ?

2) Et maintenant, remplace Demo par

Code:

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
package p1;
 
import java.util.ArrayList;
import java.util.List;
 
public class Demo {
 
	private final int value;
 
	public Demo(int value) {
		this.value=value;
	}
 
	@Override
	public int hashCode() {
		return value;
	}
 
	@Override
	public boolean equals(Object obj) {
		System.out.println("equals(Object)");
		if ( obj!=null && Demo.class.equals(obj.getClass()) ) {
			return equals((Demo)obj);
		}
		return super.equals(obj);
	}
 
	protected boolean equals(Demo demo) {
		System.out.println("equals(Demo)");
		return value==demo.value;
	}
 
	public static void main(String[] args) {
 
		List<Demo> demos = new ArrayList<>();
 
		demos.add(new Demo(42));
 
		System.out.println(demos.contains(new Demo(42)));
 
 
 
	}
 
}

Et exécute là. Qu'est-ce qui s'affiche ? Pourquoi à ton avis ?

Bonsoir,

Merci pour cette énigme instructrice :)

En fait, je n'avais même pas remarqué (:roll:) que la méthode equals(Object obj) appelait la méthode equals(Demo demo) si obj est différent de null et si les noms des classes sont identiques !!!

Ce qui me parait étrange et que je n'arrive pas à m'expliquer, c'est que lorsque je commente la méthode suivante :
Code:

1 2 3 4 5 6 7 8 @Override public boolean equals(Object obj) { System.out.println("equals(Object)"); if ( obj!=null && Demo.class.equals(obj.getClass()) ) { return equals((Demo)obj); } return super.equals(obj); }
je vois que l'on ne passe jamais dans la méthode equals(Demo demo) alors que pourtant on lui donne un attribut de type Demo !?!
System.out.println(demo1.equals(demo2));

Si on m'avais posé la question avant de debugger j'aurais dit que 'bien sûr' elle passera forcément dedans ... mais non !!! 8O

28/08/2015, 01h52
thelvin

Et oui, mais la méthode equals(Demo) est protected, elle ne peut donc être appelée que par les classes filles ou les classes du même package.

Ça ne sert à rien de commenter equals(Object). equals(Demo) est déjà la plus spécifique des deux, donc si elle pouvait être appelée, c'est elle qui le serait.
29/08/2015, 03h53
francky74

c'est quand même dingue ça ! je sais ce que signifie protected mais je ne me suis même pas inquiété de cela !
:scarymov:

Vraiment merci !!!

Et maintenant, tu peux faire un dernier essai : dans la dernière version de Demo, tu rends plublic la méthode equals(Demo).

Code:

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
public class Demo {
 
	private final int value;
 
	public Demo(int value) {
		this.value=value;
	}
 
	@Override
	public int hashCode() {
		return value;
	}
 
	@Override
	public boolean equals(Object obj) {
		System.out.println("equals(Object)");
		if ( obj!=null && Demo.class.equals(obj.getClass()) ) {
			return equals((Demo)obj);
		}
		return super.equals(obj);
	}
 
	public boolean equals(Demo demo) {
		System.out.println("equals(Demo)");
		return value==demo.value;
	}
 
	public static void main(String[] args) {
 
		List<Demo> demos = new ArrayList<>();
 
		demos.add(new Demo(42));
 
		System.out.println(demos.contains(new Demo(42)));
 
 
 
	}
 
}

Qu'affiche le programme ? Pourquoi à ton avis ?

29/08/2015, 11h54
francky74

Bonjour,

j'ai passé en public la méthode equals(Demo).

Il s'avère que lorsque je fait tourner depuis le main contenu dans Test, on ne passe plus dans la méthode equals(Object) mais directement dans equals(Demo).
Logique ! car maintenant, cette dernière méthode est vue depuis la classe Test et possède une signature appropriée à l'appel fait depuis la classe Test -> p1.Demo.equals(Demo demo)
.

Lorsque je fait tourner depuis le main contenu dans la classe Demo, là par contre, on passe dans la méthode equal(Object). Ceci parait illogique à priori (pour moi bien sur ....:weird:) mais je me l'explique par la fait que l'appel suivant demos.contains(new Demo(42)) est un appel de la méthode java.util.List.contains(Object o) qui fournit donc en paramètre un objet. Et donc le new Demo(42) est considéré comme appartenant à la classe Object et non à la classe Demo.

Am I right ?

:D
29/08/2015, 13h06
joel.drigo

Citation:

Envoyé par francky74

Am I right ?

C'est ça, oui; :ccool:

C'est le type (par lequel on manipule l'instance) plus que la classe réelle de l'instance qui est utilisé pour la sélection de méthode : en effet, dans l'ArrayList, l'instance de Demo n'est connue qu'en tant qu'Object, donc, la méthode equals(Object) est sélectionnée lors de l'invocation de equals(), malgré le fait qu'on ait une méthode accessible plus adaptée à la classe de l'instance.

:chin:

Merci Joel ! Ce sont des choses qui ne se voient pas du premier coup d'oeuil et c'était très intéressant pour moi et le sera aussi surement pour d'autres !

Donc voici au final, la classe Intervalle :

Code:

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
78
import java.util.Arrays;
import java.util.Objects;
 
public class Intervalle {
	//**************************DECLARATIONS
	private final int BORNE_MIN;
	private final int BORNE_MAX;
	private final boolean IS_MIN_INCLUDED, IS_MAX_INCLUDED;
 
	//**************************CONSTRUCTEURS
	//constructeur dont les bornes sont toutes incluses par défaut
	public Intervalle(int borneMin, int borneMax){
		this(borneMin, true, borneMax, true);
	}
 
	//constructeur permettant d'inclure ou exclure les deux bornes en même temps
	public Intervalle(int borneMin, int borneMax, boolean isAllIncluded) {
		this(borneMin, isAllIncluded, borneMax, isAllIncluded);
	}
 
	//constructeur permettant d'inclure ou exclure chaque borne séparément
	public Intervalle(int borneMin, boolean isMinIncluded, int borneMax, boolean isMaxIncluded){
		if(borneMin > borneMax){throw new IllegalArgumentException(" borneMin > borneMax ");}
 
		this.BORNE_MIN = borneMin;
		this.BORNE_MAX = borneMax;
		this.IS_MIN_INCLUDED = isMinIncluded;
		this.IS_MAX_INCLUDED = isMaxIncluded;
	}
 
	//**************************METHODES
	public int hashCode() {
	    return Objects.hash(BORNE_MIN, BORNE_MAX);
	}
 
	public boolean equals(Object obj) {
	     if ( obj!=null && Intervalle.class.equals(obj.getClass()) ) {
	         return equals((Intervalle)obj);
	     }
	     else { 
	         return false;
	     }
	}
 
	protected final boolean equals(Intervalle intervalle) {
	      return intervalle.BORNE_MIN == this.BORNE_MIN && intervalle.BORNE_MAX == this.BORNE_MAX && intervalle.IS_MIN_INCLUDED == this.IS_MIN_INCLUDED && intervalle.IS_MAX_INCLUDED == this.IS_MAX_INCLUDED;
	}
 
	public int[] rangeTabInt(int[] tableau){
 
		int[] tab;
 
		//on définit la longueur du tableau selon si les bornes sont inclues ou exclues
		if(IS_MIN_INCLUDED == true && IS_MAX_INCLUDED == true){
			tab = new int[(BORNE_MAX - BORNE_MIN)];
			tab = Arrays.copyOfRange(tableau, BORNE_MIN, BORNE_MAX);
		} else if (IS_MIN_INCLUDED == false && IS_MAX_INCLUDED == false){
			tab = new int[(BORNE_MAX - BORNE_MIN - 2)];
			tab = Arrays.copyOfRange(tableau, BORNE_MIN + 1, BORNE_MAX - 1);
		} else if (IS_MIN_INCLUDED == false && IS_MAX_INCLUDED == true){
			tab = new int[(BORNE_MAX - BORNE_MIN - 1)];
			tab = Arrays.copyOfRange(tableau, BORNE_MIN + 1, BORNE_MAX);
		} else if (IS_MIN_INCLUDED == true && IS_MAX_INCLUDED == false){
			tab = new int[(BORNE_MAX - BORNE_MIN - 1)];
			tab = Arrays.copyOfRange(tableau, BORNE_MIN, BORNE_MAX - 1);
		} else {
			throw new IllegalArgumentException(" problème d'inclusion exclusion des bornes ");
		}
 
		return tab;
	}
 
	//**************************GETTERS
	public int getBorneMin() {return BORNE_MIN;}
	public int getBorneMax() {return BORNE_MAX;}
	public boolean isMinIncluded() {return IS_MIN_INCLUDED;}
	public boolean isMaxIncluded() {return IS_MAX_INCLUDED;}
}

@uqerfromfrance : est-ce que cela répond à ton problème ? tu ne nous a pas trop guidés pour résoudre ton problème, il serait intéressant de savoir si la résolution est bien adaptée à tes besoins.

:zen:

29/08/2015, 14h16
joel.drigo
Juste 2 dernières remarques :
1. hashcode devrait prendre en compte les booléens également. Ce n'est pas que ça ne fonctionne pas, mais l'intérêt est de rendre plus efficace les traitements qui utilisent le hash (en ayant un hash suffisamment discréminant).
  Code:
  
  1 2 3 public int hashCode() { return Objects.hash(BORNE_MIN, BORNE_MAX, IS_MIN_INCLUDED, IS_MAX_INCLUDED); }
2. Il y a des conventions en java : les noms de variables en lowerCamelCase (là, tu as utilisé la convention pour les "constantes", soit les static final)
29/08/2015, 16h18
francky74

Ah !?!
Les static final sont des variables ???? je pensais que c'était des constantes quand il y a le mot clé final !

:koi:
29/08/2015, 16h36
joel.drigo
Non, je n'ai pas dit que les "static final" sont des variables ou pas. Je parlais des attributs de ta classes, qui sont seulement final et pas static.

Si tu préfères le choix entre le lowerCamelCase et le UPPER_CASE ne dépend que de la présence des modifiers combinés "static final" (UPPER_CASE).

Cette terminologie d'usage (constante ou variable, etc...) est une terminologie usuelle, dans laquelle :
- constante pour beaucoup correspond à static final (bien que certains considèrent que constante est plus adapté aux valeurs litéralles) ;
- et variable aux autres.
Si on prend la documentation (ou celle-là) de Java : tout est "variable".

Le mot-clef final rend juste une variable non-mutable (non-modifiable), non réellement constante (elle est constante pendant l'exécution du programme, mais ne l'est pas réellement, puisqu'elle peut prendre une autre valeur pour une autre exécution). Rigoureusement 42 est une constante, la constante de Planck est une constante, etc.
29/08/2015, 22h59
thelvin
Ouais, sauf que la notion de constante existe bel et bien en Java.

C'est une variable :
- final
- de type primitif ou String
- déclarée et initialisée dans la même instruction
- initialisée par une expression constante. Les expressions constantes étant composées :
  - de littéraux (1, 17, "Bonjour", false)
  - d'autres constantes (si var est une constante, alors l'appeler est une expression constante)
  - d'opérateurs sur des expressions constantes (si var est une constante, alors 2 + var + 8 est une expression constante)
Cette notion existe pour définir précisément les variables dont la valeur est connue du compilateur, donc à la compilation et avant l'exécution.
Elle annonce quand le compilateur va faire certaines optimisations comparé à d'autres cas.
Par exemple, si var est une constante et qu'on essaie de calculer 2 + var + 8, ce calcul sera fait à la compilation, et remplacé par son résultat dans le binaire compilé. À l'exécution ce calcul ne sera pas fait, parce que le résultat est déjà connu depuis la compilation.

Tout ça pour dire ce que c'est qu'une constante au sens Java.

Et malheureusement cela ne suit pas exactement les conventions de codage ALL_CAPS.
Normalement on applique le ALL_CAPS sur les variables :
- static final
- initialisées avec une valeur prédictible (qui ne dépend pas de l'heure qu'il est ou d'un effet de bord d'une autre partie du programme.) Cela n'est pas vérifiable par le compilateur, c'est jugé par le programmeur.
- immutables ou immutées. Cela n'est pas vérifiable par le compilateur, c'est jugé par le programmeur.
Exemple : public static final MonthDay NOEL = MonthDay.of(12, 25); .

Ces choses-là sont "grosso-modo des constantes pendant qu'on programme," mais pas forcément des constantes au sens Java.
Notamment, une constante Java n'est pas tenue d'être static.
Et aussi, une variable static final n'est pas forcément une constante Java.

Du coup, c'est une habitude à prendre, mais il y a une certaine confusion avec les constantes.
29/08/2015, 23h12
francky74

Je n'arrive pas à comprendre une chose au sujet de ces variables (prenons par exemple BORNE_MIN) :
Il me semble bien que si je mets BORNE_MIN en static, cette constante devient une constante de classe, et toutes les instances pointerons vers la même constante BORNE_MIN et le fait de modifier cette même constante depuis n'importe quelle autre instance devrait avoir pour effet de modifier la valeur de cette constante pour toute les instances. En d'autres termes, les instances ne se partagerons qu'une seule constante.
Or, ce qui est recherché est plutôt d'avoir la BORNE_MIN contenant une valeur différente pour chaque instance.

Donc, d'après ce que je comprends, ces constantes ne devraient pas être static.

D'ailleurs, lorsque je mets static final, eclipse me demande d'initialiser la constante dans la déclaration et me demande aussi de virer le mot clé final pour pouvoir l'initialiser dans le constructeur.

De plus, je ne comprends pas non plus l'utilité de la méthode hashCode (à laquelle j'ai rajouté les booléens) car je n'arrive pas à entrer dans le code de la méthode Objects.hash() lors de debug. En fait elle retourne un résultat que je ne parviens pas à analyser ni à anticiper.

Merci :)

Citation:

Du coup, c'est une habitude à prendre, mais il y a une certaine confusion avec les constantes.

:sm:

Bon, je pense me rapprocher de la vérité et j'espère que cela deviendra une habitude !

En fait, comme nous pouvons créer plusieurs instances de la classe Intervalle, il faut bien que les bornes de chaque instance puissent être personnalisées à la création de l'intervalle.
Dans le sens de cette réflexion, je dirais donc que les bornes ne sont pas des constantes de classes, mais plutôt des constantes d'instances -> donc pas de static final mais du final simplement -> donc du lowerCase !

Je vous remercie pour vos interventions qui transforment ce sujet en cours précis et d'un grand intérêt !

Donc, j'ai de nouveau transformé cette classe Intervalle comme ceci :

Code:

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
78
import java.util.Arrays;
import java.util.Objects;
 
public class Intervalle {
	//**************************DECLARATIONS
	private final int borneMin;
	private final int borneMax;
	private final boolean isMinIncluded, isMaxIncluded;
 
	//**************************CONSTRUCTEURS
	//constructeur dont les bornes sont toutes incluses par défaut
	public Intervalle(int borneMin, int borneMax){
		this(borneMin, true, borneMax, true);
	}
 
	//constructeur permettant d'inclure ou exclure les deux bornes en même temps
	public Intervalle(int borneMin, int borneMax, boolean isAllIncluded) {
		this(borneMin, isAllIncluded, borneMax, isAllIncluded);
	}
 
	//constructeur permettant d'inclure ou exclure chaque borne séparément
	public Intervalle(int borneMin, boolean isMinIncluded, int borneMax, boolean isMaxIncluded){
		if(borneMin > borneMax){throw new IllegalArgumentException(" borneMin > borneMax ");}
 
		this.borneMin = borneMin;
		this.borneMax = borneMax;
		this.isMinIncluded = isMinIncluded;
		this.isMaxIncluded = isMaxIncluded;
	}
 
	//**************************METHODES
	public int hashCode() {
	    return Objects.hash(borneMin, borneMax, isMinIncluded, isMaxIncluded);
	}
 
	public boolean equals(Object obj) {
	     if ( obj!=null && Intervalle.class.equals(obj.getClass()) ) {
	         return equals((Intervalle)obj);
	     }
	     else { 
	         return false;
	     }
	}
 
	protected final boolean equals(Intervalle intervalle) {
	      return intervalle.borneMin == this.borneMin && intervalle.borneMax == this.borneMax && intervalle.isMinIncluded == this.isMinIncluded && intervalle.isMaxIncluded == this.isMaxIncluded;
	}
 
	public int[] rangeTabInt(int[] tableau){
 
		int[] tab;
 
		//on définit la longueur du tableau selon si les bornes sont inclues ou exclues
		if(isMinIncluded == true && isMaxIncluded == true){
			tab = new int[(borneMax - borneMin)];
			tab = Arrays.copyOfRange(tableau, borneMin, borneMax);
		} else if (isMinIncluded == false && isMaxIncluded == false){
			tab = new int[(borneMax - borneMin - 2)];
			tab = Arrays.copyOfRange(tableau, borneMin + 1, borneMax - 1);
		} else if (isMinIncluded == false && isMaxIncluded == true){
			tab = new int[(borneMax - borneMin - 1)];
			tab = Arrays.copyOfRange(tableau, borneMin + 1, borneMax);
		} else if (isMinIncluded == true && isMaxIncluded == false){
			tab = new int[(borneMax - borneMin - 1)];
			tab = Arrays.copyOfRange(tableau, borneMin, borneMax - 1);
		} else {
			throw new IllegalArgumentException(" problème d'inclusion exclusion des bornes ");
		}
 
		return tab;
	}
 
	//**************************GETTERS
	public int getBorneMin() {return borneMin;}
	public int getBorneMax() {return borneMax;}
	public boolean isMinIncluded() {return isMinIncluded;}
	public boolean isMaxIncluded() {return isMaxIncluded;}
}

:java::java:

29/08/2015, 23h33
thelvin

Citation:

Envoyé par francky74

[...]

Donc, d'après ce que je comprends, ces constantes ne devraient pas être static.

D'ailleurs, lorsque je mets static final, eclipse me demande d'initialiser la constante dans la déclaration et me demande aussi de virer le mot clé final pour pouvoir l'initialiser dans le constructeur.

Une classe ne peut pas modifier la valeur d'une constante, c'est un peu le principe.

Mais sinon, oui, en effet. Ces variables ne doivent absolument pas être static.
Et donc elles ne doivent pas être en ALL_CAPS et plutôt s'appeler borneMin.

Citation:

Envoyé par francky74

De plus, je ne comprends pas non plus l'utilité de la méthode hashCode (à laquelle j'ai rajouté les booléens) car je n'arrive pas à entrer dans le code de la méthode Objects.hash() lors de debug. En fait elle retourne un résultat que je ne parviens pas à analyser ni à anticiper.

Ben, comme le dit son nom, elle renvoie un code de hashing.

La FAQ explique pourquoi et comment redéfinir la méthode hashCode()

En résumé, ça travaille de pair avec la méthode equals() si un jour tu utilises tes intervalles dans un HashMap, HashSet ou similaire. Un appel à hashCode() fournit un nombre qui sera forcément le même pour deux intervalles égaux. Ce nombre permet de situer l'objet dans une table de hachage. Une fois cela fait, equals() permet de vérifier si ce qu'on trouve à cet endroit est bien un intervalle égal.
30/08/2015, 02h17
joel.drigo

Citation:

Envoyé par thelvin

Ouais, sauf que la notion de constante existe bel et bien en Java.

Je ne dis pas le contraire, mais que cette désignation "constante", qu'on utilise dans le langage courant, porte à confusion. En particulier, si on dit que les constantes doivent par convention être en UPPER_CASE (ou ALL_CAPS comme tu dis), alors qu'une "final" non "static" ne doit pas l'être. La documentation parle d'ailleurs de "constant variable".