Groupement de par la valeur de l'objet, de comptage et de définir ensuite la clé de groupe par le maximum d'attribut de l'objet

J'ai réussi à écrire une solution à l'aide de Java 8 API de Flux que les premiers groupes, une liste d'objet de l'Itinéraire par sa valeur et compte ensuite le nombre d'objets dans chaque groupe. Elle renvoie une cartographie des Parcours -> Long. Voici le code:

Map<Route, Long> routesCounted = routes.stream()
                .collect(Collectors.groupingBy(gr -> gr, Collectors.counting()));

Et la classe de la Route:

public class Route implements Comparable<Route> {
private long lastUpdated;
private Cell startCell;
private Cell endCell;
private int dropOffSize;
public Route(Cell startCell, Cell endCell, long lastUpdated) {
this.startCell = startCell;
this.endCell = endCell;
this.lastUpdated = lastUpdated;
}
public long getLastUpdated() {
return this.lastUpdated;
}
public void setLastUpdated(long lastUpdated) {
this.lastUpdated = lastUpdated;
}
public Cell getStartCell() {
return startCell;
}
public void setStartCell(Cell startCell) {
this.startCell = startCell;
}
public Cell getEndCell() {
return endCell;
}
public void setEndCell(Cell endCell) {
this.endCell = endCell;
}
public int getDropOffSize() {
return this.dropOffSize;
}
public void setDropOffSize(int dropOffSize) {
this.dropOffSize = dropOffSize;
}
@Override
/**
* Compute hash code by using Apache Commons Lang HashCodeBuilder.
*/
public int hashCode() {
return new HashCodeBuilder(43, 59)
.append(this.startCell)
.append(this.endCell)
.toHashCode();
}
@Override
/**
* Compute equals by using Apache Commons Lang EqualsBuilder.
*/
public boolean equals(Object obj) {
if (!(obj instanceof Route))
return false;
if (obj == this)
return true;
Route route = (Route) obj;
return new EqualsBuilder()
.append(this.startCell, route.startCell)
.append(this.endCell, route.endCell)
.isEquals();
}
@Override
public int compareTo(Route route) {
if (this.dropOffSize < route.dropOffSize)
return -1;
else if (this.dropOffSize > route.dropOffSize)
return 1;
else {
//if contains drop off timestamps, order by last timestamp in drop off
//the highest timestamp has preceding
if (this.lastUpdated < route.lastUpdated)
return -1;
else if (this.lastUpdated > route.lastUpdated)
return 1;
else
return 0;
}
}
}

Ce que je voudrais en outre à atteindre, qui est la clé pour chaque groupe sera celui avec le plus grand lastUpdated valeur. J'étais déjà à la recherche à cette solution mais je ne sais pas comment combiner le comptage et le regroupement en fonction de la valeur et de la Route maximale lastUpdated valeur. Voici les données d'exemple de ce que je veux réaliser:

EXEMPLE:

List<Route> routes = new ArrayList<>();
routes.add(new Route(new Cell(1, 2), new Cell(2, 1), 1200L));
routes.add(new Route(new Cell(3, 2), new Cell(2, 5), 1800L));
routes.add(new Route(new Cell(1, 2), new Cell(2, 1), 1700L));

DOIT ÊTRE CONVERTIE EN UNE:

Map<Route, Long> routesCounted = new HashMap<>();
routesCounted.put(new Route(new Cell(1, 2), new Cell(2, 1), 1700L), 2);
routesCounted.put(new Route(new Cell(3, 2), new Cell(2, 5), 1800L), 1);

Avis que la clé pour la cartographie, qui comptait 2 Voies est l'un avec le plus grand lastUpdated valeur.

  • Dans l'exemple que vous utilisez new Route avec 3 paramètres, alors que le seul constructeur a 4 paramètres. Pourriez-vous veuillez la corriger?
  • Ups my bad. Il est fixé maintenant. Fondamentalement, la dropOffSize la taille n'importe pas ici, mais je ne l'ai laisser dans le code, parce que je voulais montrer à tout le remplacé les méthodes et la méthode compareTo ne faire usage de dropOffSize.
InformationsquelleAutor Jernej Jerin | 2015-05-13