Battle Manager, Maps, lambdas, collecting

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);

        Map<String, Integer> health = new LinkedHashMap<>();
        Map<String, Integer> energy = new LinkedHashMap<>();

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

            switch (command){
                case "Add":
                    String personName = tokens[1];
                    int hp = Integer.parseInt(tokens[2]);
                    int nrg = Integer.parseInt(tokens[3]);

                    if(!health.containsKey(personName)){
                        health.put(personName, hp);
                        energy.put(personName, nrg);
                    }else{
                        health.put(personName, health.get(personName) + nrg);
                    }
                    break;
                case "Attack":
                    String attacker = tokens[1];
                    String defender = tokens[2];
                    int damage = Integer.parseInt(tokens[3]);

                    if(health.containsKey(attacker) && health.containsKey(defender)){
                        int damagedHealth = health.get(defender) - damage;
                        if(damagedHealth > 0){
                            health.put(defender, damagedHealth);
                        }else{
                            health.remove(defender);
                            energy.remove(defender);
                            System.out.println(defender + " was disqualified!");
                        }
                        int lostEnergy = energy.get(attacker) - 1;
                        if(lostEnergy > 0){
                            energy.put(attacker, lostEnergy);
                        }else{
                            health.remove(attacker);
                            energy.remove(attacker);
                            System.out.println(attacker + " was disqualified!");
                        }
                    }
                    break;
                case "Delete":
                    String deletedUser = tokens[1];
                    if(deletedUser.equals("All")){
                        health = new LinkedHashMap<>();
                        energy = new LinkedHashMap<>();
                    }
                    if(health.containsKey(deletedUser)){
                        health.remove(deletedUser);
                        energy.remove(deletedUser);
                    }
                    break;
                }
            }
        System.out.println("People count: " + health.size());

        health = health.entrySet()
                .stream()
                .sorted((a, b) -> {
                            int result = b.getValue().compareTo(a.getValue());
                            if (result == 0) {
                                result = a.getKey().compareTo(b.getKey());
                            }
                            return result;
                        }).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
                        (newVal, oldVal) -> oldVal, LinkedHashMap::new));

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