Hoe krijg ik een string tussen twee karakters?

Ik heb een string,

String s = "test string (67)";

Ik wil de nr. 67 hebben, de string tussen ( en ).

Kan iemand mij vertellen hoe ik dit moet doen?


Antwoord 1, autoriteit 100%

Er is waarschijnlijk een hele nette RegExp, maar ik ben een noob op dat gebied, dus in plaats daarvan…

String s = "test string (67)";
s = s.substring(s.indexOf("(") + 1);
s = s.substring(0, s.indexOf(")"));
System.out.println(s);

Antwoord 2, autoriteit 87%

Een zeer nuttige oplossing voor dit probleem waarvoor u de indexOf niet hoeft te doen, is het gebruik van Apache Commons-bibliotheken.

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

Met deze methode kun je zelfs omgaan met meerdere keren dat de afsluitende tekenreeks voorkomt, wat niet gemakkelijk zal zijn door te zoeken naar indexOf afsluitende tekenreeks.

Je kunt deze bibliotheek hier downloaden:
https://mvnrepository.com/artifact/org.apache.commons/commons -lang3/3.4


Antwoord 3, autoriteit 69%

Probeer het zo

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

De handtekening van de methode voor substring is:

s.substring(int start, int end);

Antwoord 4, autoriteit 27%

Door reguliere expressie te gebruiken:

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

Antwoord 5, autoriteit 16%

Java ondersteunt reguliere expressies, maar ze zijn nogal omslachtig als je wilt ze eigenlijk gebruiken om overeenkomsten te extraheren. Ik denk dat de gemakkelijkste manier om bij de string te komen die je in je voorbeeld wilt, is om gewoon de ondersteuning voor reguliere expressies te gebruiken in de replaceAll-methode van de klasse replaceAll:

String x = "test string (67)".replaceAll(".*\\(|\\).*", "");
// x is now the String "67"

Dit verwijdert eenvoudig alles tot en met de eerste (, en hetzelfde voor de )en alles daarna. Hierdoor blijven de dingen tussen de haakjes staan.

Het resultaat hiervan is echter nog steeds een replaceAll. Als u in plaats daarvan een geheel getal wilt, moet u nog een conversie uitvoeren:

int n = Integer.parseInt(x);
// n is now the integer 67

Antwoord 6, autoriteit 9%

In een enkele regel stel ik voor:

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

Antwoord 7, autoriteit 7%

Je zou hiervoor StringUtils van de apache common library kunnen gebruiken.

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

Antwoord 8, autoriteit 6%

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

Antwoord 9, autoriteit 6%

Teststring test string (67)waaruit u de string moet halen die tussen twee strings is genest.

String str = "test string (67) and (77)", open = "(", close = ")";

Enkele mogelijke manieren opgesomd: Eenvoudige algemene oplossing:

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.

De functie StringUtilsklasse substringBetween()haalt de tekenreeks op die tussen twee tekenreeksen is genest. Alleen de eerste match wordt geretourneerd.

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

Vervangt de gegeven String, door de String die tussen twee Strings is genest. #395


Patroon met reguliere expressies: (\()(.*?)(\)).*

De Dotkomt overeen met (bijna) elk teken
.? = .{0,1}, .* = .{0,}, .+ = .{1,}

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

Regular-Expression met de utility-klasse RegexUtilsen enkele functies.

      Pattern.DOTALL: Komt overeen met elk teken, inclusief een regel terminator.

      Pattern.MULTILINE: Komt overeen met de hele tekenreeks vanaf het begin^tot het einde$van de invoerreeks.

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

Antwoord 10, autoriteit 5%

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

Antwoord 11, autoriteit 4%

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

Gebruik:

String input = "test string (67)";
String startChar = "(";
String endChar   = ")";
String output = getStringBetweenTwoChars(input, startChar, endChar);
System.out.println(output);
// Output: "67"

Antwoord 12, Autoriteit 3%

een andere manier om te doen met behulp van gesplitste methode

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

Antwoord 13, Autoriteit 3%

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

Antwoord 14, Autoriteit 3%

De minst generieke manier waarop ik dit heb gevonden met Regex en Pattern / Matcher-klassen:

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

Dit kan helpen bij meer complexe regexproblemen waar u de tekst tussen twee set tekens wilt ontvangen.


Antwoord 15, Autoriteit 2%

De “generieke” manier om dit te doen is om de snaar vanaf het begin te ontleden, alle personages weg te gooien vóór de eerste beugel, de personages op te nemen na de eerste beugel en de personages weg te gooien na de tweede beugel.

Ik weet zeker dat er een regex-bibliotheek is of iets om het te doen.


Antwoord 16, Autoriteit 2%

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

Antwoord 17, Autoriteit 2%

De andere mogelijke oplossing is om lastIndexOfwaar het op zoek is naar karakter of string van achteruit.

In mijn scenario, ik had het volgende Stringen ik moest <<UserName>>

1QAJK-WKJSH_MyApplication_Extract_<<UserName>>.arc

Dus, indexOfen StringUtils.substringBetweenwas niet nuttig als ze van start gaan zoeken naar karakter.

Dus, ik gebruikte lastIndexOf

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

En, het geeft me

<<UserName>>

Antwoord 18

Zoiets:

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

Antwoord 19

Dit is een eenvoudig te gebruiken \D+regex en klaar.
Dit selecteert alle tekens behalve cijfers, niet nodig om te compliceren

/\D+/

Antwoord 20

het retourneert de originele tekenreeks als de regex niet overeenkomt

var iAm67 = "test string (67)".replaceFirst("test string \\((.*)\\)", "$1");

voeg overeenkomsten toe aan de code

String str = "test string (67)";
String regx = "test string \\((.*)\\)";
if (str.matches(regx)) {
    var iAm67 = str.replaceFirst(regx, "$1");
}

—EDIT—

ik gebruik https://www.freeformatter.com/java -regex-tester.html#ad-outputom regex te testen.

blijkt dat het beter is om ? na * voor minder overeenkomst. zoiets als dit:

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

Antwoord 21

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

Antwoord 22

Kleine uitbreiding naar boven (MadProgrammer) antwoord

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

Other episodes