¿Cuál es la forma más rápida de comparar cadenas en Java?

Question

¿Cuál es la comparación más rápida de dos cadenas en Java?

¿Hay algo más rápido que los iguales?

EDITAR: No puedo ayudar mucho para aclarar el problema.

Tengo dos cuerdas que están ordenadas alfabéticamente y exactamente el mismo tamaño

Ejemplo: abbcee y abcdee

Las cadenas pueden ser de largo hasta 30 caracteres

Answer 1

No espero que Sun Oracle aún no ha optimizado el estándar String#equals() al máximo. Por lo tanto, espero que ya sea la forma más rápida. Eche un vistazo en su fuente si quiere saber cómo lo implementaron. Aquí hay un extracto:

public boolean equals(Object anObject) { 
    if (this == anObject) { 
     return true; 
    } 
    if (anObject instanceof String) { 
     String anotherString = (String)anObject; 
     int n = count; 
     if (n == anotherString.count) { 
      char v1[] = value; 
      char v2[] = anotherString.value; 
      int i = offset; 
      int j = anotherString.offset; 
      while (n-- != 0) { 
       if (v1[i++] != v2[j++]) 
        return false; 
      } 
      return true; 
     } 
    } 
    return false; 
} 

Answer 2

Depende de lo que necesite. Creo que equals() está realmente optimizado, pero quizás necesites algo más rápido que equals(). Eche un vistazo al this post.

Answer 3

Como siempre, deberá comparar su aplicación/entorno. Y a menos que ya hayas perfilado e idetificado esto como un cuello de botella de rendimiento, probablemente no importará ("la optimización prematura es la raíz de todo mal").

Una vez dicho esto:

a.equals (B) es muy rápido para cuerdas. Probablemente sea uno de los códigos más estrechamente optimizados en la plataforma Java. Me sorprendería mucho si puede encontrar una forma más rápida de comparar dos cadenas arbitrarias.

Hay casos especiales donde se puede trucos y usar (a == b) con seguridad, por ejemplo, si sabe que both Strings are interned (y, por lo tanto, la identidad del valor implica la identidad del objeto). En ese caso, puede ser un poco más rápido que a.equals (b), pero nuevamente esto depende de la implementación del compilador/JVM. Y es muy fácil de disparar en el pie si usted no sabe lo que está haciendo .....

Answer 4

Si usted puede demostrar que es un importante cuello de botella, lo que me sorprende, se podría tratar

s1.hashCode() == s2.hashCode() && s1.equals(s2) 

podría ser un poco más rápido. Puede que no.

Answer 5

comparar cadenas de igual longitud más rápido utilizando el código hash:

public static boolean equals(final String s1, final String s2) { 
return s1 != null && s2 != null && s1.hashCode() == s2.hashCode() 
    && s1.equals(s2); 
} 

puede probarlo, mis resultados son de 4.000.000 comparar las operaciones incluidas cadenas idénticas, iguales y diferentes:

String.equals(String): 177081939 
equals(String, String): 44153608 

Nota : El cálculo del hashCode de un nuevo objeto de cadena requiere cierto tiempo de cálculo y luego el hashCode se almacena en el objeto. Por lo tanto, mi mejora sugerida solo será más rápida que la comparación predeterminada si los objetos de cadena se reutilizan.En mi aplicación, estoy usando constantes de cadenas y cadenas de tiendas en colecciones. Las comparaciones múltiples de cadenas usando mi método son más rápidas para mí, pero puede que no sean en general.

Si el método se utiliza con nuevas cadenas todo el tiempo como compare("a", "b"), no será una mejora.

Así que la manera más rápida de comparar cadenas depende de:

• Ya sea que sus objetos de cadena se vuelven a utilizar (como de una colección) o son siempre nuevas (como el de un flujo de entrada)
• Ya sea que su cadenas tienen diferentes longitudes
• Ya sea que sus cadenas difieren al principio o al final de la cadena
• Su estilo de programación, la cantidad de constantes se utilizan
• La utilización del String.intern()

Haciendo caso omiso de estos hechos, la mayoría de los programas va a estar bien con String.equals().

Answer 6

I tenían tries diferentes combinaciones para la comparación de cadenas (code here):

1. s1.equals(s2) 
2. s1.length() == s2.length() && s1.hashCode() == s2.hashCode() && s1.equals(s2) 
3. s1.hashCode() == s2.hashCode() && s1.equals(s2); 
4. s1.length() == s2.length() && s1.equals(s2); 

que solía cadenas de longitud 40 caracteres, en 10000000000L iteraciones y antes de cualquier iteración I reinicializa las cuerdas.

por la igualdad de las picaduras que tengo:

equal: 2873 milis ??? 
equal: 21386 milis 
equal: 7181 milis 
equal: 2710 milis ??? 

para mismas cadenas de tamaño, pero la última con caracteres diferentes que tengo:

different: 3011 milis 
different: 23415 milis 
different: 6924 milis 
different: 2791 milis 

de diferentes tamaños, casi mismas cadenas, pero con un carácter añadido al final de S2:

different size: 3167 milis 
different size: 5188 milis 
different size: 6902 milis 
different size: 2951 milis 

me parece que lo mejor es utilizar una primera STRI ng.length() comparación antes de igual().

Pero esto no importará casi en absoluto porque este es el caso donde tengo 10^10 comparaciones de cuerdas con 40 caracteres de longitud y lo que es extraño para mí es el caso donde para cadenas iguales tengo una mejor velocidad cuando compare la longitud de la cuerda primero.

Answer 7

Respuesta simple

String.equals(Object)

Estoy bastante seguro (this answer has some references) y es muy probable que el JIT tendrá un intrínseco para String#equals, lo que significa que sería capaz de reemplazar la llamada con especialmente diseñado código de máquina para la arquitectura en la que se está ejecutando su JVM.