在Java中使用正则表达式提取值

小开

最佳答案

完整的例子:

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

由于您正在寻找第一个数字，您可以使用这样的regexp:

^\D+(\d+).*

m.group(1)将返回第一个数字。注意，带符号的数字可以包含负号:

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

小开

在Java 1.4及以上版本中:

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

小开

Allain基本上有java代码，所以你可以使用它。然而，他的表达式只匹配如果你的数字之前只有一个字字符流。

"(\\d+)"

应该能找到第一串数字。你不需要指定在它之前是什么，如果你确定它将是第一个数字字符串。同样地，指定后面是什么也没有用，除非你想要那样做。如果你只是想要一个数字，并确定它将是一个或多个数字的第一个字符串，那么这就是你所需要的。

如果您希望它被空格抵消，它将使指定更加明显

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

可能会更好。

如果你需要这三个部分，这将做:

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

Allain和Jack给出的表达式建议你需要指定一些非数字的子集来捕获数字。如果你告诉正则表达式引擎你正在寻找\d，那么它将忽略数字之前的所有内容。如果J或A的表达式适合你的模式，那么整个匹配= 输入字符串。没有理由指定它。如果它没有被完全忽略的话，它可能会降低匹配的速度。

小开

[^\\d]*([0-9]+[\\s]*[.,]{0,1}[\\s]*[0-9]*).*怎么样?我认为它可以处理小数部分的数字。我包含了空格，并包含,作为可能的分隔符。我试图得到的数字从一个字符串，包括浮动，并考虑到，用户可能会犯错误，并包括空格，而键入的数字

小开

试着这样做:

Pattern p = Pattern.compile("^.+(\\d+).+");
Matcher m = p.matcher("Testing123Testing");


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

小开

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

输出:

1234
789
2345

小开

除了模式之外，Java 字符串类还有几个可以使用正则表达式的方法，在你的例子中，代码将是:

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

其中\\D是非数字字符。

小开

看，你可以使用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);
}

由于我们将这些数值数据转换为三个不同的变量，我们可以在代码的任何地方使用这些数据(以供进一步使用)

小开

这个函数从字符串中收集所有匹配的序列。在本例中，它从字符串中获取所有电子邮件地址。

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

对于message = "adf@gmail.com, <another@osiem.osiem>>>> lalala@aaa.pl"，它将创建包含3个元素的List。

小开

有时你可以使用java.lang.String中提供的简单的.split("REGEXP")方法。例如:< br >

String input = "first,second,third";


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

小开

如果你正在从文件中读取，那么这可以帮助你

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

小开

简单的解决方案

// 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
}

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

小开

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