Map sample from functional Java to functional Kotlin

Maps.java

import java.util.List;
import java.util.Map;
import java.util.Set;

import static java.util.Comparator.comparing;
import static java.util.stream.Collectors.*;

public class Maps {
    public static Map<Integer, List<String>> listByScore(Map<String, Integer> scores) {

        return scores.keySet()
                .stream()
                .collect(groupingBy(scores::get));
    }

    public static Map<Integer, Set<String>> setByScore(Map<String, Integer> scores) {

        return scores.keySet()
                .stream()
                .collect(groupingBy(scores::get,
                        mapping(String::toUpperCase, toSet())));
    }

    public static Map<Integer, Integer> countScores(Map<String, Integer> scores) {

        return scores.keySet()
                .stream()
                .collect(groupingBy(scores::get,
                        collectingAndThen(counting(), Long::intValue)));
    }

    public static Map<Integer, Set<Integer>> numberOfLetters(Map<String, Integer> scores) {
        return scores.keySet()
                .stream()
                .collect(groupingBy(scores::get,
                        mapping(String::length, toSet())));

    }

    public static Map<Integer, Integer> maxNumberOfLetters(Map<String, Integer> scores) {

        return scores.keySet()
                .stream()
                .collect(groupingBy(scores::get,
                        collectingAndThen(maxBy(comparing(String::length)),
                                name -> name.orElse("").length())));
    }
}

MapsK.kt

class MapsK {

    companion object {

        @JvmStatic
        fun listByScore(scores: Map<String, Integer>): Map<Integer?, List<String>> {
            return scores
                    .keys
                    .groupBy(scores::get)
        }

        @JvmStatic
        fun countScores(scores: Map<String, Int>): Map<Int, Int> {
            return scores
                    .asSequence()
                    .groupingBy { it.value }
                    .eachCount()
        }

        @JvmStatic
        fun setByScore(scores: Map<String, Int>): Map<Int?, Set<String>> {
            return scores
                    .keys
                    .groupBy(scores::get)
                    .mapValues {
                        it.value
                                .map(String::toUpperCase)
                                .toSet()
                    }
        }

        @JvmStatic
        fun numberOfLetters(scores: Map<String, Int>): Map<Int?, Set<Int>> {
            return scores
                    .keys
                    .groupBy(scores::get)
                    .mapValues {
                        it.value
                                .map(String::length)
                                .toSet()
                    }
        }

        @JvmStatic
        fun maxNumberOfLetters(scores: Map<String, Int>): Map<Int?, Int?> {
            return scores
                    .keys
                    .groupBy(scores::get)
                    .mapValues {
                        it.value
                                .map(String::length)
                                .max()
                    }
        }

    }

}

MapsTest

import org.junit.jupiter.api.Test;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

import static org.junit.jupiter.api.Assertions.*;

public class MapsTest {
    private Map<String, Integer> scores = new HashMap<String, Integer>() {
        {
            put("Jack", 12);
            put("Jill", 15);
            put("Tom", 11);
            put("Darla", 15);
            put("TOM", 11);
            put("Nick", 15);
            put("Nancy", 11);
        }
    };

    @Test
    void scoresList() {
        assertAll(
                () -> assertEquals(Arrays.asList("Jack"), MapsK.listByScore(scores).get(12))
                , () -> assertEquals(3, MapsK.listByScore(scores).get(15).size())
                , () -> assertTrue(MapsK.listByScore(scores).get(15).contains("Darla"))
                , () -> assertEquals(3, MapsK.listByScore(scores).get(11).size())
                , () -> assertTrue(MapsK.listByScore(scores).get(11).contains("Tom"))
                , () -> assertTrue(MapsK.listByScore(scores).get(11).contains("TOM"))
        );
    }

    @Test
    void scoresSet() {
        assertAll(
                () -> assertTrue(MapsK.setByScore(scores).get(12).contains("JACK"))
                , () -> assertEquals(3, MapsK.setByScore(scores).get(15).size())
                , () -> assertTrue(MapsK.setByScore(scores).get(15).contains("DARLA"))
                , () -> assertEquals(2, MapsK.setByScore(scores).get(11).size())
                , () -> assertTrue(MapsK.setByScore(scores).get(11).contains("TOM"))
        );
    }

    @Test
    void scoresCount() {
        assertAll(
                () -> assertEquals(1, (int) MapsK.countScores(scores).get(12))
                , () -> assertEquals(3, (int) MapsK.countScores(scores).get(11))
                , () -> assertEquals(3, (int) MapsK.countScores(scores).get(15))
        );
    }

    @Test
    void numberOfLetters() {
        assertAll(
                () -> assertTrue(MapsK.numberOfLetters(scores).get(12).contains(4))
                , () -> assertTrue(MapsK.numberOfLetters(scores).get(15).contains(5))
                , () -> assertTrue(MapsK.numberOfLetters(scores).get(15).contains(4))
                , () -> assertTrue(MapsK.numberOfLetters(scores).get(11).contains(5))
                , () -> assertTrue(MapsK.numberOfLetters(scores).get(11).contains(3))
        );
    }

    @Test
    void maxNumberOfLetters() {
        assertAll(
                () -> assertEquals(4, (int) MapsK.maxNumberOfLetters(scores).get(12))
                , () -> assertEquals(5, (int) MapsK.maxNumberOfLetters(scores).get(15))
                , () -> assertEquals(5, (int) MapsK.maxNumberOfLetters(scores).get(11))
        );
    }
}