如何得到两个字符之间的字符串？

我有一根绳子,

String s = "test string (67)";

我想得到 no 67，它是(和)之间的字符串。

有人能告诉我怎么做吗？

363421 次浏览
小开

The "generic" way of doing this is to parse the string from the start, throwing away all the characters before the first bracket, recording the characters after the first bracket, and throwing away the characters after the second bracket.

我肯定有正则表达式库之类的东西可以做到这一点。

小开

可能有一个非常整洁的正则表达式，但我在那方面是菜鸟，所以相反..。

String s = "test string (67)";


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


System.out.println(s);
小开 
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
小开

另一种使用拆分方法的方法

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]);
}
小开

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
小开

使用正则表达式:

 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));
小开

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


}


}
小开

试试这样

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

The method's signature for substring is:

s.substring(int start, int end);
小开

在一行中，我建议:

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


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

您可以使用 apache 公共库的 StringUtils 来完成这项工作。

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

这个问题的一个非常有用的解决方案是使用 Apache Commons库，它不需要你做 indexOf。

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

这个方法甚至可以让你处理多次出现的关闭字符串，这通过寻找 indexOf 关闭字符串是不容易的。

You can download this library from here: Https://mvnrepository.com/artifact/org.apache.commons/commons-lang3/3.4

小开

对于正则表达式和模式/匹配器类，我找到的最不通用的方法是:

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

这可能有助于解决更复杂的正则表达式问题，即希望获取两组字符之间的文本。

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

另一种可能的解决方案是使用 lastIndexOf，它将从后面查找字符或字符串。

在我的场景中，我必须跟踪 String并提取 <<UserName>>

1QAJK-WKJSH_MyApplication_Extract_<<UserName>>.arc

So, indexOf and StringUtils.substringBetween was not helpful as they start looking for character from beginning.

所以我用了 lastIndexOf

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

它给了我

<<UserName>>
小开

就像这样:

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;
}
小开 
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"
小开

测试字符串 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 ));

Apache软件基金会。

类 substringBetween()函数获取嵌套在两个字符串之间的字符串，只返回第一个匹配。

String substringBetween = StringUtils.substringBetween(subStr, open, close);
System.out.println("Commons Lang3 : "+ substringBetween);

用嵌套在两个 String.#395之间的 String 替换给定的 String

带正则表达式的模式: 强 > (\()(.*?)(\)).*强

多蒂匹配(几乎)任何字符 .? = .{0,1}, .* = .{0,}, .+ = .{1,}

String patternMatch = patternMatch(generateRegex(open, close), str);
System.out.println("Regular expression Value : "+ patternMatch);

具有实用工具类 强 > RegexUtils强和一些函数的正则表达式。
匹配任何字符，包括行结束符。
Pattern.MULTILINE: 从输入序列的 startABC1到 end$匹配整个 String。

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

如果没有匹配的正则表达式，它将返回原始字符串

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来测试正则表达式。

事实证明，最好在 * 后面加上? for less match. 这样的东西:

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
小开

This is a simple use \D+ regex and job done.
此选择除数字之外的所有字符，不需要复杂

/\D+/
小开 
String s = "(69)";
System.out.println(s.substring(s.lastIndexOf('(')+1,s.lastIndexOf(')')));
小开

顶部小扩展(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;
}

提交答案