Come estrarre una sottostringa usando regex

Ho una stringa che contiene due virgolette singole, il 'personaggio. Tra le virgolette singole ci sono i dati che voglio.

Come posso scrivere una regex per estrarre "i dati che voglio" dal seguente testo?

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

Supponendo che tu voglia la parte tra virgolette singole, usa questa espressione regolare con un Matcher:

"'(.*?)'"

Esempio:

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

Risultato:

i dati che desidero

Non hai bisogno di regex per questo.

Aggiungi apache commons lang al tuo progetto ( http://commons.apache.org/proper/commons-lang/ ), quindi usa:

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

    }
}

C'è un semplice one-liner per questo:

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

Rendendo facoltativo il gruppo corrispondente, ciò provvede anche alle virgolette che non vengono trovate restituendo uno spazio in quel caso.

Guarda la demo dal vivo .

Perché hai anche selezionato Scala, una soluzione senza regex che si occupa facilmente di più stringhe tra virgolette:

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

come in javascript:

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

l'attuale regexp è: /'([^']+)'/

se usi il modificatore non avido (come per un altro post) è così:

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

è più pulito.

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

Vedi Demo live

Apache Commons Lang offre una serie di utility di supporto per l'API java.lang, in particolare i metodi di manipolazione delle stringhe. Nel tuo caso, le sottostringhe iniziale e finale sono le stesse, quindi chiama la seguente funzione.

StringUtils.substringBetween(String str, String tag)

Ottiene la stringa nidificata tra due istanze della stessa stringa .

Se le sottostringhe iniziale e finale sono diverse, utilizzare il seguente metodo sovraccarico.

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

Ottiene la stringa nidificata tra due stringhe.

Se vuoi tutte le istanze delle sottostringhe corrispondenti, usa,

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

Cerca una stringa per sottostringhe delimitate da un tag di inizio e fine, restituendo tutte le sottostringhe corrispondenti in un array .

Per l'esempio in questione ottenere tutte le istanze della sottostringa corrispondente

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

puoi usare questo che uso while loop per memorizzare tutte le corrispondenze sottostringa nell'array se usi

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

otterrai la sottostringa delle partite in modo da poterla utilizzare per ottenere la sottostringa di tutte le partite

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

aggiungi la dipendenza apache.commons dal tuo pom.xml

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

E sotto il codice funziona.

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

Alcuni come il gruppo (1) non ha funzionato per me. Ho usato il gruppo (0) per trovare la versione dell'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";