private DListNode<Entry<K,V>> findNode(K key){
DListNode<Entry<K, V>> node = head;
while(node != null && !specialEquals(node.getElement().getKey(),key))
node = node.getNext();
return node;
}
private static boolean specialEquals(K key1, K key2) {
if( key1 instanceof String && key2 instanceof String ) {
return ((String) key1).equalsIgnoreCase((String) key2);
} else {
return key1.equals(key2);
}
}
Confrontando i tipi generici in Java, come ignorare i tappi se il tipo è una stringa?
-
29-07-2022 - |
Domanda
Ho un problema quando mi confronto il tipo generico, ho una voce e ora devo confrontare la chiave con un'altra chiave, quindi senza pensare di aver fatto gli uguali ...
private DListNode<Entry<K,V>> findNode(K key){
DListNode<Entry<K, V>> node = head;
while(node != null && !node.getElement().getKey().equals(key))
node = node.getNext();
return node;
}
! node.getElement (). getKey (). Equals (Key)
Ma il problema, ovviamente, è che se ho una stringa e l'esclusione del caso Caps non avverrà .... EqualsIgnoreCase non può essere utilizzato ovviamente.
Quindi, come posso farlo funzionare con ogni tipo? Comprese le corde con tappi
Soluzione
Altri suggerimenti
Se questo è un requisito reale, allora ci sono due soluzioni logiche che mi vengono in mente ...
La prima opzione è quella di convertire tutti i valori chiave nella mappa in minuscolo (o maiuscolo) quando li inserisci, e quindi non dovrai preoccuparti del caso nel confronto.
L'altra opzione è quella di utilizzare un wrapper speciale per ogni chiave che esegue il metodo uguale per te:
class CaseInsensitiveString {
private final String mystring;
public CaseInsensitiveString(String val) {
mystring = val;
}
public boolean equals(Object o) {
return o instanceof CaseSensitiveString
&& mystring.equalsIgnoreCase(((CaseInsensitiveString)o).getString())
}
public int hashCode() {
return mystring.tolowercase().hashCode();
}
public String toString() {
return mystring;
}
}
Modo migliore, uso instanceof
parola chiave
while (node != null && node.getKey() != null) {
if (key instanceof String) {
String sKey = (String)key;
if (node.getKey() instanceof String) {
String nodeKeyString = (String)node.getKey();
if (nodeKeyString.equalsIgnoreCase(sKey)) {
return node;
}
}
} else if (node.getKey().equals(key)) {
return node;
} else {
node = node.getNext();
}
}
In alternativa, se la chiave è Comparable
, puoi personalizzare il tuo Comparable
per affrontare i casi-insensibili String
valore chiave.
Spero che questo aiuti.