Cómo extraer una subcadena usando regex

Tengo una cadena que tiene dos comillas simples, el 'personaje. Entre las comillas simples están los datos que quiero.

¿Cómo puedo escribir una expresión regular para extraer "los datos que quiero" del siguiente texto?

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

Suponiendo que desea la parte entre comillas simples, use esta expresión regular con un Matcher:

"'(.*?)'"

Ejemplo:

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

Resultado:

los datos que quiero

No necesitas expresiones regulares para esto.

Agregue apache commons lang a su proyecto ( http://commons.apache.org/proper/commons-lang/ ), luego use:

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

    }
}

Hay una frase simple para esto:

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

Al hacer que el grupo coincidente sea opcional, esto también atiende las citas que no se encuentran al devolver un espacio en blanco en ese caso.

Ver demostración en vivo .

Debido a que también seleccionó Scala, una solución sin expresiones regulares que se ocupa fácilmente de múltiples cadenas entre comillas:

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

como en javascript:

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

La expresión regular real es: /'([^']+)'/

si usa el modificador no codicioso (según otra publicación) es así:

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

Está más limpio.

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

Ver demostración en vivo

Apache Commons Lang proporciona una gran cantidad de utilidades auxiliares para la API java.lang, especialmente los métodos de manipulación de cadenas. En su caso, las subcadenas de inicio y finalización son las mismas, así que simplemente llame a la siguiente función.

StringUtils.substringBetween(String str, String tag)

Obtiene la cadena que está anidada entre dos instancias de la misma cadena .

Si las subcadenas de inicio y fin son diferentes, utilice el siguiente método sobrecargado.

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

Obtiene la cadena anidada entre dos cadenas.

Si desea todas las instancias de las subcadenas coincidentes, use,

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

Busca en una cadena las subcadenas delimitadas por una etiqueta de inicio y fin, devolviendo todas las subcadenas coincidentes en una matriz .

Para el ejemplo en cuestión, obtener todas las instancias de la subcadena coincidente

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

puede usar esto que uso mientras que el bucle para almacenar todas las subcadenas coincidentes en la matriz si usa

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

obtendrá subcadenas de coincidencias para que pueda usar esto para obtener todas las subcadenas de coincidencias

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

agregue la dependencia apache.commons en su pom.xml

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

Y debajo del código funciona.

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

De alguna manera, el grupo (1) no funcionó para mí. Usé el grupo (0) para encontrar la versión de la 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";