web-dev-qa-db-fra.com

Java - La meilleure façon de saisir TOUTES les chaînes entre deux chaînes? (Regex?)

Cette question me dérange depuis longtemps, mais je cherche essentiellement le moyen le plus efficace de saisir toutes les chaînes entre deux chaînes.

Je le fais depuis de nombreux mois maintenant en utilisant un tas d'index temporaires, de chaînes, de sous-chaînes, et c'est vraiment compliqué. (Pourquoi Java n'a-t-il pas une méthode native telle que String substring(String start, String end)?

Disons que j'ai une chaîne:

abcabc [pattern1]foo[pattern2] abcdefg [pattern1]bar[pattern2] morestuff

L'objectif final serait de produire foo et bar. (Et plus tard pour être ajouté à une JList)

J'ai essayé d'incorporer l'expression régulière dans .split() mais je n'ai pas réussi. J'ai essayé la syntaxe en utilisant ceux de * Et de . Mais je ne pense pas que ce soit vraiment mon intention, d'autant plus que .split() ne prend qu'un seul argument pour se diviser contre.

Sinon, je pense qu'une autre façon est d'utiliser les classes Pattern et Matcher? Mais je suis vraiment flou sur la procédure appropriée.

javaregexstring
31
Justin

Vous pouvez construire l'expression régulière pour le faire pour vous:

// pattern1 and pattern2 are String objects
String regexString = Pattern.quote(pattern1) + "(.*?)" + Pattern.quote(pattern2);

Ceci traitera le pattern1 Et pattern2 Comme du texte littéral , et le texte entre les motifs sera capturé dans le premier groupe de capture . Vous pouvez supprimer Pattern.quote() si vous souhaitez utiliser l'expression régulière, mais je ne garantis rien si vous faites cela.

Vous pouvez ajouter une personnalisation de la façon dont la correspondance doit se produire en ajoutant des indicateurs à regexString.

  • Si vous voulez une correspondance insensible à la casse Unicode, ajoutez (?iu) Au début de regexString, ou fournissez l'indicateur Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE À Pattern.compile méthode.
  • Si vous souhaitez capturer le contenu même si les deux chaînes de délimitation apparaissent sur des lignes, ajoutez (?s) Avant (.*?), C'est-à-dire "(?s)(.*?)", ou indiquez Pattern.DOTALL drapeau à Pattern.compile méthode.

Ensuite, compilez l'expression régulière, obtenez un objet Matcher , parcourez les correspondances et enregistrez-les dans un List (ou tout Collection, c'est à toi).

Pattern pattern = Pattern.compile(regexString);
// text contains the full text that you want to extract data
Matcher matcher = pattern.matcher(text);

while (matcher.find()) {
  String textInBetween = matcher.group(1); // Since (.*?) is capturing group 1
  // You can insert match into a List/Collection here
}

Code de test:

String pattern1 = "hgb";
String pattern2 = "|";
String text = "sdfjsdkhfkjsdf hgb sdjfkhsdkfsdf |sdfjksdhfjksd sdf sdkjfhsdkf | sdkjfh hgb sdkjfdshfks|";

Pattern p = Pattern.compile(Pattern.quote(pattern1) + "(.*?)" + Pattern.quote(pattern2));
Matcher m = p.matcher(text);
while (m.find()) {
  System.out.println(m.group(1));
}

Notez que si vous recherchez le texte entre foo et bar dans cette entrée foo text foo text bar text bar Avec la méthode ci-dessus, vous obtiendrez une correspondance, qui est  text foo text .

77
nhahtdh

Voici une doublure qui fait tout:

List<String> strings = Arrays.asList( input.replaceAll("^.*?pattern1", "")
    .split("pattern2.*?(pattern1|$)"));

La répartition est la suivante:

  1. Supprimer tout jusqu'à pattern1 (requis pour ne pas se retrouver avec une chaîne vide comme premier terme)
  2. Répartir en entrée (non gourmand .*?) Entre motif2 et motif1 (ou fin d'entrée)
  3. Utilisez la méthode utilitaire Arrays.asList() pour générer un List<String>

Voici un code de test:

public static void main( String[] args ) {
    String input = "abcabc pattern1foopattern2 abcdefg pattern1barpattern2 morestuff";
    List<String> strings = Arrays.asList( input.replaceAll("^.*?pattern1", "").split("pattern2.*?(pattern1|$)"));
    System.out.println( strings);
}

Sortie:

[foo, bar]
10
Bohemian

Essaye ça:

String str = "its a string with pattern1 aleatory pattern2 things between pattern1 and pattern2 and sometimes pattern1 pattern2 nothing";
Matcher m = Pattern.compile(
                            Pattern.quote("pattern1")
                            + "(.*?)"
                            + Pattern.quote("pattern2")
                   ).matcher(str);
while(m.find()){
    String match = m.group(1);
    System.out.println(">"+match+"<");
    //here you insert 'match' into the list
}

Il imprime:

> aleatory <
> and <
> <
9
elias