Question

我有一个字符串，

String s = "test string (67)";

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

任何人都可以告诉我该怎么做？

Answer 1

可能有一个非常简洁的RegExp，但我在该领域是菜鸟，所以相反......

String s = "test string (67)";

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

System.out.println(s);

Answer 2

尝试这样

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

该方法的子字符串签名是：

s.substring(int start, int end);

Answer 3

这个问题的一个非常有用的解决方案是您使用 Apache Commons 库而不需要您执行indexOf。

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

通过查找indexOf结束字符串，即使多次出现关闭字符串，此方法也可以处理。

您可以从此处下载此库： https://mvnrepository.com/artifact/org.apache.commons/commons-lang3/3.4

Answer 4

使用正则表达式：

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

Answer 5

Java supports Regular Expressions，但如果您真的想用它们来提取匹配项，它们会很麻烦。我认为在示例中获取所需字符串的最简单方法是在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

Answer 6

在一行中，我建议：

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

Answer 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

Answer 8

您可以使用apache公共库的StringUtils来执行此操作。

f90flags=-g -fp-model precise -traceback -r8 -O0

Answer 9

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

Answer 10

使用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);

    }

}

Answer 11

我发现使用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, ""));
}

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

Answer 12

使用split方法的另一种方法

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

Answer 13

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"

Answer 14

String s = "test string (67)";

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

Answer 15

另一种可能的解决方案是使用 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>>

Answer 16

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

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

Answer 17

这是一个简单的\D+正则表达式，可以完成工作。
这将选择除数字以外的所有字符，无需复杂化

/\D+/

Answer 18

＆＃34;泛型＆＃34;这样做的方法是从一开始就解析字符串，丢弃第一个括号前的所有字符，在第一个括号后记录字符，然后在第二个括号后丢弃字符。

我确定有一个正则表达式库或其他东西可以做到。

Answer 19

类似这样的东西：

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

Answer 20

测试字符串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 Software Foundation commons.lang3。

StringUtils类substringBetween()函数获取嵌套在两个String之间的String。仅返回第一个匹配项。

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

用嵌套在两个字符串之间的字符串替换给定的字符串。 #395

具有正则表达式的模式：($)(.*?)($).*

Dot匹配（几乎）任何字符 .? = .{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;
}

Answer 21

请参考以下示例。我已根据您的要求创建了样本

样本：click here

Answer 22

String s = "(69)";
System.out.println(s.substring(s.lastIndexOf('(')+1,s.lastIndexOf(')')));

Answer 23

我得到了这样的答案。试试吧

String value = "test string (67)";
int intValue =Integer.valueOf( value.replaceAll("[^0-9]", ""));

如何在两个字符之间获取字符串？

23 个答案: