Mapa <K, V> Voltar ao mapa <V, Map <K, V >> após valor groupingBy, em vez de Map <Obj, List <Entry <K, V >>>

É um pouco surpreendente que você tem dificuldades aqui, como você já mostrado o conhecimento de todas as coisas necessárias. Você sabe que groupingBypode tomar outra Collector, você nomeou o caminho certo, toMapjá, e você já usou funções para extrair os Map.Entryvalores já.

Combinando essas coisas, dá-lhe

Map<Long, Map<Integer, Long>> groups = filtered.entrySet().stream()
    .collect(Collectors.groupingBy(x -> x.getValue(),
        Collectors.toMap(x -> x.getKey(), x -> x.getValue())));
System.out.println("grouped " + groups);

Para demonstrar melhor a operação, I mudou a entrada para

List<Integer> list = Arrays.asList(1, 1, 1, 2, 3, 3, 3, 3, 4, 4, 4);

o que resulta em

grouped {3=[1=3, 4=3], 4=[3=4]}

porém, não há nenhum ponto em repetir as contagens que são sempre o mesmo que o exterior mapeia chaves. Assim, uma alternativa seria

Map<Long, List<Integer>> groups = filtered.entrySet().stream()
    .collect(Collectors.groupingBy(Map.Entry::getValue,
        Collectors.mapping(Map.Entry::getKey, Collectors.toList())));
System.out.println("grouped " + groups);

o que leva a

grouped {3=[1, 4], 4=[3]}

Note que você não deve usar forEach/ forEachOrdereda putem um mapa. Seus passos intermediários deve, antes, ser

//Sort desc
Map<Integer, Long> descendingSorted = countGrouped.entrySet().stream()
    .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
        (a,b) -> { throw new AssertionError(); }, LinkedHashMap::new));
System.out.println("sorted " + descendingSorted);

//filter
Map<Integer, Long> filtered = descendingSorted.entrySet().stream()
    .filter(x -> x.getValue() >= 2)
    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
        (a,b) -> { throw new AssertionError(); }, LinkedHashMap::new));
System.out.println("filtered " + filtered);

O toMapcoletor de aceitar um mapa de fábrica forças dos EUA para fornecer uma função direta, mas desde a nossa entrada já é um mapa que deve ter chaves distintas, forneci uma função sempre jogando aqui, como algo seria muito errado, se duplicatas aparecer.

Mas nota que forçar todas estas operações para recolher em novos mapas é desnecessariamente complicado e ineficiente. Também há nenhum ponto na classificação dos dados inteiros em primeiro lugar e reduzir a quantidade de dados por meio filterdepois. Filtrando primeira seria, potencialmente, reduzir o trabalho da etapa de classificação Considerando que o resultado da operação do filtro não deve depender do fim.

É muito melhor fazer toda a operação em um único gasoduto

List<Integer> list = Arrays.asList(1, 1, 1, 2, 3, 3, 3, 3, 4, 4, 4);

Map<Integer, Long> countGrouped = list.stream().collect(
    Collectors.groupingBy(x -> x, Collectors.counting()));
System.out.println("group by value, count " + countGrouped);

Map<Long, List<Integer>> groups = countGrouped.entrySet().stream()
    .filter(x -> x.getValue() >= 2)
    .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
    .collect(Collectors.groupingBy(Map.Entry::getValue, LinkedHashMap::new, 
        Collectors.mapping(Map.Entry::getKey, Collectors.toList())));

System.out.println("grouped " + groups);

Note-se que ao contrário do código anterior, agora a última operação de agrupamento irá também manter a ordem, o que resulta em

grouped {4=[3], 3=[1, 4]}

ou seja, os grupos são classificadas segundo descendente contagem.

Desde a contagem é a chave do mapa resultante, também podemos usar um mapa intrinsecamente ordenada como tipo e omitir a etapa de classificação:

Map<Long, List<Integer>> groups = countGrouped.entrySet().stream()
    .filter(x -> x.getValue() >= 2)
    .collect(Collectors.groupingBy(Map.Entry::getValue,
        () -> new TreeMap<>(Comparator.<Long>reverseOrder()),
        Collectors.mapping(Map.Entry::getKey, Collectors.toList())));

Os principais mentiras diferença no comportamento do mapa resultado após a operação de fluxo, por exemplo, se você inserir mais elementos a ele, como o TreeMapirá inserir novas chaves de acordo com a ordem descendente enquanto que LinkedHashMapirá acrescentar-los até o fim, mantendo a ordem de inserção.