Problème d'algorithme : comment comparer les éléments de deux liste différentes ?

Version imprimable

Bonjour,

je suis en train de développer une application de gestion des horaires du personnel.
Chaque fin de mois, on calcule, entre autre, le nombre d'heure travaillées, le nombre de congé pris, etc.... Ces éléments se trouve dans une table moisdisp.
A partir de la liste du personnel, il faudrait comparer les personnes qui ont leurs moisdisp qui a été généré, et indiqué les personnes qui n'ont pas eu leur moisdisp de générer.
Je ne sais pas si ce que j'ai dit est compréhensible. :oops::oops:

Ce bout de code me permet de connaitre le nombre de personne pour un service donné :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
listePersonnePasEnCdd = this.personneService.getPersonneDTOPasCDDByUniteId(this.getUniteSelected());
		if(listePersonnePasEnCdd.size() > 0){
			for(PersonneDTO personnePasEnCdd : listePersonnePasEnCdd){
				PersonneDTO persDto = new PersonneDTO();
				persDto.setIdPersonne(personnePasEnCdd.getIdPersonne());
				persDto.setNom(personnePasEnCdd.getNom());
				persDto.setPrenom(personnePasEnCdd.getPrenom());
 
			}
 
		}

Ce bout de code me permet de récuper les moisdisp qui ont été généré

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
 
listPersonneCompteurSemaine = this.compteurService.getListCompteurbyIdUniteAndMountAndYearPourDimanche(this.getUniteSelected(), this.getMoisSelected(), this.getYearSelected());
 
		if (listPersonneCompteurSemaine.size() > 0){
			for(PersonneCompteurSemaineDisp persSemaineCompt : listPersonneCompteurSemaine){
				PersonneCompteurSemaineDisp persCompteurDim = new PersonneCompteurSemaineDisp(); 
				PersonneCompteurSemaineDisp persCompteurTotal= new PersonneCompteurSemaineDisp(); 
 
				persCompteurDim.setNomPersonne(persSemaineCompt.getNomPersonne());
				persCompteurDim.setPrenomPersonne(persSemaineCompt.getPrenomPersonne());
 
				persCompteurDim.setDureeHeureDimanche(persSemaineCompt.getDureeHeureHeureDimancheTotalPersonne());
				persCompteurDim.setDureeHeureJourFerie(persSemaineCompt.getDureeHeureHeureFerieTotalPersonne());
				persCompteurDim.setDureeTravailJourMaladie(persSemaineCompt.getDureeTravailJourMaladie());
				persCompteurDim.setNbCongeAnnuel(persSemaineCompt.getNbCongeAnnuel());
				persCompteurDim.setNbCongeTri(persSemaineCompt.getNbCongeTri());
				persCompteurDim.setNbCongeMaladie(persSemaineCompt.getNbCongeMaladie());
				persCompteurDim.setNbCongeAnciennete(persSemaineCompt.getNbCongeAnciennete());
				persCompteurDim.setNbCongeFormation(persSemaineCompt.getNbCongeFormation());  
				persCompteurDim.setNbCongeSansSolde(persSemaineCompt.getNbCongeSansSolde());
				persCompteurDim.setDureeTravailJourSansSoldes(persSemaineCompt.getDureeTravailJourSansSoldes());
				persCompteurDim.setHeureSuppPaye(persSemaineCompt.getHeureSuppPaye());
				persCompteurDim.setDateGenere(persSemaineCompt.getDateGenere());
				persCompteurDim.setIdPersonne(persSemaineCompt.getIdPersonne());
 
				listPersDimRecup.add(persCompteurDim);
 
			}
		}

Dans c'est deux liste, il y a l'id de la personne.

Comment je peux faire pour les comparer et récupérer les personne manquantes ?

code globale :

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
 
		listePersonnePasEnCdd = this.personneService.getPersonneDTOPasCDDByUniteId(this.getUniteSelected());
		if(listePersonnePasEnCdd.size() > 0){
			for(PersonneDTO personnePasEnCdd : listePersonnePasEnCdd){
				PersonneDTO persDto = new PersonneDTO();
				persDto.setIdPersonne(personnePasEnCdd.getIdPersonne());
				persDto.setNom(personnePasEnCdd.getNom());
				persDto.setPrenom(personnePasEnCdd.getPrenom());
 
				System.out.println("personnePasEnCdd : "+personnePasEnCdd.getNom());
			}
 
		}
 
		listPersonneCompteurSemaine = this.compteurService.getListCompteurbyIdUniteAndMountAndYearPourDimanche(this.getUniteSelected(), this.getMoisSelected(), this.getYearSelected());
 
		if (listPersonneCompteurSemaine.size() > 0){
			for(PersonneCompteurSemaineDisp persSemaineCompt : listPersonneCompteurSemaine){
				PersonneCompteurSemaineDisp persCompteurDim = new PersonneCompteurSemaineDisp(); 
				PersonneCompteurSemaineDisp persCompteurTotal= new PersonneCompteurSemaineDisp(); 
 
				persCompteurDim.setNomPersonne(persSemaineCompt.getNomPersonne());
				persCompteurDim.setPrenomPersonne(persSemaineCompt.getPrenomPersonne());
 
				persCompteurDim.setDureeHeureDimanche(persSemaineCompt.getDureeHeureHeureDimancheTotalPersonne());
				persCompteurDim.setDureeHeureJourFerie(persSemaineCompt.getDureeHeureHeureFerieTotalPersonne());
				persCompteurDim.setDureeTravailJourMaladie(persSemaineCompt.getDureeTravailJourMaladie());
				persCompteurDim.setNbCongeAnnuel(persSemaineCompt.getNbCongeAnnuel());
				persCompteurDim.setNbCongeTri(persSemaineCompt.getNbCongeTri());
				persCompteurDim.setNbCongeMaladie(persSemaineCompt.getNbCongeMaladie());
				persCompteurDim.setNbCongeAnciennete(persSemaineCompt.getNbCongeAnciennete());
				persCompteurDim.setNbCongeFormation(persSemaineCompt.getNbCongeFormation());  
				persCompteurDim.setNbCongeSansSolde(persSemaineCompt.getNbCongeSansSolde());
				persCompteurDim.setDureeTravailJourSansSoldes(persSemaineCompt.getDureeTravailJourSansSoldes());
				persCompteurDim.setHeureSuppPaye(persSemaineCompt.getHeureSuppPaye());
				persCompteurDim.setDateGenere(persSemaineCompt.getDateGenere());
				persCompteurDim.setIdPersonne(persSemaineCompt.getIdPersonne());
 
				listPersDimRecup.add(persCompteurDim);
 
			}
		}

Je vous remercie d'avance de votre aide

Salut,

Citation:

Envoyé par leara500

Bonjour,

A partir de la liste du personnel, il faudrait comparer les personnes qui ont leurs moisdisp qui a été généré, et indiqué les personnes qui n'ont pas eu leur moisdisp de générer.
Je ne sais pas si ce que j'ai dit est compréhensible. :oops::oops:

Jusque là j'ai l'impression que ça va, mais c'est plus confus quand je lis le code après. Je ne comprends pas pourquoi déjà tu copies les instances que tu récupères dans les listes.
Code:

1 2 3 4 5 6 for(PersonneDTO personnePasEnCdd : listePersonnePasEnCdd){ PersonneDTO persDto = new PersonneDTO(); persDto.setIdPersonne(personnePasEnCdd.getIdPersonne()); persDto.setNom(personnePasEnCdd.getNom()); persDto.setPrenom(personnePasEnCdd.getPrenom()); }
A quoi sert persDto ? Pourquoi ne pas utiliser directement personnePasEnCdd.

Quoiqu'il en soit, si j'ai bien compris :
listePersonnePasEnCdd = this.personneService.getPersonneDTOPasCDDByUniteId(this.getUniteSelected());te permet d'obtenir une liste de personnes, modélisées par une classe PersonneDTO, donc une List<PersonneDTO>.

listPersonneCompteurSemaine = this.compteurService.getListCompteurbyIdUniteAndMountAndYearPourDimanche(this.getUniteSelected(), this.getMoisSelected(), this.getYearSelected()); te permet d'obtenir une liste de PersonneCompteurSemaineDisp, donc une List<PersonneCompteurSemaineDisp>.
tu dois chercher dans listePersonnePasEnCdd les personnes dont l'id correspond à l'id des PersonneCompteurSemaineDisp qu'on a dans listPersonneCompteurSemaine, c'est bien ça ?
Donc simplement :
Code:

1 2 3 4 5 6 7 8 9 for(PersonneCompteurSemaineDisp persSemaineCompt : listPersonneCompteurSemaine){ String id = persSemaineCompt.getIdPersonne(); // je suppose que c'est cette méthode pour récupérer l'id // maintenant on cherche dans listePersonnePasEnCdd la personne qui a cet id : listePersonnePasEnCdd.stream().filter(p-> p.getIdPersonne().equals(id))./** ici la suite dépendant de ce qu'on veut faire avec la personne trouvée **/ }
.
Dans l'extrait au-dessus, je n'ai pas mis la fin du code, parce que si j'ai bien compris, tu ne cherches pas les personnes dans la liste, mais les autres, celles qui n'y sont pas.

Si c'est bien le cas, on peut faire ça :
Code:

1 2 3 4 5 6 7 Set<PersonneDTO> listePresent = listPersonneCompteurSemaine.stream() .flatMap( personne-> listePersonnePasEnCdd.stream() .filter(p-> p.getIdPersonne().equals(personne.getIdPersonne()))) // ceci convertit le PersonneCompteurSemaineDisp en PersonneDTO .collect(Collectors.toSet()); // on récupère la liste des personnes distinctes de listePersonnePasEnCdd qui sont dans listPersonneCompteurSemaine (exactement qui ont le même idPersonne) listePersonnePasEnCdd.removeAll(listePresent); // on supprime tous ceux qu'on a récupérer, et donc ceux qui restent dans listePersonnePasEnCdd sont ceux qui ne sont pas dans listPersonneCompteurSemaine

Merci infiniment de votre réponse.:)

J'ai utilisé le bout de code que vous avez mis afin de récupérer les personnes qui n'ont pas vu leurs moisdisp généré, mais mon application ne comprend pas

Code:

1
2
3
4
5
 
set<PersonneDTO> listePresent = 
      listPersonneCompteurSemaine.stream()
                                 .flatMap( personne-> listePersonnePasEnCdd.stream()
                                                                           .filter(p-> p.getIdPersonne().equals(personne.getIdPersonne())))

Il me mets pleins d’alerte bizarre pour le "stream", "fatMap", etc... :oops::oops::oops:

J'ai donc fait :

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
 
List<PersonneCompteurSemaineDisp> listPersonneMoisDispPasGenere = null;
 
		listePersonnePasEnCdd = this.personneService.getPersonneDTOPasCDDByUniteId(this.getUniteSelected());
		if(listePersonnePasEnCdd.size() > 0){
			for(PersonneDTO personnePasEnCdd : listePersonnePasEnCdd){
				PersonneDTO persDto = new PersonneDTO();
				persDto.setIdPersonne(personnePasEnCdd.getIdPersonne());
				persDto.setNom(personnePasEnCdd.getNom());
				persDto.setPrenom(personnePasEnCdd.getPrenom());
 
				if (listPersonneCompteurSemaine.size() > 0){
					for(PersonneCompteurSemaineDisp persSemaineCompt : listPersonneCompteurSemaine){
 
						System.out.println("persSemaineCompt.getIdPersonne() : "+persSemaineCompt.getIdPersonne());
						System.out.println("personnePasEnCdd.getIdPersonne() : "+personnePasEnCdd.getIdPersonne());
 
						if(persSemaineCompt.getIdPersonne()!=personnePasEnCdd.getIdPersonne()){
 
							System.out.println("persSemaineCompt.getIdPersonne()!=personnePasEnCdd.getIdPersonne(");
						}
 
 
					}
 
 
				}
 
 
 
 
			}
 
		}
 
		listPersonneMoisDispPasGenere = listePersonnePasEnCdd.removeAll(listPersonneCompteurSemaine);

Je récupère les bonnes id de personnes mais je suis bloquée pour récupéré les id des personnes qui n'ont pas leur moisdisp de générer. Auriez vous une piste s'il vous plait.

Code:

1
2
 
listPersonneMoisDispPasGenere = listePersonnePasEnCdd.removeAll(listPersonneCompteurSemaine);

Ceci ne marche par car il vaut un booléan et je ne comprend pas pourquoi :oops:
Je vous remercie d'avance.

10/10/2019, 14h02
joel.drigo
Citation:

Envoyé par leara500

Il me mets pleins d’alerte bizarre pour le "stream", "fatMap", etc... :oops::oops::oops:

Bah je pense que tu utilises une très vieille version de Java. Les Stream sont apparus en Java 8 et là on est en version 13 quand même...
Citation:
Envoyé par leara500

J'ai donc fait :

Code:

1 2 if(persSemaineCompt.getIdPersonne()!=personnePasEnCdd.getIdPersonne()){
On ne compare jamais des String, ou plus généralement des objets, avec == mais avec equals (cf voir mes exemples, ou la méthode Objects.equals(obj1,obj2)).
== est l'opérateur d'identité pas d'égalité et il teste l'égalité des références des objets et il n'y a aucune garantie que deux String de même valeur soient identiques, en particulier quand on ne les a pas construites soi-même.

Evidemment, le corollaire est vrai avec l'opérateur de différence != et que l'on doit remplacer par une négation d'un test d'égalité (genre !(persSemaineCompt.getIdPersonne().equals(personnePasEnCdd.getIdPersonne())) ou !Objects.equals(persSemaineCompt.getIdPersonne(), personnePasEnCdd.getIdPersonne())
10/10/2019, 14h33
leara500

Malheureusement, je n'ai pas la main sur les librairies :oops:

Il n'y a pas d'autre moyen ?

J'aimerai pouvoir comparer les éléments de deux listes différentes et de mettre dans une troisième liste, les éléments manquant:oops::oops::oops:

Bah l'autre moyen c'est de faire la boucle imbriquée par un for, et de tester l'égalité des id, par equals(). A chaque itération tu stockes et tu peux faire le removeAll à la fin.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
Set<PersonneDTO> listePresents = new HashSet<>();
for(PersonneCompteurSemaineDisp persSemaineCompt : listPersonneCompteurSemaine){
 
    String id = persSemaineCompt.getIdPersonne(); // je suppose que c'est cette méthode pour récupérer l'id
 
    // maintenant on cherche dans listePersonnePasEnCdd  la personne qui a cet id :
    for(PersonneDTO personneDTO : listePersonnePasEnCdd) {
         if (  personneDTO .getIdPersonne().equals(persSemaineCompt.getIdPersonne()) ) {
               listePresents.add(personneDTO);
               break;
         }
    }
 
}
 
listePersonnePasEnCdd.removeAll(listePresents);
 
// ici listePersonnePasEnCdd ne contient plus que les personnes dont l'id ne correspond à aucun id de PersonneCompteurSemaineDisp de listPersonneCompteurSemaine

10/10/2019, 15h08
leara500

Merci infiniment de votre aide. Vous m'enlevez une grosse épine du pieds :)