solo - Usar expresiones regulares para extraer un valor en Java
extraer cadenas con expresiones regulares java (13)
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].
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.
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]
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.
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+).*
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<String> getAllEmails(String message) {
List<String> result = null;
Matcher matcher = Pattern.compile(EMAIL_PATTERN).matcher(message);
if (matcher.find()) {
result = new ArrayList<String>();
result.add(matcher.group());
while (matcher.find()) {
result.add(matcher.group());
}
}
return result;
}
Para message = "[email protected], <[email protected]>>>> [email protected]" 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 i.e 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 i.e 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 i.e 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)
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("[A-Z],//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());
}
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);
}
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