Discussion :

[uqerfromfrance]

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

[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.

[uqerfromfrance]

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

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

[francky74]

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 .
Merci aux pros de corriger si j'écris des bêtises

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
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.

1. 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().
2. un constructeur prenant en paramètres une longueur de tableau et les bornes. Ce constructeur créera le tableau tout seul.
3. 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à

[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 :

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

   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 :

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

   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).

[francky74]

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 :

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
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 :

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
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 :

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
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 :

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