Extend output of stream with groupingBy & summingInt in Java8

A simple way to group by a subset of fields is to use a TreeMap with a custom Comparator. Suppose you were to define

Comparator<Topic> byDateAndUser = Comparator.comparing(Topic::getDate)
            .thenComparing(t -> t.getUser().getUserId());

Map<Topic,...> map = new TreeMap<>(byDateAndUser);

The resulting map would use the supplied comparator instead of equals to determine equality and will thus treat all topics with the same date and user as the same.

This feature of TreeMap allows you to compute a Map of topic to the total points and it will only contain one entry for each combination of date/user:

import static java.util.stream.Collectors.groupingBy;
import static java.util.stream.Collectors.summingInt;

Comparator<Topic> byDateAndUser = Comparator.comparing(Topic::getDate)
            .thenComparing(t -> t.getUser().getUserId());

Map<Topic, Integer> pointTotals = topics.stream()
        .collect(groupingBy(
                topic -> topic, 
                () -> new TreeMap<>(byDateAndUser), 
                summingInt(Topic::getPoints)
        ));

Assuming User implements hashCode and equals consistently, you could group to a map of date/user composite key and ResultDto values. To do this, you need two operations: one to map to and the other one to aggregate points for each group. (You can place these operations either in ResultDto or in a utility class, etc, here I'm assuming the first one is in a Mapper utility class and the 2nd one in ResultDto):

public final class Mapper {

    private Mapper() { }

    public static ResultDto fromTopic(Topic topic) {
        ResultDto result = new ResultDto();
        result.setDate(topic.getDate());
        result.setName(topic.getName());
        result.setPoints(topic.getPoints());
        result.setUser(topic.getUser());
        return result;
    }
}

In ResultDto:

public ResultDto merge(ResultDto another) {
    this.points += another.points;
    return this;
}

Note that I'm assigning the first Topic.name found in the Mapper.fromTopic mapping operation. I'm assuming this is an inconsistency in your example, please take it into account if you use this approach in a real world scenario.

Now we can stream the topics and group by date/user:

Map<List<Object>, ResultDto> groups = topics.stream()
    .collect(Collectors.toMap(
        topic -> Arrays.asList(topic.getDate, topic.getUser()), // Java 9: List.of
        Mapper::fromTopic,
        ResultDto::merge));

This collects to a map whose key is a List with its first element being the date and the second, the user. These 2-element lists aren't very useful for later usage, here we're only using them to create a composite key and group topics by this key. The values of the map is a ResultDto instance that is initially created from the topic and then merged with other topics that belong to the same group (same date and user). In this ResultDto.merge operation the points are being summed.

The results you need are the values of the map:

Collection<ResultDto> results = groups.values(); // or new ArrayList<>(groups.values())

EDIT: Here's a slightly more succinct variant without streams:

Map<List<Object>, ResultDto> groups = new HashMap<>();

topics.forEach(topic -> groups.merge(
    List.of(topic.getDate(), topic.getUser()), // Java 8: Arrays.asList
    Mapper.fromTopic(topic),
    ResultDto::merge));

Collection<ResultDto> results = groups.values();