el método coincide no funciona bien

No entiendo por qué con esta expresión regular el método devuelve falso;

Pattern.matches("\\bi", "an is"); 

el personaje i está en un límite de palabras!

En Java, matches bashs de emparejar un patrón con la cadena completa .

Esto es cierto para String.matches , Pattern.matches y Matcher.matches .

Si desea verificar si hay una coincidencia en algún lugar de una cadena, puede usar .*\bi.* . En este caso, como un literal de cadena Java, es ".*\\bi.*" .

enlaces de la API java.util.regex.Matcher

  • boolean matches() : intenta hacer coincidir toda la región con el patrón.

Qué .* Significa

Como se usa aquí, el punto . es un metacaracter regex que significa (casi) cualquier caracter. * es un metacaracter regex que significa “cero o más repetición de”. Entonces, por ejemplo, algo como A.*B coincide con A , seguido de cero o más de “cualquier” carácter, seguido de B ( ver en rubular.com ).

Referencias

  • regular-expressions.info/Repetition con Star and Plus y The Dot Matches (Casi) Cualquier personaje

Preguntas relacionadas

  • Diferencia entre .*? y .* para expresiones regulares

Tenga en cuenta que tanto el . y * (así como otros metacaracteres) pueden perder su significado especial según dónde aparezcan. [.*] es una clase de caracteres que coincide con un período literal . o un asterisco literal * . Precedido por una barra diagonal inversa también escapa metacaracteres, por lo que a\.b coincide con "ab" .

  • regular-expressions.info/Character Class y Literal Characters and Metacharacters

Problemas relacionados

Java no tiene endsWith basados ​​en endsWith , startsWith y contains . Todavía puede usar matches para lograr las mismas cosas de la siguiente manera:

  • matches(".*pattern.*") – ¿contiene una coincidencia del patrón en cualquier lugar?
  • matches("pattern.*") – ¿comienza con una coincidencia del patrón ?
  • matches(".*pattern") : ¿termina con una coincidencia del patrón ?

String API quick cheat sheet

Aquí hay una hoja de referencia rápida que enumera qué métodos están basados ​​en expresiones regulares y cuáles no:

  • Métodos no regex:
    • String replace(char oldChar, char newChar)
    • String replace(CharSequence target, CharSequence replacement)
    • boolean startsWith(String prefix)
    • boolean endsWith(String suffix)
    • boolean contains(CharSequence s)
  • Métodos Regex:
    • String replaceAll(String regex, String replacement)
    • String replaceFirst(String regex, String replacement)
    • String[] split(String regex)
    • boolean matches(String regex)

Toda la cadena tiene que coincidir si usa coincidencias:

 Pattern.matches(".*\\bi.*", "an is") 

Esto permite 0 o más caracteres antes y después. O:

 boolean anywhere = Pattern.compile("\\bi").matcher("an is").find(); 

le dirá si alguna subcadena coincide (es verdad en este caso). Como nota, la comstackción de expresiones regulares y su mantenimiento pueden mejorar el rendimiento.

No entiendo por qué Java decidió ir en dirección opuesta a los lenguajes como Perl que ha soportado regex de forma nativa durante años. Tiré el estándar Java Regex y comencé a usar mi propia versión de Regex lib para Java llamada MentaRegex . Vea a continuación cómo la expresión regular puede tener sentido en Java.

El método coincide devuelve un booleano que dice si tenemos una coincidencia regex o no.

 matches("Sergio Oliveira Jr.", "/oliveira/i" ) => true 

La coincidencia de método devuelve una matriz con los grupos coincidentes. Por lo tanto, no solo le dice si tiene una coincidencia o no, sino que también devuelve los grupos coincidentes en caso de que tenga una coincidencia.

 match("aa11bb22", "/(\\d+)/g" ) => ["11", "22"] 

El sub método le permite realizar sustituciones con expresiones regulares.

 sub("aa11bb22", "s/\\d+/00/g" ) => "aa00bb00" 

Compatible con expresiones regulares globales y case-insensitive.

 match("aa11bb22", "/(\\d+)/" ) => ["11"] match("aa11bb22", "/(\\d+)/g" ) => ["11", "22"] matches("Sergio Oliveira Jr.", "/oliveira/" ) => false matches("Sergio Oliveira Jr.", "/oliveira/i" ) => true 

Le permite cambiar el carácter de escape en caso de que no quiera ver tantas ‘\’.

 match("aa11bb22", "/(\\d+)/g" ) => ["11", "22"] match("aa11bb22", "/(#d+)/g", '#' ) => ["11", "22"]