Decrement Max Value From Map?

Question

How can I sort a Map based on value? Here is the Map structure:

Map<DateTime, Integer> AppDetails = new Map<DateTime, Integer>();

And the data:

2016-10-1,10
2016-10-2,3
2016-10-3,13
2016-10-6,40
2016-10-4,60
2016-10-8,40

How can I sort AppDetails by value and get the highest value(60) out of it and return the date(2016-10-4) to the calling function and decrement the original value by 1 (in this case it will be 59) in the Map.

Thanks in advance!

Answer 1

Here is my attempt:

Map<Date, Integer> appDetails = new Map<Date, Integer>
{
    Date.newInstance(2016,10,1) => 10,
    Date.newInstance(2016,10,2) => 3,
    Date.newInstance(2016,10,3) => 13,
    Date.newInstance(2016,10,6) => 40,
    Date.newInstance(2016,10,4) => 60,
    Date.newInstance(2016,10,8) => 40
};

List<Integer> detailsList = new List<Integer>( appDetails.values() );
detailsList.sort();
Integer maxNumber = detailsList[detailsList.size() - 1];
Integer maxCount = 1;

while (detailsList[detailsList.size() - 1 - maxCount] == maxNumber)
    maxCount++;

for (Date d:appDetails.keySet())
{
    if(appDetails.get(d) == maxNumber)
    {
        appDetails.put(d, maxNumber - 1);
        maxCount--;
        if(maxCount == 0)
            break;
    }
}

It could handle multiple members with max value (if there are more than one) and will decrease each by 1. It also breaks the loop after all members with max value were updated.

Answer 2

Maps are an example of an unordered collection, which cannot be sorted.

However, If you're open to writing code and spending additional time developing your idea, you can build something that should work.

From what I see, you don't absolutely require a Map, it was just the closest feature provided by Salesforce that you could find.

Instead of a Map, I'd suggest making an Apex class to hold your data that implements the comparable interface. You can then store these results in a List (which is an ordered collection).

A quick example to get you going

class DatePlusInteger implements Comparable{
    public Date myDate;
    public Integer count;

    public Integer compareTo(Object compareObj){
        DatePlusInteger comparisonTarget = (DatePlusInteger)compareObj;

        if(comparisonTarget.Integer === count){
            return 0;
        }else if(comparisonTarget.Integer < count){
            // This instance of our object has a greater count than the one
            //   we are comparing against. So, return positive 1
            return 1;
        } else {
            return -1;
        }
    }
}

Implementing the Comparable interface will allow you to call List.sort(). Doing so will sort the records in ascending order, meaning that your largest count will be the last element of your list.

The last element of a list is pretty easily retrieved using the List's size() method

// Apex collections are 0-indexed, so when using size(), we must subtract 1
// Otherwise, we'd get an out-of-bounds exception
Object lastElement = someList[someList.size() - 1];

I'm fairly certain that retrieving an object from a List returns a reference to the object instance in that list. To put it simply, that means that you should be able to grab the date, decrement the count, and not have to worry about anything else.

lastElement.myDate;
lastElement.count -= 1;

A slightly better approach would be to add a getter to DatePlusCount that would take care of the decrementing for you.

class DatePlusCount{
    /* other lines omitted */
    public Date getDate(){
        count -=1;
        return myDate;
    }
}

usage is pretty simple

// Assuming List<DatePlusCount> myList is initialized elsewhere...
myList.sort();
Date targetDate = myList[myList.size()-1].getDate();

The only thing left that you'd need to concern yourself with would be to make sure that you always call sort() on the List every single time before trying to retrieve the Date associated with the maximum count.

Swapping the return 1; and return -1; in the compareTo(Object compareObj) method could make things even simpler still. That should effectively cause the list sorting to return in decending order, meaning the max value would be at index 0;

Answer 3

Here is another option. At first I thought Comparable would make the most sense, but this might be faster. I haven't profiled them, that's just a guess.

public static void decrementMaxValue(Map<Datetime, Integer> input)
{
    Datetime maxKey;
    Integer maxValue;
    for (Datetime key : input.keySet())
    {
        Integer value = input.get(key);
        if (maxValue == null || (value != null && value > maxValue))
        {
            maxValue = value;
            maxKey = key;
        }
    }
    if (maxKey != null && maxValue != null)
        input.put(maxKey, maxValue - 1);
}

You could probably program this method to be less defensive against NPE. I'll leave that to you to decide.

I profiled the three approaches recommended so far and this one does seem to be the fastest. Here is a Gist detailing my methodology. Your mileage may vary. My results (milliseconds per hundred calls):

method                  Trial_1  Trial_2  Trial_3  Trial_4  Trial_5  Average
decrementMaxComparable       32       33       31       28       26     30.0
decrementMaxInvertMap        17       18       16       19       19     17.8
decrementMaxTrackValue       11       10       11       11       12     11.0

Answer 4

In this case you have to create a new Map by using AppDetails Map. Like :

Map<integer, date> details = new Map<integer, date>(); for(date d : AppDetails.keySet()) { details.put(AppDetails.get(d), d); }

Now by using new map you can get set. Like : Set<Integer> values = details.keyset();

Now change Set into List.In List you can apply sort() method to sort values in List.'

List<Integer> sortedList = new List<Integer>(values).sort();

Last element is your Max value and by this value you can corresponding date using details map. Like :

Date d = details.get(sortedList[sortedList.size() - 1]);