我有一个字符串，
String s = "test string (67)";
我想得到第 67 号，它是 ( 和 ) 之间的字符串。
谁能告诉我该怎么做？
问问题
319655 次
22 回答
117
可能有一个非常整洁的正则表达式，但我在那个领域是菜鸟，所以相反......
String s = "test string (67)";
s = s.substring(s.indexOf("(") + 1);
s = s.substring(0, s.indexOf(")"));
System.out.println(s);
于 2012-09-26T05:27:44.150 回答
101
这个问题的一个非常有用的解决方案是使用Apache Commons库，不需要您执行 indexOf 。
StringUtils.substringBetween(s, "(", ")");
即使通过查找 indexOf 结束字符串，该方法将允许您处理多次出现的结束字符串。
你可以从这里下载这个库： https ://mvnrepository.com/artifact/org.apache.commons/commons-lang3/3.4
于 2016-07-07T06:28:47.670 回答
80
像这样试试
String s="test string(67)";
String requiredString = s.substring(s.indexOf("(") + 1, s.indexOf(")"));
子字符串的方法签名是：
s.substring(int start, int end);
于 2013-08-07T06:42:21.570 回答
31
通过使用正则表达式：
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));
于 2012-09-26T05:48:18.527 回答
19
Java 支持正则表达式，但如果您真的想使用它们来提取匹配项，它们会有点麻烦。我认为在示例中获取所需字符串的最简单方法是在String类的replaceAll方法中使用正则表达式支持：
String x = "test string (67)".replaceAll(".*\\(|\\).*", "");
// x is now the String "67"
这只是删除了所有内容，包括第一个(，以及)之后的所有内容。这只是在括号之间留下了东西。
但是，这样做的结果仍然是一个String。如果您想要一个整数结果，那么您需要进行另一次转换：
int n = Integer.parseInt(x);
// n is now the integer 67
于 2012-09-26T05:37:21.580 回答
11
在一行中，我建议：
String input = "test string (67)";
input = input.subString(input.indexOf("(")+1, input.lastIndexOf(")"));
System.out.println(input);`
于 2014-09-15T10:11:57.777 回答
8
您可以使用 apache 公共库的 StringUtils 来执行此操作。
import org.apache.commons.lang3.StringUtils;
...
String s = "test string (67)";
s = StringUtils.substringBetween(s, "(", ")");
....
于 2016-04-11T19:04:07.003 回答
7
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
于 2012-09-26T05:30:31.590 回答
7
测试字符串test string (67)，您需要从中获取嵌套在两个字符串之间的字符串。
String str = "test string (67) and (77)", open = "(", close = ")";
列出了一些可能的方法：简单的通用解决方案：
String subStr = str.substring(str.indexOf( open ) + 1, str.indexOf( close ));
System.out.format("String[%s] Parsed IntValue[%d]\n", subStr, Integer.parseInt( subStr ));
阿帕奇软件基金会
commons.lang3。
StringUtils类substringBetween()函数获取嵌套在两个字符串之间的字符串。仅返回第一个匹配项。
String substringBetween = StringUtils.substringBetween(subStr, open, close);
System.out.println("Commons Lang3 : "+ substringBetween);
用嵌套在两个字符串之间的字符串替换给定的字符串。#395
带有正则表达式的模式：
(\()(.*?)(\)).*
点匹配（几乎）任何字符
.? = .{0,1}, .* = .{0,}, .+ = .{1,}
String patternMatch = patternMatch(generateRegex(open, close), str);
System.out.println("Regular expression Value : "+ patternMatch);
具有实用程序类RegexUtils和一些函数的正则表达式。
Pattern.DOTALL:匹配任何字符，包括行终止符。
Pattern.MULTILINE：匹配从输入序列开始到结束的整个字符串。^$
public static String generateRegex(String open, String close) {
return "(" + RegexUtils.escapeQuotes(open) + ")(.*?)(" + RegexUtils.escapeQuotes(close) + ").*";
}
public static String patternMatch(String regex, CharSequence string) {
final Pattern pattern = Pattern.compile(regex, Pattern.DOTALL);
final Matcher matcher = pattern .matcher(string);
String returnGroupValue = null;
if (matcher.find()) { // while() { Pattern.MULTILINE }
System.out.println("Full match: " + matcher.group(0));
System.out.format("Character Index [Start:End]«[%d:%d]\n",matcher.start(),matcher.end());
for (int i = 1; i <= matcher.groupCount(); i++) {
System.out.println("Group " + i + ": " + matcher.group(i));
if( i == 2 ) returnGroupValue = matcher.group( 2 );
}
}
return returnGroupValue;
}
于 2019-01-08T09:30:19.707 回答
6
String result = s.substring(s.indexOf("(") + 1, s.indexOf(")"));
于 2017-03-02T09:55:38.353 回答
5
public String getStringBetweenTwoChars(String input, String startChar, String endChar) {
try {
int start = input.indexOf(startChar);
if (start != -1) {
int end = input.indexOf(endChar, start + startChar.length());
if (end != -1) {
return input.substring(start + startChar.length(), end);
}
}
} catch (Exception e) {
e.printStackTrace();
}
return input; // return null; || return "" ;
}
用法 ：
String input = "test string (67)";
String startChar = "(";
String endChar = ")";
String output = getStringBetweenTwoChars(input, startChar, endChar);
System.out.println(output);
// Output: "67"
于 2018-10-27T17:21:56.200 回答
4
利用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);
}
}
于 2012-09-26T05:56:26.287 回答
4
使用拆分方法的另一种方法
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]);
}
于 2012-09-26T05:36:59.157 回答
3
另一种可能的解决方案是使用lastIndexOf它将向后查找字符或字符串的位置。
在我的场景中，我有跟随String，我必须提取<<UserName>>
1QAJK-WKJSH_MyApplication_Extract_<<UserName>>.arc
所以，indexOf并StringUtils.substringBetween没有帮助，因为他们从一开始就开始寻找角色。
所以，我用lastIndexOf
String str = "1QAJK-WKJSH_MyApplication_Extract_<<UserName>>.arc";
String userName = str.substring(str.lastIndexOf("_") + 1, str.lastIndexOf("."));
而且，它给了我
<<UserName>>
于 2017-10-05T18:49:55.247 回答
3
我发现使用 Regex 和 Pattern / 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, ""));
}
这可能有助于解决更复杂的正则表达式问题，您希望在两组字符之间获取文本。
于 2017-02-02T19:25:12.263 回答
2
这样做的“通用”方式是从头开始解析字符串，丢弃第一个括号之前的所有字符，记录第一个括号之后的字符，并丢弃第二个括号之后的字符。
我确定有一个正则表达式库或可以做的事情。
于 2012-09-26T05:26:22.460 回答
2
String s = "test string (67)";
System.out.println(s.substring(s.indexOf("(")+1,s.indexOf(")")));
于 2016-02-18T11:50:04.147 回答
1
这是一个简单的使用\D+正则表达式并完成工作。
这会选择除数字以外的所有字符，无需复杂化
/\D+/
于 2020-07-13T14:34:55.340 回答
1
像这样的东西：
public static String innerSubString(String txt, char prefix, char suffix) {
if(txt != null && txt.length() > 1) {
int start = 0, end = 0;
char token;
for(int i = 0; i < txt.length(); i++) {
token = txt.charAt(i);
if(token == prefix)
start = i;
else if(token == suffix)
end = i;
}
if(start + 1 < end)
return txt.substring(start+1, end);
}
return null;
}
于 2018-06-30T00:55:59.303 回答
1
如果没有匹配正则表达式，它将返回原始字符串
var iAm67 = "test string (67)".replaceFirst("test string \\((.*)\\)", "$1");
将匹配项添加到代码中
String str = "test string (67)";
String regx = "test string \\((.*)\\)";
if (str.matches(regx)) {
var iAm67 = str.replaceFirst(regx, "$1");
}
- -编辑 - -
我使用https://www.freeformatter.com/java-regex-tester.html#ad-output来测试正则表达式。
结果是添加更好？* 之后的匹配较少。像这样的东西：
String str = "test string (67)(69)";
String regx1 = "test string \\((.*)\\).*";
String regx2 = "test string \\((.*?)\\).*";
String ans1 = str.replaceFirst(regx1, "$1");
String ans2 = str.replaceFirst(regx2, "$1");
System.out.println("ans1:"+ans1+"\nans2:"+ans2);
// ans1:67)(69
// ans2:67
于 2020-06-11T03:52:25.287 回答
0
String s = "(69)";
System.out.println(s.substring(s.lastIndexOf('(')+1,s.lastIndexOf(')')));
于 2021-04-29T15:43:04.483 回答
0
顶部的小扩展（MadProgrammer）答案
public static String getTextBetween(final String wholeString, final String str1, String str2){
String s = wholeString.substring(wholeString.indexOf(str1) + str1.length());
s = s.substring(0, s.indexOf(str2));
return s;
}
于 2021-10-22T12:19:43.707 回答