Cómo usar expresiones regulares para hacer coincidir todo antes de cierto tipo de palabra

Question

Soy nuevo en las expresiones regulares.

¿Es posible para que coincida con todo antes de una palabra que se encuentra con un cierto criterio:

P. ej

Ésta es una prueba - - +++ Esta es una prueba

me gustaría que a encontrar una palabra que comienza con una mayúscula y el siguiente carácter es minúscula. Esto constituye una palabra correcta. Me gustaría borrar todo antes de esa palabra.

el ejemplo anterior se debe producir: Esta es una prueba

sólo quiero este tratamiento hasta que encuentra la palabra adecuada y luego se detiene.

Cualquier ayuda sería apreciada.

Gracias

Answer 1

Reemplazar

^.*?(?=[A-Z][a-z]) 

con la cadena vacía. Esto funciona para la entrada ASCII. Para entradas que no sean ASCII (Unicode, otros idiomas), se aplican diferentes estrategias.

Explicación

.*? Everything, until 
(?= followed by 
[A-Z] one of A .. Z and 
[a-z] one of a .. z 
) 

La variante de Unicode de Java sería la siguiente:

^.*?(?=\p{Lu}\p{Ll}) 

Answer 2

entonces usted puede hacer algo como esto

'.*([A-Z][a-z].*)\s*' 

.* matches anything 
([A-Z] #followed by an uper case char 
    [a-z] #followed by a lower case 
    .*) #followed by anything 
    \s* #followed by zeror or more white space 

¿Qué es lo que busca Creo que

Answer 3

Después de haber despertado un poco, no necesita borrar nada, o incluso crear un subgrupo, simplemente encuentre el patrón expresado en otras partes de las respuestas. Aquí está un ejemplo completo:

import java.util.regex.*; 

public class Test 
{ 
    public static void main(String args[]) 
    { 
     Pattern pattern = Pattern.compile("[A-Z][a-z].*"); 

     String original = "THIS IS A TEST - - +++ This is a test"; 
     Matcher match = pattern.matcher(original); 
     if (match.find()) 
     { 
      System.out.println(match.group()); 
     } 
     else 
     { 
      System.out.println("No match"); 
     }   
    } 
} 

EDIT: Respuesta original

Esto parece que está haciendo lo correcto:

import java.util.regex.*; 

public class Test 
{ 
    public static void main(String args[]) 
    { 
     Pattern pattern = Pattern.compile("^.*?([A-Z][a-z].*)$"); 

     String original = "THIS IS A TEST - - +++ This is a test"; 
     String replaced = pattern.matcher(original).replaceAll("$1"); 

     System.out.println(replaced); 
    } 
} 

Básicamente, el truco no es ignorar todo antes de la palabra adecuada - es para agrupar todo, desde la palabra adecuada en adelante, y reemplazar todo el texto con ese grupo.

Lo anterior fallaría con "*** FOO *** I am fond of peanuts" porque la "I" no se consideraría una palabra correcta. Si desea corregir eso, cambie [a-z] por [a-z \ s], lo que permitirá espacios en blanco en lugar de una letra.

Answer 4

([A-Z] [a-z].+)

coincidiría:

Este es un texto

Answer 5

Sé que mi opinión sobre esto en realidad no es tan popular por lo que ustedes pueden Me Down-voto en el olvido si se quiere, pero Tengo que despotricar un poco (y esto contiene una solución, simplemente no de la manera en que lo solicitó el cartel).

Realmente no entiendo por qué las personas van a expresiones regulares tan rápido.

He realizado una gran cantidad de análisis de cadenas (Utilizado para pantallas de menú raspado vt100) y nunca he encontrado un solo caso donde las Expresiones regulares hubieran sido mucho más fáciles que solo escribir código. (Quizás una pareja hubiera sido un poco más fácil, pero no mucho).

Entiendo que se supone que son más fáciles una vez que los conoces, pero ves a alguien hacer una pregunta como esta y te das cuenta de que no es fácil para cada programador echarle un vistazo. Si cuesta 1 programador en algún momento de la línea 10 minutos de reflexión, tiene una gran pérdida neta sobre solo codificarla, incluso si le tomó 5 minutos escribir 5 líneas.

Así que va a necesitar documentación, y si alguien que está en el mismo nivel se encuentra con ella, no podrá modificarla sin conocimiento fuera de su dominio, incluso con documentación.

Quiero decir que si el afiche tuviera que preguntar sobre un caso trivial, entonces simplemente no existe tal cosa como un caso trivial.

public String getRealText(String scanMe) { 
    for(int i=0 ; i < scanMe.length ; i++) 
     if(isUpper(scanMe[i]) && isLower(scanMe[i+1])) 
      return scanMe.subString(i); 
return null; } 

quiero decir que es de 5 líneas, pero es simple, fácil de leer, y más rápido que la mayoría (todos?) Analizadores de ER. Una vez que haya envuelto una expresión regular en un método y comentado, la diferencia de tamaño no se puede medir. La diferencia en el tiempo - bueno para el poster obviamente hubiera sido MUCHO menos tiempo - como podría ser para el próximo tipo que se encuentra con su código.

Y esta operación de cadena es uno de los que son aún más fácil en C con los punteros - y sería incluso más rápido ya que las funciones de prueba son macros en C

Por cierto, asegúrese de buscar para un espacio en la segunda ranura, no solo una variable en minúsculas, de lo contrario perderá líneas que comiencen con las palabras A o I.