Faire un tri parmi les attributs d'un objet

Version imprimable

28/04/2015, 15h53
Lord Bouillon

Faire un tri parmi les attributs d'un objet
Bonjour à tous, je fais actuellement un programme qui permet de créer des machines possédant certains attributs (Nom, ID, ID de l'atelier, marque etc...)

Et je suis sensé faire une méthode qui me permettrai de pouvoir savoir combien de machine ont été créées dans chaque atelier.

Et je vous avoues que je suis un peu perdu car j'ai tenté 100 trucs différents et je m'en sors pas...

J'ai essayé d'abord de faire un double test du style:
Code:

1 2 3 4 5 6 7 8 if( this.getIdAtelier() == idAtelier && this.getNomMachine() != nomMachine) { temp++; } else { temp=1; }
Puis me rendant compte que ça ne pouvais marcher car j'écrasais tout le temps la valeur temp ce qui donc tronquais mon résultat j'ai essayé via un tableau comme ceci:
Code:

1 2 3 4 5 6 int [] saveId = new int[50]; temp = nbMachine-1; for (i=temp; i < nbMachine; i++) { saveId[i] = getIdAtelier(); }
Sachant que la variable nbMachine est le nombre de machines totales créées. J'ai donc bien sauvegardé mes id comme je le veux dans mon tableau (pb, je ne peux pas avoir plus de 50 machines) mais je ne sais pas faire le tris sur mon tableau. Ce que je voudrai est de, suivant le nombre de redondance d'un certain ID, incrémenter x fois une variable afin de la display par la suite ( ex: si j'ai 3 ID =5 dans mon tableau, alors j'ai une variable x=3 ).

Merci d'avance =D
28/04/2015, 15h55
wax78

Juste une petite remarque sur

Code:

this.getNomMachine() != nomMachine

Si nomMachine est un String, il faut savoir qu'on en compare des string qu'avec la méthode equals() et non avec == ou !=
28/04/2015, 15h57
Lord Bouillon

Ah ouais t'as complètement raison j'avais même pas fais gaffe ! Ça ne me résous pas mon problème mais au moins j'y penserai la prochaine fois ! Merci !

Salut,

Je ne suis pas sûr d'avoir tout compris à ce que tu cherches à faire. Tu cherches à compter le nombre d’occurrences d'éléments pour chaque valeur d'une condition donnée sur tes attributs.

Autrement dit, ce qu'on pourrait avoir avec un
Code:

1 2 3 4 5 6 List<Machine> list = new ArrayList<Machine>(); Map<Atelier,Long> counters = list.stream().collect( Collectors.groupingBy(Machine::getAtelier, Collectors.counting()) );
Avec une classe :
Code:

1 2 3 4 5 6 public class Machine { public Atelier getAtelier() { } }
(bien sûr, si au lieu de Atelier getAtelier() tu as String getAtelierId(), c'est le même principe, pour obtenir une Map<String, Long>)

Ceci en Java 8. En Java 7, il faut écrire soit même le code qui effectue le remplissage de la map, sous le principe :
Code:

1 2 3 4 5 6 7 8 9 pour l'ensemble des machines je regarde si la map contient déjà un compteur pour l'atelier de cette machine si oui : j'incrémente ce compteur si non, je mets 1 dans la map associé à cet atelier fin test fin pour

Ceci n'est peut être pas la meilleur des manières mais cela fonctionne :

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
package dummy;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Random;
import java.util.Set;
 
public class main {
 
	public static void main(String[] args) {
 
		Random rnd = new Random();
 
		List<Machine> list_machines = new ArrayList<>();
		int id = 0;
 
		for (int i = 0; i < 16; i++) {
			Machine m = new Machine("Machine", id++, rnd.nextInt(4));
			list_machines.add(m);
			System.err.println("Machine crée : "+m);
		}
 
 
		// Méthode 1
 
		// Map atelier, compteur de machines
		Map<Integer, Integer> map = new HashMap<>();
		for (Iterator<Machine> iterator = list_machines.iterator(); iterator.hasNext();) {
			Machine machine = (Machine) iterator.next();
			int cle = machine.ID_atelier;
			Integer compteur = map.get(cle);
			if (compteur==null)
				map.put(cle, 1);
			else
				map.put(cle, compteur+1);
		}
 
		// Et la tu as un map avec pour chacune des clé (id atelier), le nombre de machine
		Set<Entry<Integer, Integer>> set = map.entrySet();
		for (Iterator iterator = set.iterator(); iterator.hasNext();) {
			Entry<Integer, Integer> entry = (Entry<Integer, Integer>) iterator.next();
			System.err.println("Dans atelier "+entry.getKey()+" il y'a "+entry.getValue()+ " machines");
		}
 
 
	}
 
}

avec :

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
package dummy;
 
public class Machine {
	String nom;
	int ID;
	int ID_atelier;
 
	public Machine(String nom, int iD, int iD_atelier) {
		super();
		this.nom = nom;
		ID = iD;
		ID_atelier = iD_atelier;
	}
 
        public int getID_atelier() {
		return ID_atelier;
	}
 
	@Override
	public String toString() {
		return "Machine [nom=" + nom + ", ID=" + ID + ", ID_atelier="
				+ ID_atelier + "]";
	}
 
}

Sinon la méthode 2 avec java 8 qui prends beaucoup moins de lignes :

Code:

1
2
3
4
5
6
7
// Methode 2 : 
Map<Integer, Long> map2 = list_machines.stream().collect(Collectors.groupingBy(Machine::getID_atelier, HashMap::new, Collectors.counting()));
 
map2.entrySet().forEach(entry -> {
	System.err.println("Dans atelier "+entry.getKey()+" il y'a "+entry.getValue()+ " machines");
	}
);

Edit : Oups j'avais pas vu ta réponse Joel...

Désolé de ne pas avoir été clair, ce que je veux faire est plutot simple dans l'idée, j'ai une classe machine avec les attributs suivant:
Code:

1 2 3 4 5 6 7 8 9 10 11 public Machine(String nomM, int imM, int iaM, String marqueM, int irM){ nbMachine++; idMachine = imM; nomMachine = nomM; marqueMachine = marqueM; idAtelier = iaM; idRespMaintenance =irM; }
J'ai un attribut nbMachine que j'incrémente à chaque création afin d'avoir le nombre de machine totale. Le reste est entré par l'utilisateur. Et la question est la suivante :

*Ajouter dans la classe Machine des variables de classe qui permettent de calculer le nombre des machines créées dans chaque atelier, ainsi que les méthodes permettant de les gérer.

Je vais lire de ce pas vos réponses car c'était un peu trop fournit pour que je lise ça en 2min (d’où ma réponse en avance de phase).

Donc, en gros, tu dois stocker la map dont on t'a parlé dans la classe machine et au lieu de faire une boucle pour compter, tu fais le code de l'itération dans le constructeur.

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
private static final Map<Integer, Integer> mapNbMachinesParAtelier = new HashMap<>();
 
public Machine(String nomM, int imM, int iaM, String marqueM, int irM){
 
		nbMachine++;
		idMachine = imM;
		nomMachine = nomM;
		marqueMachine = marqueM;
		idAtelier = iaM;	
		idRespMaintenance =irM;
 
 
                Integer compteur = mapNbMachinesParAtelier.get(idAtelier );
                if ( compteur!=null ) {
                     mapNbMachinesParAtelier.put(idAtelier , compteur+1);
                }
                else {
                       mapNbMachinesParAtelier.put(idAtelier , 1);
                }
 
	}
 
public static int getNbMachinesPourAtelier(int idAtelier) {
   return mapNbMachinesParAtelier.getOrDefault(idAtelier, 0);
}

La méthode getNbMachinesPourAtelier () retourne le nombre de machine créées pour l'atelier d'id passé en argument.

PS : il n'est pas multithread ton programme ?

28/04/2015, 17h26
Lord Bouillon

Super !!! Merci beaucoup ! Non le programme est séquentiel car l’énoncé est construit comme cela, (faire cette méthode, puis celle la, ajoutez ça après etc...).

Je te remercie pour ton aide, je vais essayer ça de ce pas ! :D
28/04/2015, 17h40
Lord Bouillon

Par contre j'ai un souci, il me dit "Map cannot be resolved as a type" ... C'est une souci de bibliothèque non ? Pourtant j'ai rajouté la bibliothèque Hashtable!
28/04/2015, 17h43
joel.drigo
Il faut évidemment ajouter les imports :
Code:

1 2 import java.util.Map; import java.util.HashMap;
28/04/2015, 17h51
Lord Bouillon

Effectivement ça marche mieux comme ça :aie: !

Par contre je ne comprends pas méthode getOrDefault, quel est sont but ? Et j'ai une érreur dessus aussi qui me dit qu'elle est undefined pour le type map... J’imagine donc que tu l'import d'une bibli aussi non ?

Citation:

Envoyé par Lord Bouillon

Effectivement ça marche mieux comme ça :aie: !

Par contre je ne comprends pas méthode getOrDefault, quel est sont but ? Et j'ai une érreur dessus aussi qui me dit qu'elle est undefined pour le type map... J’imagine donc que tu l'import d'une bibli aussi non ?

C'est une méthode introduite sur l'interface Map dans Java 8. Dans un Java plus ancien (voire obsolète), cela correspond à faire :
Code:

1 2 3 4 5 6 7 8 9 public static int getNbMachinesPourAtelier(int idAtelier) { Integer compteur = mapNbMachinesParAtelier.get(idAtelier); if ( compteur==null ) { return 0; } else { return compteur; } }
Ou encore :
Code:

1 2 3 4 5 6 7 8 public static int getNbMachinesPourAtelier(int idAtelier) { if ( mapNbMachinesParAtelier.containsKey(idAtelier ) { return mapNbMachinesParAtelier.get(idAtelier); } else { return 0; } }

28/04/2015, 18h14
Lord Bouillon

Ok j'ai modifié un peu à ma sauce et ça marche parfaitement ! Je te remercie je commençais à devenir fou sur ce problème ! N'ayant pas encore vu les Array List et Map j'aurai pu chercher longtemps ^^
28/04/2015, 18h24
joel.drigo

Citation:

Envoyé par Lord Bouillon

Ok j'ai modifié un peu à ma sauce et ça marche parfaitement ! Je te remercie je commençais à devenir fou sur ce problème ! N'ayant pas encore vu les Array List et Map j'aurai pu chercher longtemps ^^

Hum, ça m'étonne qu'on te donne un exercice à faire où il faut appliquer quelque chose que tu n'as pas encore vu en cours :weird: C'est peut-être par un autre moyen (genre tableau) qu'on veut que tu le fasses.
29/04/2015, 17h33
Lord Bouillon

Ouais bah justement j'ai cherché pendant longtemps comment résoudre ce problème avec les outils que je connais et franchement, j'ai éssayé avec un tableau mais j'ai pas réussi et impossible de passer par un simple test if ou while ...

On peut le faire avec un tableau, vu que les clefs sont des int et sont incrémentaux. Donc, en gros, on simule la map avec un tableau. On peut encapsuler tout ça dans une classe :

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
public CompteurParId {
 
      private int[] compteurs;
 
      public CompteurParId () {
      }
 
      // détermine la taille du tableau (ou 0, si pas encore de tableau)
      public int size() {
           if ( compteurs==null )  return 0;
           else return compteurs.length;
      }
 
      public void incrementeCompteur(int id) {
              if( id<0 ) throw new IllegalArgumentException(); // le système ne peut fonctionner pour des identifiants inférieurs à 0
              if ( id>=size() ) {
                   // l'id n'est pas déjà stocké dans le tableau : on agrandit le tableau
                   agrandirTableau(id+1);
              }
              compteurs[id] ++; // on incrémente le compteur
      }
 
      public int getCompteur(int id) {
            if ( id<size() ) {   
                 // l'id est pas déjà stocké dans le tableau
                 return compteurs[ id ];
          }
          else {
                 return 0; // il y'en a forcément que 0
          }
      }
 
      private void agrandirTableau(int nouvelleTaille) {
          if ( compteurs==null ) {
               // la première fois, on ne l'agrandit pas, on le créé tout simplement
               compteurs = new int[nouvellTaille];
          }
          else {
                // on agrandit le tableau
                compteurs = Arrays.copyOf( compteurs, nouvelleTaille );
          }
      }
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
private static final CompteurParId  mapNbMachinesParAtelier = new CompteurParId ();
 
public Machine(String nomM, int imM, int iaM, String marqueM, int irM){
 
		nbMachine++;
		idMachine = imM;
		nomMachine = nomM;
		marqueMachine = marqueM;
		idAtelier = iaM;	
		idRespMaintenance =irM;
 
 
                mapNbMachinesParAtelier.incrementeCompteur(idAtelier); 
 
	}
 
public static int getNbMachinesPourAtelier(int idAtelier) {
   return mapNbMachinesParAtelier.getCompteur(idAtelier);
}