Jak wyodrębnić podciąg za pomocą wyrażenia regularnego

Mam ciąg znaków, który zawiera dwa pojedyncze cudzysłowy - 'znak. Pomiędzy pojedynczymi cudzysłowami znajdują się dane, które chcę.

Jak napisać wyrażenie regularne, aby wyodrębnić „dane, które chcę” z następującego tekstu?

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

Zakładając, że chcesz część między pojedynczymi cudzysłowami, użyj tego wyrażenia regularnego z Matcher:

"'(.*?)'"

Przykład:

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

Wynik:

dane, które chcę

Nie potrzebujesz do tego wyrażenia regularnego.

Dodaj apache commons lang do swojego projektu ( http://commons.apache.org/proper/commons-lang/ ), a następnie użyj:

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

    }
}

Jest w tym prosty prosty linijka:

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

Jeśli opcjonalna grupa dopasowywania będzie opcjonalna, będzie to również uwzględniać cytaty, których nie można znaleźć, zwracając w tym przypadku spację.

Zobacz demo na żywo .

Ponieważ zaznaczyłeś także Scalę, rozwiązanie bez wyrażenia regularnego, które łatwo radzi sobie z wieloma cytowanymi ciągami:

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

jak w javascript:

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

rzeczywiste wyrażenie regularne to: /'([^']+)'/

jeśli używasz nie chciwego modyfikatora (jak w innym poście), wygląda to tak:

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

to jest czystsze.

W Scali

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

Zobacz prezentację na żywo

Apache Commons Lang udostępnia wiele narzędzi pomocniczych dla interfejsu API java.lang, w szczególności metod manipulacji ciągami. W twoim przypadku początkowe i końcowe podciągi są takie same, więc po prostu wywołaj następującą funkcję.

StringUtils.substringBetween(String str, String tag)

Pobiera łańcuch, który jest zagnieżdżony między dwoma instancjami tego samego łańcucha .

Jeśli początkowe i końcowe podciągi są różne, użyj następującej metody przeciążenia.

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

Pobiera ciąg zagnieżdżony między dwoma ciągami.

Jeśli chcesz wszystkie wystąpienia pasujących podciągów, użyj:

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

Przeszukuje ciąg pod kątem podciągów rozdzielonych znacznikiem początkowym i końcowym, zwracając wszystkie pasujące podciągi w tablicy .

Na przykład, aby uzyskać wszystkie wystąpienia pasującego podciągu

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

możesz użyć tego używam pętli while do przechowywania wszystkich pasujących podciągów w tablicy, jeśli używasz

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

dostaniesz podłańcuch dopasowań, dzięki czemu możesz użyć tego, aby uzyskać podłańcuch wszystkich dopasowań

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

dodaj zależność apache.commons od pom.xml

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

I poniżej działa kod.

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

Trochę jak grupa (1) nie działała dla mnie. Użyłem grupy (0), aby znaleźć wersję adresu 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";