À l'aide de Java pour rechercher une sous-chaîne d'une grande chaîne à l'aide de l'Expression Régulière

Question

Si j'ai une chaîne de caractères comme ceci:

FOO[BAR]

J'ai besoin d'un générique de façon à obtenir le "BAR" de la chaîne de la chaîne de sorte que n'importe quelle chaîne est entre les crochets, il serait en mesure d'obtenir la chaîne de caractères.

par exemple

FOO[DOG] = DOG
FOO[CAT] = CAT

Answer 1

Vous devriez être en mesure d'utiliser la non-greedy quantificateurs, spécifiquement *?. Vous allez probablement vouloir le suivant:

Pattern MY_PATTERN = Pattern.compile("\\[(.*?)\\]");

Cela vous donnera un modèle qui correspondra à votre chaîne et de mettre le texte entre crochets dans le premier groupe. Avoir un regard sur le Modèle de la Documentation de l'API pour plus d'informations.

Pour extraire la chaîne, vous pouvez utiliser quelque chose comme ce qui suit:

Matcher m = MY_PATTERN.matcher("FOO[BAR]");
while (m.find()) {
    String s = m.group(1);
    // s now contains "BAR"
}

Answer 2

le non-regex façon:

String input = "FOO[BAR]", extracted;
extracted = input.substring(input.indexOf("["),input.indexOf("]"));

sinon, pour des performances légèrement meilleures/l'utilisation de la mémoire (merci Hosam):

String input = "FOO[BAR]", extracted;
extracted = input.substring(input.indexOf('['),input.lastIndexOf(']'));

Answer 3

C'est un exemple de travail :

RegexpExample.java

package org.regexp.replace;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexpExample
{
    public static void main(String[] args)
    {
        String string = "var1[value1], var2[value2], var3[value3]";
        Pattern pattern = Pattern.compile("(\\[)(.*?)(\\])");
        Matcher matcher = pattern.matcher(string);

        List<String> listMatches = new ArrayList<String>();

        while(matcher.find())
        {
            listMatches.add(matcher.group(2));
        }

        for(String s : listMatches)
        {
            System.out.println(s);
        }
    }
}

Il affiche :

value1
value2
value3

Answer 4

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public static String get_match(String s, String p) {
    // returns first match of p in s for first group in regular expression 
    Matcher m = Pattern.compile(p).matcher(s);
    return m.find() ? m.group(1) : "";
}

get_match("FOO[BAR]", "\\[(.*?)\\]")  // returns "BAR"

public static List<String> get_matches(String s, String p) {
    // returns all matches of p in s for first group in regular expression 
    List<String> matches = new ArrayList<String>();
    Matcher m = Pattern.compile(p).matcher(s);
    while(m.find()) {
        matches.add(m.group(1));
    }
    return matches;
}

get_matches("FOO[BAR] FOO[CAT]", "\\[(.*?)\\]")) // returns [BAR, CAT]

Answer 5

Je pense que votre expression régulière serait:

/FOO\[(.+)\]/

En supposant que TOTO va être constante.

Donc, pour mettre cela en Java:

Pattern p = Pattern.compile("FOO\\[(.+)\\]");
Matcher m = p.matcher(inputLine);