如何对地图进行排序 <String, List<Summary> &gt;

Question

I need sort a map by attribute of elements of values that are a list. See the code.

public Map<String, List<Summary>> getMostMentions() throws Exception {

    List<Tweet> tweets;
    try {
        tweets = getApiFromTweet().getTweets();
    } catch (Exception e) {
        throw new Exception(e);
    }


    List<Summary> summary = new ArrayList<>();

    tweets.forEach(t -> {
        summary.add(
                new Summary(
                        t.getUser().getScreen_name(), 
                        t.getFollowersCount(), 
                        t.getRetweet_count(),                   
                        t.getFavorite_count(), 
                        t.getText(), 
                        t.getCreated_at(),
                        appConfig.getProfileLink(t.getUser().getScreen_name()),
                        appConfig.getTweetLink(t.getUser().getScreen_name(), t.getId())));
    });

    Map<String, List<Summary>> mostMentionsMap = summary.stream().collect(Collectors.groupingBy(Summary::getScreen_name));

    mostMentionsMap.forEach((k,v) -> {
        v.sort(Comparator.comparing(Summary::getFavorite_count).reversed());
    });


    return mostMentionsMap;
}

I need sort the map mostMentionsMap by getFavorite_count of the elements List to return map sorted. I'm already sorting the elements of each map item, but I need to use the same sorting criteria for the map.

I can sort by key see the code.

LinkedHashMap<String, List<SummaryTweet>> mapSorted = mostMentionsMap.entrySet().stream()
                .sorted(Map.Entry.comparingByKey())             
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
                        (oldValue, newValue) -> oldValue, LinkedHashMap::new));

But, I have to sort by a attribute of the elements of the values ​​(List ). I do not know if I'm explaining well?

Answer 1

Well, it's clear from your question that you want to sort the Map by values. And you can do that using:

Comparator<List<Summary>> valueComparator;

LinkedHashMap<String, List<Summary>> mapSorted = mostMentionsMap.entrySet().stream()
        .sorted(Map.Entry.comparingByValue(valueComparator))
        .collect(Collectors.toMap(
                Map.Entry::getKey, Map.Entry::getValue,
                (oldValue, newValue) -> oldValue, // or throw here (just in case)
                LinkedHashMap::new
        ));

Now, it's unclear (and that's what Slaw's comment was about) how you want to sort the values (ie what the valueComparator should be). We know you want to sort using Summary::getFavorite_count , but since you have a List of Summary 'ies, the options are multiple. Here are a few of these options:

1) Sort by maximum:

// assumes Summaries are sorted by: Comparator.comparing(Summary::getFavorite_count).reversed()
Comparator.<List<Summary>>comparingInt(list -> list.isEmpty()
        ? 0
        : list.get(0).getFavorite_count()
).reversed();

2) Sort by total:

Comparator.<List<Summary>>comparingInt(list -> list.stream()
        .mapToInt(Summary::getFavorite_count)
        .sum()
).reversed();

3) Sort by average:

Comparator.<List<Summary>>comparingDouble(list -> list.stream()
        .mapToInt(Summary::getFavorite_count)
        .average().orElse(0)
).reversed();

Answer 2

In general when wanting a specific ordering of a map in Java you should probably use a TreeMap. Now, I am supposing .getFavorite_count returns a int so the key will need to be of type Integer as I am not sure making the key of type String will sort a number of type String as you currently have in your return type.

Answer 3

You can use the Comparable Interface:

public class YourNameOfTheClass implements Comparable</*Your objects, which should be sorted. Example: Car*/> {

/*Your code and stuff…*/

    @Override
    public int compareTo(/*Your object, which you wrote above and the name of it. Example: Car myCar*/) {

        /*
        Now here you should enter your criteria.

        If you want to sort something it should be comparable.

        Usually, this method returns '0', when the two objects, which are compared are equal. So you should write something like this:

        if (this.getFavourite() == car.getFavourite())
            return 0;

        This method returns a negative integer when the first object has a 'smaller' value and a positive integer when it's of greater value.

        Example:
        myCar.compareTo(yourCar) would return 0, if we're actually driving the same car. -1 when my Car is not as good as yours and +1 when my Car is better.
        */
    }
}

After you've defined your comparison criterion, you can sort it simply like this:

Collections.sort(/*The name of your list*/)

I'll demonstrate it:

public class CompareCars implements Comparable<Car> {

    public static void main (String [] args) {
        List<Car> allCars = new ArrayList<Car>();
        Collections.sort(allCars);
    }

    @Override
    public int compareTo (Car secondCar) {
        if (this.getLicensePlate() == secondCar.getLicensePlate() || this.getHP() == secondCar.getHP())
            return 0;
        if (this.getHP() > secondCar.getHP())
            return 1;
        else
            return -1;
    }

}

You can read more about it here . It should work with maps, too.