1
votes

Java - extraire le contenu entre crochets (ignorer les crochets imbriqués)?

Je souhaite extraire le contenu de la chaîne entre crochets ( si l'un des crochets contient des crochets imbriqués , il doit être ignoré ).

Exemple :

String in = "c[ts[0],99:99,99:99] + 5 - d[ts[1],99:99,99:99, ts[2]] + 5";

Pattern p = Pattern.compile("\\[(.*?)\\]");
Matcher m = p.matcher(in);

while(m.find()) {
    System.out.println(m.group(1));
}

// print: ts[0, ts[1, 2

Doit renvoyer:

 match1 = "ts[0],99:99,99:99";
 match2 = "ts[1],99:99,99:99, ts[2]";

Le code que j'ai jusqu'à présent ne fonctionne qu'avec des non-imbriqués crochets

c[ts[0],99:99,99:99] + 5 - d[ts[1],99:99,99:99, ts[2]] + 5

java algorithm regex parsing

1 commentaires

Dans devrait ignorer quand il y a des crochets imbriqués, mais dans Devrait retourner il y a des crochets imbriqués des externes? Pouvez-vous ajouter un exemple qui ne doit pas être retourné?

4 Réponses :

2
votes

J'ai créé une fonction pour le faire (pas avec regex, mais ça marche)

  for (int i = 0; i < in.length(); i++){
        char c = in.charAt(i);
        String part = String.valueOf(c);
        int numberOfOpenBrackets = 0;
        if (c == '[') {
            part = "";
            numberOfOpenBrackets++;
            for (int j = i + 1; j < in.length(); j++) {
                char d = in.charAt(j);
                if (d == '[') {
                    numberOfOpenBrackets++;
                }
                if (d == ']') {
                    numberOfOpenBrackets--;
                    i = j;
                    if (numberOfOpenBrackets == 0) {
                        break;
                    }
                }
                part += d;
            }

            System.out.println(part);
            part = "[" + part + "]";
        }

        result += part;
    }

    // print: ts[0],99:99,99:99
    //        ts[1],99:99,99:99, ts[2]

0 commentaires

0
votes

Vous voudrez peut-être ajouter une limite droite dans votre expression et ts commencer et faire glisser tout ce qui se trouve entre les deux, ce qui pourrait fonctionner, peut-être similaire à cette expression :

(ts.*?)(\]\s+\+)

Si nous avons plus de caractères ici: (\ s \ +) code >, vous pouvez simplement l'ajouter avec des OU logiques dans une liste de caractères et cela fonctionnerait toujours.

RegEx

Si ce n'était pas l'expression souhaitée, vous pouvez modifier / changer vos expressions dans regex101.com .

Circuit RegEx

Vous pouvez également visualiser vos expressions dans jex.im :

0 commentaires

1
votes

Sans regex; juste tout droit java:

import java.util.ArrayList;
import java.util.List;

public class BracketParser {

    public static List<String> parse(String target) throws Exception {
        List<String> results = new ArrayList<>();
        for (int idx = 0; idx < target.length(); idx++) {
            if (target.charAt(idx) == '[') {
                String result = readResult(target, idx + 1);
                if (result == null) throw new Exception();
                results.add(result);
                idx += result.length() + 1;
            }
        }
        return results;
    }

    private static String readResult(String target, int startIdx) {
        int openBrackets = 0;
        for (int idx = startIdx; idx < target.length(); idx++) {
            char c = target.charAt(idx);
            if (openBrackets == 0 && c == ']')
                return target.substring(startIdx, idx); 
            if (c == '[') openBrackets++;
            if (c == ']') openBrackets--;
        }
        return null;
    }

    public static void main(String[] args) throws Exception {
        System.out.println(parse("c[ts[0],99:99,99:99] + 5 - d[ts[1],99:99,99:99, ts[2]] + 5"));
    }
}

Code complet sur GitHub

0 commentaires

2
votes

Si l'imbrication est juste un niveau, vous pouvez rechercher une séquence entre les crochets:

une séquence de:
soit n'est pas un [
ou un [ suivi de la séquence la plus courte à

Pattern p = Pattern.compile("\\[([^\\[]|\\[.*?\\])*\\]");
//                             [                   ]
//                              ( not-[ or
//                                        [, shortest sequence to ]
//                                               )* repeatedly

Le problème étant que les crochets doivent être correctement appariés: aucune erreur de syntaxe autorisée.

0 commentaires