En comparant les types génériques en Java, comment ignorer les plafonds si le type est une chaîne?

Question

J'ai un problème lors de la comparaison de type générique, j'ai une entrée et maintenant je dois comparer la clé avec une autre clé, donc sans penser que j'ai fait les égaux ...

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)

Mais le problème, évidemment, est que si j'ai une chaîne et que l'exclusion du cas de CAPS ne se produira pas .... equalsignorecase ne peut pas être utilisé bien sûr.

Alors, comment puis-je que cela fonctionne avec tous les types? Y compris les cordes avec des bouchons

Answer 1

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

Answer 2

S'il s'agit d'une véritable exigence, il existe deux solutions logiques qui me viennent à l'esprit ...

La première option consiste à convertir toutes les valeurs de clés de la carte en minuscules (ou majuscules) lorsque vous les insérez, puis vous n'aurez pas à vous soucier du cas dans la comparaison.

L'autre option consiste à utiliser un wrapper spécial pour chaque clé qui fait la méthode égale pour vous:

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

Answer 3

Meilleur moyen, utiliser instanceof mot-clé

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

Alternativement, si votre clé est Comparable, vous pouvez personnaliser votre Comparable faire face à l'insensibilité à la casse String valeur clé.

J'espère que ça aide.