How could we sort a Map descending by values and then alphabetically by keys?

Question

I am currently doing the following programming task: Prize Draw, the statement is:

To participate in a prize draw each one gives his/her firstname.

Each letter of a firstname has a value which is its rank in the English alphabet. A and a have rank 1, B and b rank 2 and so on.

The length of the firstname is added to the sum of these ranks hence a number som.

An array of random weights is linked to the firstnames and each som is multiplied by its corresponding weight to get what they call a winning number.

Example:

names: "COLIN,AMANDBA,AMANDAB,CAROL,PauL,JOSEPH" weights: [1, 4, 4, 5, 2, 1]

PauL -> som = length of firstname + 16 + 1 + 21 + 12 = 4 + 50 -> 54 The weight associated with PauL is 2 so PauL's winning number is 54 * 2 = 108.

Now one can sort the firstnames in decreasing order of the winning numbers. When two people have the same winning number sort them alphabetically by their firstnames. Task:
parameters: st a string of firstnames, we an array of weights, n a rank

return: the firstname of the participant whose rank is n (ranks are numbered from 1)
Example:

names: "COLIN,AMANDBA,AMANDAB,CAROL,PauL,JOSEPH" weights: [1, 4, 4, 5, 2, 1] n: 4

The function should return: "PauL"

Note:
If st is empty return "No participants".

If n is greater than the number of participants then return "Not enough participants".

I have thought the pseudocode as:

if names are empty return No participants
if n is greater than names length return Not enough participants
for each name
    sum its length
    for each character
        sum its value in the alphabet
    multiply sum by weight
    store name and sum in the map
sort map descending by value
sort map alphabetically by key (if values are equal)
return key n from the map

In addition I have coded the following:

import java.util.*;
import java.util.stream.*;

class Rank {

    public static String nthRank(String st, Integer[] we, int n) {
      System.out.println("\n\n\nNames: "+st+" weights: "+Arrays.toString(we)+" n: "+n);

      if(st.isEmpty()) return "No participants";
      String[] names = st.split(",");
      if(n > names.length) return "Not enough participants";

      String alphabet = "abcdefghijklmnopqrstuvwxyz";
      int sum = 0;
      Map<String, Integer> map = new HashMap<String, Integer>();

      for(int i = 0; i < names.length; i++){
        String currentName = names[i];
        sum += currentName.length();
        for(int j = 0; j < currentName.length(); j++){
          char currentChar = Character.toLowerCase(currentName.charAt(j));
          sum += alphabet.indexOf(currentChar) + 1;
        }
        map.put(currentName, sum*we[i]);
        System.out.println("Map: "+map.toString());
        sum = 0;
      }

      map = map.entrySet().stream()
            .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
            .collect(Collectors.toMap(
              Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));

      System.out.println("\n\nSorted Map: "+map.toString());

      Object[] namesByWinningNumber = map.keySet().toArray();
      Arrays.sort(namesByWinningNumber);

      System.out.println("\n\n\nSorted names array: "+ Arrays.toString(namesByWinningNumber));

      return map.keySet().toArray()[n-1].toString();
    }
}

When input is:

Names: William,Willaim,Olivia,Olivai,Lily,Lyli weights: [1, 1, 1, 1, 1, 1] n: 1

Expected is:

Willaim

But the code outputs:

William

Being the trace:

Names: William,Willaim,Olivia,Olivai,Lily,Lyli weights: [1, 1, 1, 1, 1, 1] n: 1
Map: {William=86}
Map: {William=86, Willaim=86}
Map: {Olivia=74, William=86, Willaim=86}
Map: {Olivia=74, Olivai=74, William=86, Willaim=86}
Map: {Olivia=74, Olivai=74, William=86, Willaim=86, Lily=62}
Map: {Olivia=74, Olivai=74, William=86, Willaim=86, Lily=62, Lyli=62}


Sorted Map: {William=86, Willaim=86, Olivia=74, Olivai=74, Lily=62, Lyli=62}



Sorted names array: [Lily, Lyli, Olivai, Olivia, Willaim, William]

So, as we see, first I sort the map by values in descending order. Then I thought if I get the keys and I sort them alphabetically, it would just take care of the ones with exact same values; however it sorts all.