Message Manager - Map, sorting descend. by val, asc. by name

package com.company;

import javafx.util.Pair;

import javax.xml.crypto.dsig.keyinfo.KeyValue;
import java.lang.reflect.Array;
import java.security.KeyStore;
import java.text.Collator;
import java.text.DecimalFormat;
import java.util.*;
import java.util.function.Predicate;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collector;
import java.util.stream.Collectors;


public class Main {



    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        //sent - received
        Map<String, List<Integer>> record = new LinkedHashMap<>();

        int capacity = Integer.parseInt(scanner.nextLine());

        String input = "";
        while(!"Statistics".equals(input = scanner.nextLine())){
            String[] tokens = input.split("=");
            String command = tokens[0];

            switch (command){
                case "Add":
                    String username = tokens[1];
                    Integer sent = Integer.parseInt(tokens[2]);
                    Integer received = Integer.parseInt(tokens[3]);
                    if(!record.containsKey(username)){
                        List<Integer> messages = new ArrayList<Integer>();
                        messages.add(sent);
                        messages.add(received);
                        record.put(username, messages);
                    }
                    break;
                case "Message":
                    String sender = tokens[1];
                    String receiver = tokens[2];
                    if(record.containsKey(sender) && record.containsKey(receiver)){
                        int sentMsg = record.get(sender).get(0) + 1;
                        record.get(sender).set(0, sentMsg);
                        if(sentMsg + record.get(sender).get(1) >= capacity){
                            record.remove(sender);
                            System.out.println(sender + " reached the capacity!");
                        }

                        int receivedMsg = record.get(receiver).get(1) + 1;
                        record.get(receiver).set(1, receivedMsg);
                        if(receivedMsg + record.get(receiver).get(0) >= capacity){
                            record.remove(receiver);
                            System.out.println(receiver + " reached the capacity!");
                        }
                    }
                    break;
                case "Empty":
                    String deleteUser = tokens[1];
                    if(deleteUser.equals("All")){
                        record = new LinkedHashMap<>();
                    }else{
                        record.remove(deleteUser);
                    }
                    break;
            }
        }
        System.out.printf("Users count: %d\n", record.size());
        record = record
                .entrySet()
                .stream()
                .sorted((a, b) -> {
                    int userA = a.getValue().get(1);
                    int userB = b.getValue().get(1);

                    // sort users in descending order by the received messages
                    // then by username in ascending order
                    if(userA < userB){
                        return 1;
                    }else if(userA > userB){
                        return -1;
                    }else {
                      return  a.getKey().compareTo(b.getKey());
                    }
                }).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,  (newVal, oldVal) -> oldVal, LinkedHashMap::new));

        for (Map.Entry<String, List<Integer>> entry : record.entrySet()) {
            System.out.printf("%s - %d\n", entry.getKey(), entry.getValue().get(0) + entry.getValue().get(1));
        }

    }
}