转换一个HashMap<Integer，Long> ito HashMap<Integer，Integer>

Question

Collectors.counting()为此方法中的每个键返回long值：

private static Map<Integer, Long> countDuplicates(HashSet<Card> cards) {
    return cards.stream().collect(Collectors.groupingBy(Card::getRankNumber, Collectors.counting()));
}

是否有方法将结果Map从Map<Integer, Long>转换为Map<Integer, Integer>？

直接铸造使此例外情况出现：

Type mismatch: cannot convert from Map<Integer,Integer> to Map<Integer,Long>

注释：类的实现保证cards中有五个对象，因此没有溢出的可能性.

Answer 1

尝试以下几点：

private static Map<Integer, Integer> countDuplicates(HashSet<Card> cards) {
    return cards.stream()
                .collect(Collectors.groupingBy(Card::getRankNumber, Collectors.summingInt(x -> 1)));
}

不要使用Collectors.counting()，而是使用Collectors.summingInt(x -> 1)，这样您就可以立即获得作为整数的值。

Answer 2

获取Map<Integer, Integer>的另一种方法是使用toMap收集器和Integer::sum 方法参考作为合并函数：

private static Map<Integer, Integer> countDuplicates(HashSet<Card> cards) {
    return cards.stream()
                .collect(Collectors.toMap(Card::getRankNumber, x -> 1, Integer::sum));
}

Answer 3

梦中的答案和亚历克斯·鲁登科的答复似乎都是正确的。下面是我为尝试这两种方法而编写的示例代码。

Card类。

package work.basil.example;

import java.util.Objects;

public class Card
{
    public enum Suit
    {
        CLUB, DIAMOND, HEART, SPADE
    }

    // -------------|  Member fields  |-----------------------
    private Suit suit;
    private String name;
    private Integer rankNumber;

    // -------------|  Constructors  |-----------------------
    public Card ( Suit suit , String name , Integer rankNumber )
    {
        Objects.requireNonNull( suit );
        Objects.requireNonNull( name );
        Objects.requireNonNull( rankNumber );
        this.suit = suit;
        this.name = name;
        this.rankNumber = rankNumber;
    }

    // -------------|  Getters  |-----------------------
    public String getName ( ) { return this.name; }

    public Integer getRankNumber ( ) { return this.rankNumber; }


    // -------------|  Object methods  |-----------------------

    @Override
    public String toString ( )
    {
        return "Card{ " +
                "suit=" + suit +
                " | name='" + name + '\'' +
                " | rankNumber=" + rankNumber +
                " }";
    }

    @Override
    public boolean equals ( Object o )
    {
        if ( this == o ) return true;
        if ( o == null || getClass() != o.getClass() ) return false;
        Card card = ( Card ) o;
        return suit == card.suit && getName().equals( card.getName() ) && getRankNumber().equals( card.getRankNumber() );
    }

    @Override
    public int hashCode ( )
    {
        return Objects.hash( suit , getName() , getRankNumber() );
    }
}

在Java16和更高版本中，我们可以将这个Card类简化为一个简短的record。在下面的代码中，我们将getRankNumber更改为隐式getter方法rankNumber。Suit枚举将移动到它自己的.java文件中。

package work.basil.example.cardgame;

public record Card( Suit suit , String name , Integer rankNumber )
{
}

收集这些卡片的CastingStream类。

package work.basil.example;

import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

public class CastingStream
{
    public static void main ( String[] args )
    {
        CastingStream app = new CastingStream();
        app.demo();
    }

    private void demo ( )
    {
        Set < Card > cards = Set.of(
                new Card( Card.Suit.HEART , "Ten" , 10 ) ,
                new Card( Card.Suit.SPADE , "Ten" , 10 ) ,
                new Card( Card.Suit.HEART , "Queen" , 12 )
        );

        // Code taken from Question. https://stackoverflow.com/q/65910153/642706
        Map < Integer, Long > countDuplicatesLong =
                cards
                        .stream()
                        .collect(
                                Collectors.groupingBy(
                                        Card :: getRankNumber ,
                                        Collectors.counting()
                                )
                        );

        // Code taken from Answer by dreamcrash. https://stackoverflow.com/a/65910215/642706
        Map < Integer, Integer > countDuplicatesIntegerBySummingInt =
                cards
                        .stream()
                        .collect(
                                Collectors.groupingBy(
                                        Card :: getRankNumber ,
                                        Collectors.summingInt( x -> 1 )
                                )
                        );

        // Code taken from Answer by Alex Rudenko. https://stackoverflow.com/a/65910400/642706
        Map < Integer, Integer > countDuplicatesIntegerBySumMethodReference =
                cards
                        .stream()
                        .collect(
                                Collectors.toMap( Card :: getRankNumber ,
                                        x -> 1 ,
                                        Integer :: sum
                                )
                        );


        System.out.println( "cards = " + cards );
        System.out.println( "countDuplicatesLong = " + countDuplicatesLong );
        System.out.println( "countDuplicatesIntegerBySummingInt = " + countDuplicatesIntegerBySummingInt );
        System.out.println( "countDuplicatesIntegerBySumMethodReference = " + countDuplicatesIntegerBySumMethodReference );
    }
}

跑的时候。

cards = [Card{ suit=HEART | name='Queen' | rankNumber=12 }, Card{ suit=HEART | name='Ten' | rankNumber=10 }, Card{ suit=SPADE | name='Ten' | rankNumber=10 }]
countDuplicatesLong = {10=2, 12=1}
countDuplicatesIntegerBySummingInt = {10=2, 12=1}
countDuplicatesIntegerBySumMethodReference = {10=2, 12=1}