Inverse de Guava HashBiMap avec plusieurs clés pointant sur une valeur

Question

J'utilise une HashMap pour associer plusieurs objets joueurs à un seul objet de jeu.

Je veux être en mesure d'obtenir les joueurs associés à un certain jeu. Par conséquent, j'ai pensé utiliser HashBiMap de Guava avec des joueurs comme des clés, et des jeux comme des valeurs, puis prendre l'inverse pour trouver des joueurs associés aux jeux.

Est-ce que quelqu'un sait si c'est possible? L'inverse renvoie un autre HashBiMap et à cause des clés en double, j'aurais vraiment besoin d'un multimap.

Des pensées?

Answer 1

J'utiliserais probablement plus d'une structure de données.

Pour lever tous les joueurs dans un jeu:

Map<Game, Set<Player>> gamePlayers = new HashMap<>(); 

Si vous avez besoin de trouver le jeu un certain joueur, vous pouvez aussi:

Map<Player, Game> playersGames = new HashMap<>(); 

vous aurez donc avoir

public void addPlayerToGame(Player player, Game game) { 
    gamePlayers.computeIfAbsent(game,() -> new TreeSet<>()).add(player); 
    playersGames.put(player, game); 
} 

Answer 2

Vous pouvez utiliser CQEngine:

IndexedCollection<GamePlayer> gamePlayers = new ConcurrentIndexedCollection<>(); 
SimpleAttribute<GamePlayer, Game> gameAttribute = attribute(GamePlayer::getGame); 
SimpleAttribute<GamePlayer, Player> playerAttribute = attribute(GamePlayer::getPlayer); 
gamePlayers.addIndex(HashIndex.onAttribute(gameAttribute)); 
gamePlayers.addIndex(HashIndex.onAttribute(playerAttribute)); 

Game spades = new Game("Spades"); 
Game hearts = new Game("Hearts"); 
Game rummy = new Game("Rummy"); 
Player joe = new Player("Joe", 23); 
Player mary = new Player("Mary", 24); 
Player jane = new Player("Jane", 19); 
Player charles = new Player("Charles", 56); 
Player daniel = new Player("Daniel", 29); 

gamePlayers.add(new GamePlayer(hearts, joe)); 
gamePlayers.add(new GamePlayer(hearts, mary)); 
gamePlayers.add(new GamePlayer(hearts, jane)); 
gamePlayers.add(new GamePlayer(hearts, charles)); 
gamePlayers.add(new GamePlayer(spades, charles)); 
gamePlayers.add(new GamePlayer(spades, jane)); 
gamePlayers.add(new GamePlayer(spades, daniel)); 
gamePlayers.add(new GamePlayer(spades, mary)); 
gamePlayers.add(new GamePlayer(rummy, charles)); 
gamePlayers.add(new GamePlayer(rummy, jane)); 

System.out.println("Spades' players:"); 
for (GamePlayer spadesGamePlayer : gamePlayers.retrieve(equal(gameAttribute, spades))) { 
    Player player = spadesGamePlayer.getPlayer(); 
    System.out.println(" - " + player.getName() + " (age " + player.getAge() + ")"); 
} 
System.out.println(); 
System.out.println("Mary's games:"); 
for (GamePlayer maryGamePlayer : gamePlayers.retrieve(equal(playerAttribute, mary))) { 
    Game game = maryGamePlayer.getGame(); 
    System.out.println(" - " + game.getName()); 
} 

Sortie:

Spades' players: 
    - Daniel (age 29) 
    - Jane (age 19) 
    - Mary (age 24) 
    - Charles (age 56) 

Mary's games: 
    - Hearts 
    - Spades 

Answer 3

Si vous avez des joueurs mis en correspondance avec des jeux en Map (non BiMap, puisque les joueurs de couple peut être dans le même jeu), vous pouvez utiliser Multimaps#forMap vue de goyave et Multimaps#invertFrom pour atteindre ce que vous et veulent avoir des jeux avec collection de joueurs par match (notez que les valeurs invertFrom copies, donc si vous mettez à jour playersGames, gamesPlayers ne changera pas):

static Map<Player, Game> playersGames; 

static { 
    final Game game1 = new Game(); 
    final Game game2 = new Game(); 
    final Game game3 = new Game(); 
    playersGames = ImmutableMap.of(
      new Player(), game1, 
      new Player(), game1, 
      new Player(), game2, 
      new Player(), game2, 
      new Player(), game3 
    ); 
    // {Player1=game1, Player2=game1, Player3=game2, Player4=game2, Player5=game3} 
} 

static Multimap<Game, Player> gamePlayers = Multimaps.invertFrom(
     Multimaps.forMap(playersGames), 
     ArrayListMultimap.create()); // or any other Multimap implementation 
// {game2=[Player3, Player4], game3=[Player5], game1=[Player1, Player2]}