Appoggio appropriato di una distinzione tra maiuscole e minuscole

Question

Desidero implementare una mappa hash senza distinzione tra maiuscole e minuscole. Questa domanda di per sé non è nuova, ma volevo aggiungere funzionalità extra e non so quale direzione generale prendere. Voglio che il cliente sia in grado di fare qualcosa del genere:

boolean preserve_case = true; 
Map<String, MyClass> maplet = new CaseInsensitiveHashMap<MyClass>(preserve_case); // If the client enters true at construction, then the put, get, and remove methods should still be case insensitive, but the entry and key sets should preserve the case that the client used when calling put. 

maplet.put("FoO", my_class); 

MyClass bar = maplet.get("foo"); // Should return a reference to my_class 

Set<Entry<String, MyClass>> case_sensitive_set = maplet.entrySet(); // Since the client input true to preserve order, this entry set should be ["FoO"=my_class.toString()] 

posso gestire la maggior parte di questo abbastanza bene; Mi limito a tenere un HashMap sul backend. Quando un cliente inserisce qualcosa, prima di aggiungerlo alla mappa, inserisco la chiave in maiuscolo.

Sto solo facendo fatica a scrivere i metodi keySet() e entrySet(). Voglio che il set di voci restituite e il set di chiavi siano supportati dalla mappa, come lo standard con le mappe Java.

Tuttavia, l'unico modo che posso pensare di gestire è quello di creare una seconda struttura di dati di supporto, come un qualcosa preserved_case_map, che contiene il input.toUpperCase() => ingresso come coppie di valori chiave. Quando il client chiama lo entrySet() (o keySet()), è possibile creare il set di voci restituite eseguendo il ciclo attraverso lo preserved_case_map. Il problema qui è che il set di voci restituite non verrà modificato se apporto modifiche allo HashMap, a meno che non fraintenda qualcosa ...

Fammi sapere se questo ha un senso, o se sto contorcendo un semplice situazione.

Answer 1

È possibile utilizzare una TreeMap con comparatore senza distinzione tra maiuscole e minuscole. Il TreeMap utilizzerà il comparatore per confrontare le chiavi in ​​un modo case-insensitive:

Map<String, Integer> map = new TreeMap<>(String.CASE_INSENSITIVE_ORDER); 

    map.put("Foo", 1); 
    map.put("fOo", 2); 

    System.out.println(map.get("foo")); // prints 2 
    System.out.println(map.keySet()); // prints [Foo] 

Answer 2

Invece di memorizzare semplicemente il valore, memorizzare un KeyValuePair sia della chiave di input (che ha ancora la custodia fornita dall'utente) che del valore e utilizzare la chiave maiuscola come chiave.

Quando si estrae il valore, estrarlo dal KeyValuePair prima di restituirlo. È anche possibile recuperare il caso della chiave originale eseguendo la stessa ricerca con la chiave maiuscola e quindi estraendo la chiave originale.

Answer 3

Un modo è ereditare da HashMap<String, V>, quindi chiamare i metodi nella classe base dopo aver chiamato toUpperCase() sulle chiavi.

Tuttavia, è molto più facile da ignorare semplicemente il metodo hashCode() in MyClass (o qualsiasi altra cosa le classi che verrà utilizzato), e quindi utilizzare la classe standard HashMap<K, V>, senza implementare il proprio. Per esempio:

public int hashCode() { 
    return this.toString().toUperCase().hashCode(); 
} 

Se che mettere in una classe di base e quindi avere il vostro classi ereditano da essa, allora si avrà una soluzione DRY e molto semplice al tuo problema.

Answer 4

Per semplificare il wrapping di una mappa, è possibile utilizzare ForwardingMap dalle librerie Guava di Google ma questo è facoltativo.

Prima di mettere/ottenere qualcosa dalla mappa di supporto, avvolgere la chiave String in una classe che esegue l'override di hashCode()/equals() e utilizzare il wrapper come chiave nella mappa. Qualcosa di simile:

class KeyWrapper { 
    int hashCode() { 
     return actualStringKey.toUpperCase().hashCode() 
    } 
    boolean equals(Object o) {...} // compare case-insensitive 
} 

Se si ignorare keySet() è possibile creare un nuovo set e riempirlo con actualStringKeys.

Answer 5

Faccio qualcosa in questo modo per una cache mappata che ho scritto. Il nome è cambiato qui per riflettere la tua insensibilità al caso invece del mio caching, ma i concetti sono gli stessi.

Ciò fornirebbe una classe UncasedMap che potrebbe essere riutilizzata per contenere qualcosa, ma sarebbe limitata all'utilizzo di Stringhe come chiavi.

// Map that uses case insensitive strings as keys to any kind of element 
public class UncasedMap<V> extends HashMap<String, V> 
{ 
    private static final long serialVersionUID = 1L; 
    private Map<String, MappedObject> backingMap = new HashMap<String, MappedObject>(); 

    @Override 
    public V put(String key, V value) 
    { 
     MappedObject currentVal = backingMap.get(key.toUpperCase()); 
     backingMap.put(key.toUpperCase(), new MappedObject(key.toUpperCase(), value)); 
     return currentVal.getElement(); 

    } 
    @Override 
    public V get(Object key) 
    { 
     return backingMap.get(key.toString().toUpperCase()).getElement(); 
    } 

    // a private inner class of my case insensitive map, to wrap the callers element 
    private class MappedObject 
    { 
     private String key; 
     private String orig_key; 
     private V mapElement; 

     public MappedObject(String keyx, V elem) 
     { 
      this.orig_key = keyx; 
      this.key = keyx.toUpperCase(); 
      this.mapElement = elem; 
     } 

     public V getElement() 
     { 
      return this.mapElement; 
     } 
    } 
} 

Attuazione keySet() e emptySet() sarebbe più complicato, ma fatto lungo le stesse linee.

Answer 6

si potrebbe usare CaseInsensitiveMap da Apache Commons Collezioni.

http://commons.apache.org/proper/commons-collections/