Comparación de tipos genéricos en Java, ¿cómo ignorar las tapas si el tipo es una cadena?

Question

Tengo un problema al comparar el tipo genérico, tengo una entrada y ahora tengo que comparar la clave con otra clave, así que sin pensar que hice los iguales ...

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)

Pero el problema, obviamente, es que si tengo una cadena y la exclusión del caso CAPS no sucederá ... iguales de igualdad de información no se puede usar, por supuesto.

Entonces, ¿cómo puedo hacer que esto funcione con cada tipo? Incluyendo las cuerdas con tapas

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

Si este es un requisito real, entonces hay dos soluciones lógicas que vienen a la mente ...

La primera opción es simplemente convertir todos los valores clave en el mapa a minúsculas (o mayúsculas) cuando los inserte, y luego no tendrá que preocuparse por el caso en comparación.

La otra opción es usar un envoltorio especial para cada clave que haga el método igual para usted:

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

La mejor manera, usar instanceof palabra clave

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

Alternativamente, si su clave es Comparable, puedes personalizar tu Comparable para tratar con caso de insensible String valor clave.

Espero que esto ayude.