Reconnaître un modèle pour les expressions régulières

Question

S'il vous plaît, aidez-moi à la façon dont l'utilisation java expression régulière pour le scénario décrit précisément comment reconnaître un motif particulier pour correspondre:

J'ai une chaîne d'entrée qui peut ressembler à ceci:

something + {SomeProductSet1}.count + {SomeOtherProductSet2}.amount > 
    {SomeProductSet3}.count + {SomeUSOC4}.amount 

J'ai besoin de remplacer tout le {} avec quelque chose comme ça

something + [abc].count+[xyz].count+[something].count + [xom].amount+ 
    [ytkd].amount > [d].count 

Fondamentalement, everyth entre "{..}" est-il équivalent à une liste de choses que je mettrai plus tard en utilisant "[..]". J'ai la liste des choses pour [..] mais, comment puis-je "reconnaître" la partie '{...}' C'est de longueur variable et de jeux de caractères variables.

Que devrais-je utiliser comme motif si j'utilise des expressions régulières?

Merci! Très appréciée.

Answer 1

En Java il y a beaucoup de façons de coder pour obtenir le contenu entre parenthèses (ou deux caractères spécifiques d'ailleurs) mais vous voulez en quelque sorte vous amuser avec une expression régulière qui peut être plutôt lente pour ce genre de chose particulièrement lorsqu'il s'agit de plusieurs instances de paires de parenthèses dans une chaîne fournie.

Le code de base que vous voulez rassembler le contenu contenus entre accolades pourrait être quelque chose comme ceci:

String myString = "something + {SomeProductSet1}.count + {SomeOtherProductSet2}.amount > \n" + 
       " {SomeProductSet3}.count + {SomeUSOC4}.amount"; 
Matcher match = Pattern.compile("\\{([^}]+)\\}").matcher(myString); 
while(match.find()) { 
    System.out.println(match.group(1));  
} 

Qu'est-ce qui précède Expression régulière signifie:

• \\{ ouvert ACCOLADE caractère {
• ( début groupe de correspondance
• [ l'un de ces personnages
• ^ pas le caractère suivant
• } avec le ^ précédent, cela signifie « tous les caractères sauf le Fermer ACCOLADE } »
• + l'un des plusieurs autres personnages du [] ensemble
• ) groupe de correspondance d'arrêt
• \\} littéral Fermeture aCCOLADE }

Si elle était moi, je créerais une méthode pour héberger ce code afin qu'il puisse être utilisé pour d'autres types de support, ainsi que: Parenthèses(), Crochets [], accolades {} (comme montré dans le code), chevrons <>, ou même entre deux caractères fournis comme: /.../ ou% ...% ou peut-être même A ... A. Voir la méthode d'exemple ci-dessous qui démontre ceci.

Dans l'exemple de code ci-dessus, il se trouverait dans la boucle tandis que où vous géreriez chaque sous-chaîne trouvée entre chaque ensemble de parenthèses.Vous aurez bien sûr besoin d'un mécanisme pour déterminer quelle sous-chaîne détectée doit être remplacée par n'importe quelle chaîne comme peut-être un tableau multidimensionnel, ou même un dialogue personnalisé qui afficherait la sous-chaîne trouvée entre chaque parenthèse et permettre à l'utilisateur de choisir son remplacement une zone de liste déroulante avec Faire toutes les cases. Il y a bien sûr plusieurs options ici pour savoir comment et ce que vous voulez gérer chaque sous-chaîne trouvée entre chaque ensemble de parenthèses.

Voici un exemple de méthode qui illustre ce dont nous avons discuté ici. Il est bien commenté:

public String replaceBetween(String inputString, String openChar, 
          String closeChar, String[][] replacements) { 
    // If the supplied input String contains nothing 
    // then return a Null String (""). 
    if (inputString.isEmpty()) { return ""; } 

    // Declare a string to hold the input string, this way 
    // we can freely manipulate it without jeopordizing the 
    // original input string. 
    String inString = inputString; 

    // Set the escape character (\) for RegEx special Characters 
    // for both the openChar and closeChar parameters in case 
    // a character in each was supplied that is a special RegEx 
    // character. We'll use RegEx to do this. 
    Pattern regExChars = Pattern.compile("[{}()\\[\\].+*?^$\\\\|]"); 
    String opnChar = regExChars.matcher(openChar).replaceAll("\\\\$0"); 
    String clsChar = regExChars.matcher(closeChar).replaceAll("\\\\$0"); 

    // Create our Pattern to find the items contained between 
    // the characters tht was supplied in the openChar and 
    // closeChar parameters. 
    Matcher m = Pattern.compile(opnChar + "([^" + closeChar + "]+)" + clsChar).matcher(inString); 

    // Iterate through the located items... 
    while(m.find()) { 
     String found = m.group(1); 
     // Lets see if the found item is contained within 
     // our supplied 2D replacement items Array... 
     for (int i = 0; i < replacements.length; i++) { 
      // Is an item found in the array? 
      if (replacements[i][0].equals(found)) { 
       // Yup... so lets replace the found item in our 
       // input string with the related element in our 
       // replacement array. 
       inString = inString.replace(openChar + found + closeChar, replacements[i][1]); 
      } 
     } 
    } 
    // Return the modified input string. 
    return inString; 
} 

Pour utiliser cette méthode, vous pouvez le faire:

// Our 2D replacement array. In the first column we place 
// the substrings we would like to find within our input 
// string and in the second column we place what we want 
// to replace the item in the first column with if it's 
// found. 
String[][] replacements = {{"SomeProductSet1", "[abc]"}, 
          {"SomeOtherProductSet2", "[xyz]"}, 
          {"SomeProductSet3", "[xom]"}, 
          {"SomeUSOC4", "[ytkd]"}}; 

// The string we want to modify (the input string): 
String example = "something + {SomeProductSet1}.count + {SomeOtherProductSet2}.amount > \n" + 
       " {SomeProductSet3}.count + {SomeUSOC4}.amount"; 

// Lets make the call and place the returned result 
// into a new variable... 
String newString = replaceBetween(example, "{", "}", replacements); 

// Display the new string variable contents 
// in Console. 
System.out.println(newString); 

La console doit afficher:

something + [abc].count + [xyz].amount > 
    [xom].count + [ytkd].amount 

Remarquez comment il remplace également les accolades? Cela semble être l'une de vos exigences, mais peut être facilement modifié pour remplacer la sous-chaîne entre les parenthèses. Peut-être que vous pouvez modifier cette méthode (si vous le souhaitez) pour le faire en option et encore une autre fonctionnalité facultative ajoutée .... lui permettent d'ignorer la casse des lettres.