Race - Regex [Map sorting and collection | Using patterns]

package com.company;

import javafx.util.Pair;

import javax.xml.crypto.dsig.keyinfo.KeyValue;
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;
import java.util.stream.Stream;


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

        Map<String, Integer> racers = new LinkedHashMap<>();
        List<String> names = Arrays.stream(scanner.nextLine().split(", ")).collect(Collectors.toList());

        String regexLetters = "(?<name>[A-Za-z]+)";
        String regexDistance = "(?<distance>[0-9])";

        for (String name : names) {
            if (!racers.containsKey(name)) {
                racers.put(name, 0);
            }
        }

        String input;
        while (!"end of race".equals(input = scanner.nextLine())) {

            Pattern letterPattern = Pattern.compile(regexLetters);
            Matcher nameMatcher = letterPattern.matcher(input);
            StringBuilder builder = new StringBuilder();

            while (nameMatcher.find()) {
                builder.append(nameMatcher.group("name"));
            }
            String racerName = builder.toString();

            Pattern distancePattern = Pattern.compile(regexDistance);
            Matcher distanceMatcher = distancePattern.matcher(input);
            int distance = 0;

            while (distanceMatcher.find()) {
                distance += Double.parseDouble(distanceMatcher.group("distance"));
            }

            if (racers.containsKey(racerName)) {
                racers.put(racerName, racers.get(racerName) + distance);
            }
        }
        racers = racers
                .entrySet()
                .stream()
                .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
                        (newVal, oldVal) -> oldVal, LinkedHashMap::new));

        int i = 1;
        for (Map.Entry<String, Integer> racer : racers.entrySet()) {

            if (i > 3) break;
            String place = "";

            switch (i) {
                case 1:
                    place = "1st place: ";
                    break;
                case 2:
                    place = "2nd place: ";
                    break;
                case 3:
                    place = "3rd place: ";
                    break;
            }
            System.out.println(place + racer.getKey());
            i++;
        }
    }
}