¿Cómo obtener una cadena entre dos caracteres?

Question

tengo una cadena,

String s = "test string (67)"; 

que desea obtener el nº 67 que es la cadena entre (y).

¿Alguien puede decirme cómo hacerlo?

Answer 1

La manera "genérica" ​​de hacerlo es analizar la cadena desde el principio, tirando todos los caracteres antes del primer corchete, grabando los caracteres después del primer corchete y tirando los caracteres después del segundo corchete.

Estoy seguro de que hay una biblioteca de expresiones regulares o algo para hacerlo.

Answer 2

Probablemente hay una expresión regular muy ordenado, pero soy novato en esa zona, así que en vez ...

String s = "test string (67)"; 

s = s.substring(s.indexOf("(") + 1); 
s = s.substring(0, s.indexOf(")")); 

System.out.println(s); 

Answer 3

String s = "test string (67)"; 

int start = 0; // '(' position in string 
int end = 0; // ')' position in string 
for(int i = 0; i < s.length(); i++) { 
    if(s.charAt(i) == '(') // Looking for '(' position in string 
     start = i; 
    else if(s.charAt(i) == ')') // Looking for ')' position in string 
     end = i; 
} 
String number = s.substring(start+1, end); // you take value between start and end 

Answer 4

Otra forma de hacerlo utilizando el método de división

public static void main(String[] args) { 


    String s = "test string (67)"; 
    String[] ss; 
    ss= s.split("\\("); 
    ss = ss[1].split("\\)"); 

    System.out.println(ss[0]); 
} 

Answer 5

Java supports Regular Expressions , pero son un poco engorrosos si realmente quieres usarlos para extraer coincidencias. Creo que la forma más fácil de llegar a la cadena que desea en su ejemplo es que sólo tiene que utilizar el soporte de expresiones regulares en replaceAll método de la clase String:

String x = "test string (67)".replaceAll(".*\\(|\\).*", ""); 
// x is now the String "67" 

Esto simplemente borra todo hasta al e-incluyendo la primera (, y lo mismo para el ) y todo lo demás. Esto simplemente deja el material entre paréntesis. Sin embargo, el resultado sigue siendo String. Si quieres un resultado entero entonces que hay que hacer otra conversión:

int n = Integer.parseInt(x); 
// n is now the integer 67 

Answer 6

Mediante el uso de expresiones regulares:

String s = "test string (67)"; 
Pattern p = Pattern.compile("\\(.*?\\)"); 
Matcher m = p.matcher(s); 
if(m.find()) 
    System.out.println(m.group().subSequence(1, m.group().length()-1)); 

Answer 7

Uso Pattern and Matcher

public class Chk { 

    public static void main(String[] args) { 

     String s = "test string (67)"; 
     ArrayList<String> arL = new ArrayList<String>(); 
     ArrayList<String> inL = new ArrayList<String>(); 

     Pattern pat = Pattern.compile("\\(\\w+\\)"); 
     Matcher mat = pat.matcher(s); 

     while (mat.find()) { 

      arL.add(mat.group()); 
      System.out.println(mat.group()); 

     } 

     for (String sx : arL) { 

      Pattern p = Pattern.compile("(\\w+)"); 
      Matcher m = p.matcher(sx); 

      while (m.find()) { 

       inL.add(m.group()); 
       System.out.println(m.group()); 
      } 
     } 

     System.out.println(inL); 

    } 

} 

Answer 8

Tratar como este

String s="test string(67)"; 
String requiredString = s.substring(s.indexOf("(") + 1, s.indexOf(")")); 

La firma del método para la subcadena es:

s.substring(int start, int end); 

Answer 9

Recibí la respuesta de esta manera. Pruébalo

String value = "test string (67)"; 
int intValue =Integer.valueOf(value.replaceAll("[^0-9]", "")); 

Answer 10

En una sola línea, sugiero:

String input = "test string (67)"; 
input = input.subString(input.indexOf("(")+1, input.lastIndexOf(")")); 
System.out.println(input);` 

Answer 11

String s = "test string (67)"; 

System.out.println(s.substring(s.indexOf("(")+1,s.indexOf(")"))); 

Answer 12

usted podría utilizar StringUtils Apache de la biblioteca común de hacer esto.

import org.apache.commons.lang3.StringUtils; 
... 
String s = "test string (67)"; 
s = StringUtils.substringBetween(s, "(", ")"); 
.... 

Answer 13

Una solución muy útil para este problema, que no requiere de usted para hacer el indexOf está utilizando Apache Commons bibliotecas.

StringUtils.substringBetween(s, "(", ")"); 

Este método le permitirá manejar incluso aunque haya múltiples apariciones de la cadena de cierre que no será fácil mediante la búsqueda de la cadena de cierre indexOf.

Puede descargar esta biblioteca desde aquí: https://mvnrepository.com/artifact/org.apache.commons/commons-lang3/3.4

Answer 14

La manera más genérica que encontré para hacer esto con expresiones regulares y clases de patrones/Matcher:

String text = "test string (67)"; 

String START = "\\("; // A literal "(" character in regex 
String END = "\\)"; // A literal ")" character in regex 

// Captures the word(s) between the above two character(s) 
String pattern = START + "(\w+)" + END; 

Pattern pattern = Pattern.compile(pattern); 
Matcher matcher = pattern.matcher(text); 

while(matcher.find()) { 
    System.out.println(matcher.group() 
     .replace(START, "").replace(END, "")); 
} 

Esto puede ayudar a los problemas de expresiones regulares más complejas donde desea obtener el texto entre dos conjuntos de caracteres.

Answer 15

String result = s.substring(s.indexOf("(") + 1, s.indexOf(")")); 

Answer 16

La otra solución posible es utilizar lastIndexOf donde buscará carácter o cadena de atrás.

En mi caso, yo había String siguiente y tuve que extraer <<UserName>>

1QAJK-WKJSH_MyApplication_Extract_<<UserName>>.arc 

Así, indexOf y StringUtils.substringBetween No fue útil, ya que comienzan a buscar el carácter de principio.

Por lo tanto, he usado lastIndexOf

String str = "1QAJK-WKJSH_MyApplication_Extract_<<UserName>>.arc"; 
String userName = str.substring(str.lastIndexOf("_") + 1, str.lastIndexOf(".")); 

Y, me da

<<UserName>>