Usar expresiones regulares para extraer un valor en Java

Tengo varias cadenas en bruto:

[some text] [some number] [some more text] 

Quiero extraer el texto en [algún número] usando las clases Java Regex.

Sé aproximadamente qué expresión regular quiero usar (aunque todas las sugerencias son bienvenidas). Lo que realmente me interesa son las llamadas de Java para tomar la cadena de expresiones regulares y usarla en los datos de origen para producir el valor de [algún número].

EDITAR: Debería añadir que solo estoy interesado en un solo [algún número] (básicamente, la primera instancia). Las cadenas fuente son cortas y no voy a buscar múltiples ocurrencias de [algún número].

Ejemplo completo:

 private static final Pattern p = Pattern.compile("^([a-zA-Z]+)([0-9]+)(.*)"); public static void main(String[] args) { // create matcher for pattern p and given string Matcher m = p.matcher("Testing123Testing"); // if an occurrence if a pattern was found in a given string... if (m.find()) { // ...then you can use group() methods. System.out.println(m.group(0)); // whole matched expression System.out.println(m.group(1)); // first expression from round brackets (Testing) System.out.println(m.group(2)); // second one (123) System.out.println(m.group(3)); // third one (Testing) } } 

Como busca el primer número, puede usar dicha expresión regular:

 ^\D+(\d+).* 

y m.group(1) le devolverá el primer número. Tenga en cuenta que los números firmados pueden contener un signo menos:

 ^\D+(-?\d+).* 

Allain básicamente tiene el código Java, así que puedes usar eso. Sin embargo, su expresión solo coincide si tus números solo están precedidos por una secuencia de caracteres de palabra.

 "(\\d+)" 

debería ser capaz de encontrar la primera cadena de dígitos. No necesita especificar lo que tiene delante, si está seguro de que será la primera cadena de dígitos. Del mismo modo, no tiene sentido especificar lo que le espera, a menos que así lo desee. Si solo quiere el número, y está seguro de que será la primera cadena de uno o más dígitos, eso es todo lo que necesita.

Si espera que esté compensado por espacios, será aún más distinto especificar

 "\\s+(\\d+)\\s+" 

podría ser mejor.

Si necesita las tres partes, esto hará:

 "(\\D+)(\\d+)(.*)" 

EDITAR Las expresiones dadas por Allain y Jack sugieren que debe especificar algún subconjunto de no dígitos para capturar dígitos . Si le dice al motor de expresiones regulares que está buscando \d , ignorará todo antes de los dígitos. Si la expresión de J o A se ajusta a su patrón, entonces la coincidencia completa es igual a la cadena de entrada . Y no hay razón para especificarlo. Probablemente desacelere una coincidencia limpia, si no se ignora por completo.

 import java.util.regex.Matcher; import java.util.regex.Pattern; public class Regex1 { public static void main(String[]args) { Pattern p = Pattern.compile("\\d+"); Matcher m = p.matcher("hello1234goodboy789very2345"); while(m.find()) { System.out.println(m.group()); } } } 

Salida:

 1234 789 2345 

Además de Pattern , la clase Java String también tiene varios métodos que pueden funcionar con expresiones regulares, en su caso el código será:

 "ab123abc".replaceFirst("\\D*(\\d*).*", "$1") 

donde \\D es un carácter sin dígitos.

En Java 1.4 y versiones posteriores:

 String input = "..."; Matcher matcher = Pattern.compile("[^0-9]+([0-9]+)[^0-9]+").matcher(input); if (matcher.find()) { String someNumberStr = matcher.group(1); // if you need this to be an int: int someNumberInt = Integer.parseInt(someNumberStr); } 

Esta función recoge todas las secuencias coincidentes de la cadena. En este ejemplo, toma todas las direcciones de correo electrónico de la cadena.

 static final String EMAIL_PATTERN = "[_A-Za-z0-9-\\+]+(\\.[_A-Za-z0-9-]+)*@" + "[A-Za-z0-9-]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})"; public List getAllEmails(String message) { List result = null; Matcher matcher = Pattern.compile(EMAIL_PATTERN).matcher(message); if (matcher.find()) { result = new ArrayList(); result.add(matcher.group()); while (matcher.find()) { result.add(matcher.group()); } } return result; } 

Para message = "adf@gmail.com, >>> lalala@aaa.pl" creará la Lista de 3 elementos.

Intenta hacer algo como esto:

 Pattern p = Pattern.compile("^.+(\\d+).+"); Matcher m = p.matcher("Testing123Testing"); if (m.find()) { System.out.println(m.group(1)); } 

Mira que puedes hacerlo usando StringTokenizer

 String str = "as:"+123+"as:"+234+"as:"+345; StringTokenizer st = new StringTokenizer(str,"as:"); while(st.hasMoreTokens()) { String k = st.nextToken(); // you will get first numeric data ie 123 int kk = Integer.parseInt(k); System.out.println("k string token in integer " + kk); String k1 = st.nextToken(); // you will get second numeric data ie 234 int kk1 = Integer.parseInt(k1); System.out.println("new string k1 token in integer :" + kk1); String k2 = st.nextToken(); // you will get third numeric data ie 345 int kk2 = Integer.parseInt(k2); System.out.println("k2 string token is in integer : " + kk2); } 

Dado que estamos tomando estos datos numéricos en tres variables diferentes, podemos usar estos datos en cualquier lugar del código (para un uso posterior)

Solución simple

 // Regexplanation: // ^ beginning of line // \\D+ 1+ non-digit characters // (\\d+) 1+ digit characters in a capture group // .* 0+ any character String regexStr = "^\\D+(\\d+).*"; // Compile the regex String into a Pattern Pattern p = Pattern.compile(regexStr); // Create a matcher with the input String Matcher m = p.matcher(inputStr); // If we find a match if (m.find()) { // Get the String from the first capture group String someDigits = m.group(1); // ...do something with someDigits } 

Solución en una clase Util

 public class MyUtil { private static Pattern pattern = Pattern.compile("^\\D+(\\d+).*"); private static Matcher matcher = pattern.matcher(""); // Assumptions: inputStr is a non-null String public static String extractFirstNumber(String inputStr){ // Reset the matcher with a new input String matcher.reset(inputStr); // Check if there's a match if(matcher.find()){ // Return the number (in the first capture group) return matcher.group(1); }else{ // Return some default value, if there is no match return null; } } } ... // Use the util function and print out the result String firstNum = MyUtil.extractFirstNumber("Testing4234Things"); System.out.println(firstNum); 

¿Qué tal [^\\d]*([0-9]+[\\s]*[.,]{0,1}[\\s]*[0-9]*).* Creo que lo haría cuidar números con parte fraccional. Incluí espacios en blanco e incluido , como posible separador. Estoy tratando de sacar los números de una cadena, incluidos los flotadores y teniendo en cuenta que el usuario puede cometer un error e incluir espacios en blanco al escribir el número.

 Pattern p = Pattern.compile("(\\D+)(\\d+)(.*)"); Matcher m = p.matcher("this is your number:1234 thank you"); if (m.find()) { String someNumberStr = m.group(2); int someNumberInt = Integer.parseInt(someNumberStr); } 

Algunas veces puede usar el método simple .split (“REGEXP”) disponible en java.lang.String. Por ejemplo:

 String input = "first,second,third"; //To retrieve 'first' input.split(",")[0] //second input.split(",")[1] //third input.split(",")[2] 

si estás leyendo un archivo, entonces esto puede ayudarte

  try{ InputStream inputStream = (InputStream) mnpMainBean.getUploadedBulk().getInputStream(); BufferedReader br = new BufferedReader(new InputStreamReader(inputStream)); String line; //Ref:03 while ((line = br.readLine()) != null) { if (line.matches("[AZ],\\d,(\\d*,){2}(\\s*\\d*\\|\\d*:)+")) { String[] splitRecord = line.split(","); //do something } else{ br.close(); //error return; } } br.close(); } } catch (IOException ioExpception){ logger.logDebug("Exception " + ioExpception.getStackTrace()); }