Wie man generische Typen in Java verglichen, wie kann man die Kappen ignorieren, wenn der Typ eine Zeichenfolge ist?

Question

Ich habe ein Problem beim Vergleich generischer Typ, ich habe einen Eintrag und jetzt muss ich den Schlüssel mit einem anderen Schlüssel vergleichen. Ohne zu denken, dass ich die Gleichen gemacht habe ...

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 (Schlüssel)

Das Problem ist jedoch offensichtlich, dass, wenn ich eine Zeichenfolge habe und der Caps -Fallausschluss nicht passieren wird ... EqualSignoreCase kann natürlich nicht verwendet werden.

Wie kann ich das dazu bringen, mit jedem Typ zu arbeiten? Einschließlich der Saiten mit Kappen

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

Wenn dies eine echte Anforderung ist, gibt es zwei logische Lösungen, die mir in den Sinn kommen.

Die erste Option besteht darin, einfach alle Schlüsselwerte in der Karte in Kleinbuchstaben (oder Großbuchstaben) zu konvertieren, wenn Sie sie einfügen, und dann müssen Sie sich keine Sorgen um den Fall im Vergleich machen.

Die andere Option besteht darin, einen speziellen Wrapper für jeden Schlüssel zu verwenden, der die Equals -Methode für Sie ausführt:

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

Bester Weg, verwenden Sie instanceof Stichwort

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

Alternativ, wenn Ihr Schlüssel ist Comparable, Sie können Ihre anpassen Comparable Um mit Fall unempfindlich umzugehen String Schlüsselwert.

Ich hoffe das hilft.