web-dev-qa-db-fra.com

Comment obtenir une chaîne entre deux caractères?

J'ai une ficelle,

String s = "test string (67)";

Je veux obtenir le no 67 qui est la chaîne entre (et).

Quelqu'un peut-il me dire s'il vous plaît comment faire cela? 

javastring
57
Roshanck

Il y a probablement une RegExp vraiment chouette, mais je suis noob dans ce domaine, alors à la place ...

String s = "test string (67)";

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

System.out.println(s);
67
MadProgrammer

Essayez comme ça

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

La signature de la méthode pour la sous-chaîne est la suivante:

s.substring(int start, int end);
51
user2656003

Une solution très utile à ce problème qui ne nécessite pas de votre part l'indexf utilise des bibliothèques Apache Commons.

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

Cette méthode vous permettra même de gérer même s'il existe plusieurs occurrences de la chaîne de fermeture, ce qui ne sera pas facile en recherchant la chaîne de fermeture indexOf.

Vous pouvez télécharger cette bibliothèque ici: https://mvnrepository.com/artifact/org.Apache.commons/commons-lang3/3.4

40
Pini Cheyni

En utilisant une expression régulière:

 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));
22
Grisha Weintraub

Java prend en charge les expressions régulières , mais elles sont plutôt lourdes si vous souhaitez les utiliser pour extraire des correspondances. Je pense que le moyen le plus simple d'obtenir la chaîne souhaitée dans votre exemple consiste à utiliser simplement le support des expressions régulières dans la méthode String de la classe replaceAll:

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

Ceci supprime simplement tout ce qui est à la hauteur, y compris le premier (, et le même pour le ) et tout ce qui suit. Cela laisse juste le truc entre les parenthèses.

Cependant, le résultat est toujours une String. Si vous voulez plutôt un résultat entier, vous devez effectuer une autre conversion:

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

En une seule ligne, je suggère:

String input = "test string (67)";
input = input.subString(input.indexOf("(")+1, input.lastIndexOf(")"));
System.out.println(input);`
9
Rainy
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
6
Piotr Chojnacki
String result = s.substring(s.indexOf("(") + 1, s.indexOf(")"));
3
techlearner

Pour ce faire, vous pouvez utiliser StringUtils de la bibliothèque commune Apache. 

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

La façon la moins générique que j'ai trouvée de le faire avec les classes Regex et 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, ""));
}

Cela peut aider pour les problèmes de regex plus complexes où vous voulez obtenir le texte entre deux jeux de caractères.

2
Tobe

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

    }

}
2
Kumar Vivek Mitra

Une autre façon de faire en utilisant la méthode 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]);
}
2
Jayy

L'autre solution possible consiste à utiliser lastIndexOf où il cherchera un caractère ou une chaîne à l'envers.

Dans mon scénario, je suivais String et je devais extraire <<UserName>>

1QAJK-WKJSH_MyApplication_Extract_<<UserName>>.arc

Ainsi, indexOf et StringUtils.substringBetween n’a pas été utile car ils ont commencé à chercher un personnage à partir du début.

Donc, j'ai utilisé lastIndexOf

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

Et ça me donne 

<<UserName>>
1
Ravi
String s = "test string (67)";

System.out.println(s.substring(s.indexOf("(")+1,s.indexOf(")")));
1
vinod
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 "" ;
}

Utilisation:

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

La méthode "générique" consiste à analyser la chaîne depuis le début, en jetant tous les caractères avant le premier crochet, en enregistrant les caractères après le premier crochet et en jetant les caractères après le second crochet.

Je suis sûr qu'il existe une bibliothèque de regex ou quelque chose à faire.

0
Jonathon Ashworth

Testez String test string (67) à partir duquel vous devez obtenir la chaîne imbriquée entre deux chaînes.

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

Répertorié quelques manières possibles: Solution générique simple:

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 class substringBetween() La fonction obtient la chaîne imbriquée entre deux chaînes. Seul le premier match est retourné.

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

Remplace la chaîne donnée, par la chaîne imbriquée entre deux chaînes. #395

Motif avec des expressions régulières: (\()(.*?)(\)).*

Le Dot correspond à (Presque) N'importe quel caractère .? = .{0,1}, .* = .{0,}, .+ = .{1,}

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

Regular-Expression avec la classe d'utilitaires RegexUtils et certaines fonctions.
Pattern.DOTALL: correspond à n'importe quel caractère, y compris un fin de ligne.
Pattern.MULTILINE: Correspond à la chaîne entière du début^ au fin$ de la séquence d'entrée.

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

S'il vous plaît se référer ci-dessous échantillon. J'ai créé un échantillon selon vos besoins

échantillon: cliquez ici

0
kumaresan_sd

Quelque chose comme ça:

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;
}
0
Ahmad AlMughrabi