So extrahieren Sie einen Teilstring mit Regex

Ich habe eine Zeichenfolge, die zwei einfache Anführungszeichen enthält, das 'Zeichen. Zwischen den einfachen Anführungszeichen stehen die Daten, die ich möchte.

Wie kann ich einen regulären Ausdruck schreiben, um "die gewünschten Daten" aus dem folgenden Text zu extrahieren?

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

Angenommen, Sie möchten den Teil zwischen einfachen Anführungszeichen verwenden, verwenden Sie diesen regulären Ausdruck mit Matcher:

"'(.*?)'"

Beispiel:

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));
}

Ergebnis:

die Daten, die ich will

Sie brauchen dafür keinen regulären Ausdruck.

Fügen Sie Ihrem Projekt apache commons lang hinzu ( http://commons.apache.org/proper/commons-lang/ ), und verwenden Sie dann:

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));
        }

    }
}

Dafür gibt es einen einfachen Einzeiler:

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

Wenn Sie die übereinstimmende Gruppe optional machen, wird auch berücksichtigt, dass Anführungszeichen nicht gefunden werden, indem in diesem Fall ein Leerzeichen zurückgegeben wird.

Siehe Live-Demo .

Weil Sie auch Scala angekreuzt haben, eine Lösung ohne Regex, die sich leicht mit Zeichenfolgen in mehreren Anführungszeichen befasst:

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");

wie in Javascript:

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

Der eigentliche reguläre Ausdruck ist: /'([^']+)'/

Wenn Sie den nicht gierigen Modifikator verwenden (wie in einem anderen Beitrag beschrieben), ist dies folgendermaßen:

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

es ist sauberer.

In 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];

Siehe Live-Demo

Apache Commons Lang bietet eine Vielzahl von Hilfsprogrammen für die java.lang-API, insbesondere Methoden zur Manipulation von Zeichenfolgen. In Ihrem Fall sind die Start- und End-Teilzeichenfolgen identisch. Rufen Sie einfach die folgende Funktion auf.

StringUtils.substringBetween(String str, String tag)

Ruft den String ab, der zwischen zwei Instanzen desselben Strings verschachtelt ist .

Wenn die Start- und Endunterzeichenfolgen unterschiedlich sind, verwenden Sie die folgende überladene Methode.

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

Ruft den String ab, der zwischen zwei Strings verschachtelt ist.

Wenn Sie alle Instanzen der übereinstimmenden Teilzeichenfolgen möchten, verwenden Sie,

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

Durchsucht einen String nach Teilzeichenfolgen, die durch ein Start- und ein End-Tag begrenzt sind, und gibt alle übereinstimmenden Teilzeichenfolgen in einem Array zurück .

Für das betreffende Beispiel werden alle Instanzen des passenden Teilstrings abgerufen

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

Sie können diese while-Schleife verwenden, um alle übereinstimmenden Teilzeichenfolgen im Array zu speichern, wenn Sie verwenden

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

Sie erhalten einen Übereinstimmungs-Teilstring, mit dem Sie alle Übereinstimmungs-Teilzeichenfolgen abrufen können

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);

hinzufügen apache.commons Abhängigkeit von Ihrem pom.xml

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

Und unten Code funktioniert.

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

Einige, wie die Gruppe (1) für mich nicht funktioniert hat. Ich habe Gruppe (0) verwendet, um die URL-Version zu finden.

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";