Alternative à la table Guava

Question

Existe-t-il une alternative à Guava Tables qui utilise des primitives, au lieu de types génériques, comme clés?

Je souhaite utiliser des primitives pour éviter la mise en boîte automatique provoquée par l'utilisation de Java Numbers et des objets d'entrée supplémentaires créés par Java Maps.

J'ai roulé mon propre LongLongObjectTable de base en utilisant Trove TLongObjectMap, mais je préférerais utiliser une bibliothèque standard si elle est disponible.

private static class LongLongObjectTable<T> { 
    private final TLongObjectMap<TLongObjectMap<T>> backingMap = new TLongObjectHashMap<>(); 

    T get(final long rowKey, final long columnKey) { 
     final TLongObjectMap<T> map = this.backingMap.get(rowKey); 
     if (map == null) { 
      return null; 
     } 
     return map.get(columnKey); 
    } 

    void put(final long rowKey, final long columnKey, final T value) { 
     TLongObjectMap<T> map = this.backingMap.get(rowKey); 
     if (map == null) { 
      map = new TLongObjectHashMap<>(); 
      this.backingMap.put(rowKey, map); 
     } 
     map.put(columnKey, value); 
    } 

    Collection<T> values() { 
     final List<T> values = new ArrayList<T>(); 
     for (final TLongObjectMap<T> map : this.backingMap.valueCollection()) { 
      values.addAll(map.valueCollection()); 
     } 
     return values; 
    } 
} 

Answer 1

Pas vraiment. Le problème est que de telles implémentations ne sont pas imminentes (par définition) et devraient être définies une par une. Cela signifie une répétition importante et potentiellement beaucoup de permutations de collection possibles. Cela dit, d'autres langages autorisent cela en demandant au compilateur de générer du code pour les instances d'une collection avec le type T plutôt que d'utiliser type erasure, mais ce n'est pas la direction que java est allée. Le fait que vous puissiez utiliser des variantes auto-encadrées telles que Long ou Integer sur la collection existante est suffisant pour la grande majorité des cas, car le surcoût est relativement faible. En outre, les concepteurs de la bibliothèque standard préfèrent probablement le garder mince plutôt que de le polluer avec des variantes personnalisées supplémentaires.