Expresiones regulares simples de alto rendimiento de Java

Question

Parte del código en el que estoy trabajando usa un montón de expresiones regulares para buscar algunos patrones simples de cadena (por ejemplo, patrones como "foo [0-9] {3,4} bar") Actualmente, utilizamos Java Patterns compilados estáticamente y luego llamamos al Pattern#matcher para verificar si una cadena contiene una coincidencia con el patrón (no necesito la coincidencia, solo un booleano que indica si hay una coincidencia). Esto está causando una notable cantidad de asignación de memoria que está afectando el rendimiento.

¿Existe una mejor opción para la coincidencia de expresiones regulares de Java que sea más rápida o que al menos no asigne memoria cada vez que busque una cadena en un patrón?

Answer 1

Pruebe el método matcher.reset("newinputtext") para evitar crear nuevos mezcladores cada vez que llame a Pattern.matcher.

Answer 2

Puede intentar usar el método estático Pattern.matches() que simplemente devolverá el valor booleano. Eso no devolvería un objeto Matcher por lo que podría ayudar con los problemas de asignación de memoria.

Dicho esto, el patrón de expresión regular no sería precompilado, por lo que sería una cuestión de rendimiento vs recursos en el punto.

Answer 3

Si desea evitar la creación de un nuevo Matcher para cada patrón, utilice el método usePattern(), así:

Pattern[] pats = { 
    Pattern.compile("123"), 
    Pattern.compile("abc"), 
    Pattern.compile("foo") 
}; 
String s = "123 abc"; 
Matcher m = Pattern.compile("dummy").matcher(s); 
for (Pattern p : pats) 
{ 
    System.out.printf("%s : %b%n", p.pattern(), m.reset().usePattern(p).find()); 
} 

see the demo on Ideone

usted tiene que utilizar el método de coincidencias de reset() también, o find() solo buscará desde el punto donde terminó la partida anterior (suponiendo que la coincidencia fue exitosa).

Answer 4

Si espera menos del 50% de las líneas que coincidan con la expresión regular, primero puede tratar de probar por alguna subsecuencia través String.indexOf() que es aproximadamente de 3 a 20 veces más rápido para la secuencia simple en comparación con coincidencias de expresiones regulares:

if (line.indexOf("foo")>-1) && pattern.matcher(line).matches()) { 
    ... 

Si agrega a su código tales heurísticas, recuerde documentarlas siempre bien, y verificar el uso del generador de perfiles que el código es de hecho más rápido en comparación con el código simple.