Obtenir le texte qui suit, après la correspondance de la regex

Je suis nouveau à l'aide de Regex, j'ai été en passant par un râteau de tutoriels mais je n'ai pas trouvé un qui s'applique à ce que je veux faire,

Je veux à la recherche de quelque chose, mais qui reviennent tout ce qui suit, mais pas la chaîne de recherche lui-même

par exemple "Certains boiteux phrase qui est génial"

de la recherche pour "phrase"

retour "qui est génial"

Toute aide serait grandement appréciée

C'est ma regex jusqu'à présent

sentence(.*)

mais il retourne: phrase qui est génial

Pattern pattern = Pattern.compile("sentence(.*)");

Matcher matcher = pattern.matcher("some lame sentence that is awesome");

boolean found = false;
while (matcher.find())
{
    System.out.println("I found the text: " + matcher.group().toString());
    found = true;
}
if (!found)
{
    System.out.println("I didn't find the text");
}

Quel est votre appel? Êtes-vous à l'aide de Matcher?
Je suis en utilisant le comparateur et le modèle
... et on a quand même envie de voir votre code Java dans afin de les aider à évaluer ce qui est mauvais.
System.out.println("I found the text: " + "some lame sentance that is aweomse".substring(end()));
+1 si vous êtes un nazi de la grammaire comme moi
Nazi doit disposer d'un capital N...

InformationsquelleAutor Scott | 2011-02-15

java regex

88

Vous pouvez le faire avec un "expression régulière" comme vous l'avez demandé dans un commentaire:
```
(?<=sentence).*
```
(?<=sentence) est un positif lookbehind affirmation. Cela correspond à une certaine position dans la chaîne, à savoir à une position juste après le texte sentence, sans texte lui-même partie du match. Par conséquent, (?<=sentence).* correspond à tout le texte après sentence.

C'est une jolie caractéristique de regex. Toutefois, en Java, cela ne fonctionne que pour de longueur finie de sous-expressions, j'. e. (?<=sentence|word|(foo){1,4}) est légal, mais (?<=sentence\s*) ne l'est pas.
- caractéristique très cool en effet!
- Vous dites qu'il ne devrait pas inclure l'lookbehind affirmation. Donc je suppose que c' ".*(?<=phrase)" devrait revenir le tout jusqu'à, mais ne comportant pas de "phrase". Mais il ne le fait pas, il retourne "phrase" ainsi. Ce qui me manque?
- C'est parce que c'est un lookderrière assertion. .* correspond à n'importe quel texte, puis (?<=...) regarde en arrière pour le mot sentence, affirmant dans ce cas que le match se termine avec le mot. Si vous souhaitez vous arrêter avant que word, vous devez regarder avant: .*(?=sentence) correspond à tout texte qui est suivie par sentence.
InformationsquelleAutor Tim Pietzcker
16

Votre regex "sentence(.*)" est droit. Pour récupérer le contenu du groupe entre parenthèses, vous pouvez appeler:
```
Pattern p = Pattern.compile( "sentence(.*)" );
Matcher m = p.matcher( "some lame sentence that is awesome" );
if ( m.find() ) {
   String s = m.group(1); //" that is awesome"
}
```
Notez l'utilisation de m.find() dans ce cas (les tentatives pour trouver n'importe où sur la chaîne) et pas m.matches() (échouerait à cause du préfixe "certains boiteux"; dans ce cas, la regex aurait besoin d'être ".*sentence(.*)")
- Merci, Mais si j'ai juste envie de revenir "c'est génial"
- Merci homme, cela a très bien fonctionné, j'espérais qu'il y avait un moyen de le faire avec l'expression régulière, si je ne peux pas trouver un moyen de le faire de cette manière, ce sera le travail aswell
- Probablement une mauvaise idée d'ajouter un "(.*)" à la fin de la regexp pour la performance...
InformationsquelleAutor st.never
8

si Matcher est initialisé avec str, après le match, vous pouvez obtenir la partie après le match avec
```
str.substring(matcher.end())
```
Exemple De Code:
```
final String str = "Some lame sentence that is awesome";
final Matcher matcher = Pattern.compile("sentence").matcher(str);
if(matcher.find()){
    System.out.println(str.substring(matcher.end()).trim());
}
```
De sortie:

qui est génial
- matcher.find() est nécessaire avant cela, de l'OMI.
- c'est ce que j'ai écrit: "après le match". Ajout d'un exemple de code pour illustrer
InformationsquelleAutor Sean Patrick Floyd
1

Vous devez utiliser le groupe(int) de votre comparateur de groupe(0) est l'ensemble du match, et le groupe(1) est le premier groupe que vous avez marqué. Dans l'exemple que vous spécifiez, groupe(1) c'est ce qui vient après "phrase".

InformationsquelleAutor Rami C
1

Vous avez juste besoin de mettre "du groupe(1)" au lieu de "groupe de()" dans la ligne suivante et le retour sera celui que vous attendiez:
```
System.out.println("I found the text: " + matcher.group(**1**).toString());
```
InformationsquelleAutor Ricardo Ferreira

Vous devez vous connecter pour publier un commentaire.