Java8 Nested Grouping with time intervals - java-8

Question

I've the list in the following format:
List<MyObject> myObj = Arrays.asList(
new MyObject(time="2017-05-09T15:37:51.896+00:00", name="123", status=200)
new MyObject(time="2017-05-09T15:37:57.090+00:00", name="ABC", status=200)
new MyObject(time="2017-05-09T15:37:59.733+00:00", name="ABC", status=200)
new MyObject(time="2017-05-09T15:39:57.883+00:00", name="ABC", status=200)
new MyObject(time="2017-05-09T15:40:00.862+00:00", name="ABC", status=200)
new MyObject(time="2017-05-09T15:40:04.659+00:00", name="ABC", status=200)
new MyObject(time="2017-05-09T15:40:05.114+00:00", name="ABC", status=500)
new MyObject(time="2017-05-09T15:45:58.796+00:00", name="XYZ", status=200)
new MyObject(time="2017-05-09T15:46:00.562+00:00", name="XYZ", status=200)
new MyObject(time="2017-05-09T15:48:04.144+00:00", name="ABC", status=200)
new MyObject(time="2017-05-09T15:48:04.364+00:00", name="ABC", status=200)
new MyObject(time="2017-05-09T15:48:04.750+00:00", name="ABC", status=200)
new MyObject(time="2017-05-09T15:48:07.052+00:00", name="XYZ", status=202)
);
I wanted to iterate through that and perform some grouping with 1m interval and achieve as follows:
ABC
-> 15:37
-> 200 -> 2
-> 202 -> 0
-> 500 -> 0
-> 15:38
-> 200 -> 0
-> 202 -> 0
-> 500 -> 0
-> 15:39
-> 200 -> 1
-> 202 -> 0
-> 500 -> 0
-> 15:40
-> 200 -> 2
-> 202 -> 0
-> 500 -> 1
What I've tried so far is:
myObj.stream()
.collect(Collectors.groupingBy(MyObject::getName,
Collectors.groupingBy(MyObject::getTime)));
But this actually groups by name, then by time. But I want to have the 1m time interval and then group by status also.
Need help here since I'm novice to streams and lambdas in java.
EDIT: Please note that the getTime returns a String, not the Date.

Answer 1

This could be achieved via:
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm");
Map<String, Map<String, Map<Integer, Integer>>> collect = myObj.stream()
.collect(Collectors.groupingBy(MyObject::getName, TreeMap::new,
Collectors.groupingBy(
myObject -> ZonedDateTime.parse(myObject.getTime()).format(formatter),
TreeMap::new,
Collectors.groupingBy(MyObject::getStatus, TreeMap::new,
Collectors.summingInt(i -> 1)
)
)
));
Outcome:
{
123={
15:37={200=1}
},
ABC={
15:37={200=2}, 15:39={200=1}, 15:40={200=2, 500=1}, 15:48={200=3}
},
XYZ={
15:45={200=1}, 15:46={200=1}, 15:48={202=1}
}
}

Answer 2

I understand that you require “empty” entries, both for the minutes where there are no objects for the name in question, and also for the statuses that don’t appear within that minute. Streams are great for processing the elements that are in the stream, but not good at inventing elements that are not already there.
My suggestion is you build the map structure from the elements you have using streams, and then fill in the missing empty entries afterward. The first part is quite like Flown’s answer.
First I suggest if you can fit your MyObject class with an extra getter in addition to the standard ones:
public LocalTime getWholeMinute() {
return ZonedDateTime.parse(time)
.withZoneSameInstant(ZoneOffset.UTC)
.toLocalTime()
.truncatedTo(ChronoUnit.MINUTES);
}
This will return the whole minute of the time. The method can return LocalDateTime if you need to distinguish times accross days (and you can always format it later to print only the time). If you cannot modify MyObject you may instead declare a static method that takes a MyObject, extracts the time string, performs the above calculation and returns the LocalTime or LocalDateTime. Either of the suggested methods will come in handy next:
final int[] statuses = { 200, 202, 500 };
if (! myObj.isEmpty()) {
LocalTime minTime = myObj.stream()
.map(MyObject::getWholeMinute)
.min(Comparator.naturalOrder())
.get();
LocalTime maxTime = myObj.stream()
.map(MyObject::getWholeMinute)
.max(Comparator.naturalOrder())
.get();
Map<String, Map<LocalTime, Map<Integer, Long>>> counts = myObj.stream()
.collect(Collectors.groupingBy(MyObject::getName,
Collectors.groupingBy(MyObject::getWholeMinute,
Collectors.groupingBy(MyObject::getStatus,
Collectors.counting()))));
for (Map.Entry<String, Map<LocalTime, Map<Integer, Long>>> outerEntry :
counts.entrySet()) {
Map<LocalTime, Map<Integer, Long>> middleMap = outerEntry.getValue();
LocalTime currentMinute = minTime;
while (! currentMinute.isAfter(maxTime)) {
// fill in missing map
Map<Integer, Long> innerMap
= middleMap.computeIfAbsent(currentMinute, t -> new HashMap<>(4));
// fill in missing counts
for (int status : statuses) {
innerMap.putIfAbsent(status, 0L);
}
currentMinute = currentMinute.plusMinutes(1);
}
}
// ...
}
The other approach I was thinking of was creating the map structure filled with zero counts first, and then iterating over the list and increasing the relevant count for each object encountered. I think it will take just a few more code lines and may be clearer since it will not use the many nested collectors.