Discussion :

[toutemes1]

Bonjour tout le monde, j'ai besoin de votre aide.Voici mon besoin

Identification des voyages pour nettoyage dans une liste
Objectif : supprimer les doublons de FATS en prenant le voyage le plus ancien pour chaque FAT
Si un FAT a plusieurs voyages, on ne conservera que le voyage le plus ancien : on prendra le voyage qui est survenu sur la date de parcours la plus lointaine.
Il est possible qu’un FAT ait plusieurs voyages sur cette date de parcours la plus ancienne. A ce moment-là, on prendra le kilométrage voyages le plus faible. Si les kilométrages sont égaux, on n’en conservera qu’un seul incident.

FAT_1	01/01/2016	1000	A conserver
FAT_1	02/02/2016	1500	Delete
FAT_1	03/03/2016	2000	Delete
FAT_2	01/01/2016	1000	A conserver
FAT_2	01/01/2016	1010	Delete
FAT_2	03/03/2016	2000	Delete
FAT_3	01/01/2016	1000	A conserver
FAT_3	01/01/2016	1000	Delete
FAT_3	03/03/2016	2000	Delete

J'ai essayé avec distinctBy comme ceci :

Code :

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

1
2
3
4
public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
    Set<Object> seen = ConcurrentHashMap.newKeySet();
    return t -> seen.add(keyExtractor.apply(t));
}

en appelant cette fonction :

Code :

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

1
2
3
4
5
 private List<VoyageBean> getVoyagesFails(@NonNull List<VoyageBean> voyagesInitList) {        
 
return voyagesInitList.stream()
                .filter(Utils.distinctByKey(VoyageBean::getFat))
                .collect(Collectors.toList());

ça ne marche pas.

Merci par avance pour votre aide,

[joel.drigo]

Salut,

Je ne sais pas ce que tu essayes de faire avec distinctByKey, mais ça ne peut pas fonctionner, puisque le traitement est censé tenir compte de la date et de la distance, qui n'apparaissent nulle part dans cette fonction.

On pourrait écrire un Collector qui fait le job, mais... pour faire ce que tu veux, il suffit de faire une réduction puisqu'on cherche les "plus ancien", et parmi les doublons de ceux-ci, les plus courts. Et cette réduction s'applique à un groupement sur l'identifiant, puisqu'on cherche les plus courts des plus anciens pour chaque identifiant.

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
public class Demo {
 
	public static void main(String[] args) {
 
		List<VoyageBean> list = Arrays.asList(
				new VoyageBean("FAT_1", LocalDate.of(2016, 1, 1), 1000),
				new VoyageBean("FAT_1", LocalDate.of(2016, 2, 2), 1500),
				new VoyageBean("FAT_1", LocalDate.of(2016, 3, 3), 2000),
				new VoyageBean("FAT_2", LocalDate.of(2016, 1, 1), 1000),
				new VoyageBean("FAT_2", LocalDate.of(2016, 1, 1), 1010),
				new VoyageBean("FAT_2", LocalDate.of(2016, 3, 3), 2000),
				new VoyageBean("FAT_3", LocalDate.of(2016, 1, 1), 1000),
				new VoyageBean("FAT_3", LocalDate.of(2016, 1, 1), 1000),
				new VoyageBean("FAT_3", LocalDate.of(2016, 3, 3), 2000)
		);
 
		List<VoyageBean> result = list.stream()
		    .collect(
		    		Collectors.groupingBy(VoyageBean::getFat, // groupement sur l'identifiant
		    		Collectors.reducing(
		    				BinaryOperator.minBy( 
		    						Comparator.comparing(VoyageBean::getDate) // réduction sur la date la plus ancienne
		    						.thenComparing(VoyageBean::getDistance)) // réduction de la distance la plus courte
		    				)
		    		))
		    .values() // on veut une liste, et la réduction donne des Optional<VoyageBean>, on remap donc sur des VoyageBean
		    .stream()
		    .map(v-> v.orElse(null)) // on remap sur des VoyageBean
		    .sorted(Comparator.comparing(VoyageBean::getFat))
		    .collect(Collectors.toList());
 
		System.out.println(result);
 
	}
 
 
	public static class VoyageBean {
		private String fat;
		private LocalDate date;
		private long distance; 
		public VoyageBean(String fat, LocalDate date, long distance) {
			this.fat=fat;
			this.date=date;
			this.distance=distance;
		}
 
		public String getFat() {
			return fat;
		}
 
		public LocalDate getDate() {
			return date;
		}
 
		public long getDistance() {
			return distance;
		}
 
		@Override
		public String toString() {
			return fat+" "+date.format(DateTimeFormatter.ofPattern("dd/MM/yyyy"))+" "+distance+"km";
		}
 
	}
 
}

[toutemes1]

Merci Joel pour cet exercice de programmation fonctionnelle, ta solution marche