Comment extraire une sous-chaîne à l'aide de regex

J'ai une chaîne qui contient deux guillemets simples, le 'caractère. Entre les guillemets simples se trouvent les données que je veux.

Comment puis-je écrire une expression régulière pour extraire "les données que je veux" du texte suivant?

mydata = "some string with 'the data i want' inside";

En supposant que vous vouliez la partie entre guillemets simples, utilisez cette expression régulière avec un Matcher:

"'(.*?)'"

Exemple:

String mydata = "some string with 'the data i want' inside";
Pattern pattern = Pattern.compile("'(.*?)'");
Matcher matcher = pattern.matcher(mydata);
if (matcher.find())
{
    System.out.println(matcher.group(1));
}

Résultat:

les données que je veux

Vous n'avez pas besoin de regex pour cela.

Ajoutez apache commons lang à votre projet ( http://commons.apache.org/proper/commons-lang/ ), puis utilisez:

String dataYouWant = StringUtils.substringBetween(mydata, "'");

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile(".*'([^']*)'.*");
        String mydata = "some string with 'the data i want' inside";

        Matcher matcher = pattern.matcher(mydata);
        if(matcher.matches()) {
            System.out.println(matcher.group(1));
        }

    }
}

Il existe un simple revêtement pour cela:

String target = myData.replaceAll("[^']*(?:'(.*?)')?.*", "$1");

En rendant le groupe de correspondance facultatif, cela répond également aux citations non trouvées en retournant un blanc dans ce cas.

Voir la démo en direct .

Parce que vous avez également coché Scala, une solution sans regex qui gère facilement plusieurs chaînes entre guillemets:

val text = "some string with 'the data i want' inside 'and even more data'"
text.split("'").zipWithIndex.filter(_._2 % 2 != 0).map(_._1)

res: Array[java.lang.String] = Array(the data i want, and even more data)

String dataIWant = mydata.replaceFirst(".*'(.*?)'.*", "$1");

comme en javascript:

mydata.match(/'([^']+)'/)[1]

l'expression rationnelle réelle est: /'([^']+)'/

si vous utilisez le modificateur non gourmand (selon un autre post) c'est comme ça:

mydata.match(/'(.*?)'/)[1]

c'est plus propre.

À Scala,

val ticks = "'([^']*)'".r

ticks findFirstIn mydata match {
    case Some(ticks(inside)) => println(inside)
    case _ => println("nothing")
}

for (ticks(inside) <- ticks findAllIn mydata) println(inside) // multiple matches

val Some(ticks(inside)) = ticks findFirstIn mydata // may throw exception

val ticks = ".*'([^']*)'.*".r    
val ticks(inside) = mydata // safe, shorter, only gets the first set of ticks

String dataIWant = mydata.split("'")[1];

Voir la démo en direct

Apache Commons Lang fournit une multitude d'utilitaires d'assistance pour l'API java.lang, notamment les méthodes de manipulation de chaînes. Dans votre cas, les sous-chaînes de début et de fin sont les mêmes, il suffit donc d'appeler la fonction suivante.

StringUtils.substringBetween(String str, String tag)

Obtient la chaîne imbriquée entre deux instances de la même chaîne .

Si les sous-chaînes de début et de fin sont différentes, utilisez la méthode surchargée suivante.

StringUtils.substringBetween(String str, String open, String close)

Obtient la chaîne imbriquée entre deux chaînes.

Si vous voulez toutes les instances des sous-chaînes correspondantes, utilisez alors,

StringUtils.substringsBetween(String str, String open, String close)

Recherche dans une chaîne des sous-chaînes délimitées par une balise de début et de fin, renvoyant toutes les sous-chaînes correspondantes dans un tableau .

Pour l'exemple en question pour obtenir toutes les instances de la sous-chaîne correspondante

String[] results = StringUtils.substringsBetween(mydata, "'", "'");

vous pouvez utiliser cette i boucle while pour stocker toutes les sous-chaînes de correspondance dans le tableau si vous utilisez

if (matcher.find()) { System.out.println(matcher.group(1)); }

vous obtiendrez des sous-chaînes de correspondance afin que vous puissiez l'utiliser pour obtenir toutes les sous-chaînes de correspondances

Matcher m = Pattern.compile("[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+").matcher(text);
   // Matcher  mat = pattern.matcher(text);
    ArrayList<String>matchesEmail = new ArrayList<>();
        while (m.find()){
            String s = m.group();
            if(!matchesEmail.contains(s))
                matchesEmail.add(s);
        }

    Log.d(TAG, "emails: "+matchesEmail);

ajouter la dépendance apache.commons à votre pom.xml

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-io</artifactId>
    <version>1.3.2</version>
</dependency>

Et le code ci-dessous fonctionne.

StringUtils.substringBetween(String mydata, String "'", String "'")

Certains comment le groupe (1) n'a pas fonctionné pour moi. J'ai utilisé le groupe (0) pour trouver la version URL.

Pattern urlVersionPattern = Pattern.compile("\\/v[0-9][a-z]{0,1}\\/");
Matcher m = urlVersionPattern.matcher(url);
if (m.find()) { 
    return StringUtils.substringBetween(m.group(0), "/", "/");
}
return "v0";