Convert a HashMap ito HashMap

Question

Collectors.counting() returns long values for each key in this method:

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

Is there a way to cast or convert the resulting Map from Map to Map?

Direct casting gives this exception:

Type mismatch: cannot convert from Map to Map

Note: The implementation of my class guarantees that cards has five objects in it, so there is no chance of overflow.

user_1366871 · Answer

Try the following:

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

Instead of Collectors.counting() use Collectors.summingInt(x -> 1) so that you get immediately the value as an Integer.

user_13279831 · Answer

Another way to get Map is to use toMap collector along with Integer::sum method reference as a merge function:

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

user_642706 · Answer

Both the Answer by dreamcrash and the Answer by Alex Rudenko seem correct. Here is example code I wrote to try both approaches.

The Card class.

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

In Java 16 and later, we could reduce that Card class to a brief record. And in the code further down we would change getRankNumber to the implicit getter method rankNumber. The Suit enum would move to its own .java file.

package work.basil.example.cardgame;

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

The CastingStream class to collect those cards.

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

When run.

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}

Convert a HashMap<Integer, Long> ito HashMap<Integer, Integer>

3 Answers