Expressions régulières: 100 erreurs

Question

J'essaie d'en apprendre davantage sur les expressions régulières, mais je ne le fais pas aussi bien après avoir lu le didacticiel Java.

Ce programme est censé prendre un imput au format:

a) ajouter dd dd ensemble b) soustraire 05 de 13 c) ajouter 02-03

et retourner le dd (+ ou -) dd = answer

La (mauvaise) façon dont j'ai configuré ceci est d'avoir le prog essayer de trouver l'une des 3 correspondances, et continuer à le faire jusqu'à ce que l'utilisateur entre "bye". S'il n'y a pas de correspondance, il suffit d'inviter à nouveau l'utilisateur pour une entrée.

Voici mon code! Avec exactement 100 erreurs. :/ Si quelqu'un peut m'aider avec la syntaxe, ce serait vraiment apprécié!

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

    class Calculator { 
     public static void main(String[] args){ 
     Scanner imp = new Scanner(System.in); 
     System.out.println("yes> "); 
     String s = imp.nextLine(); 

     if (s.equals("bye")) { 
      System.exit(0); 
     } 

     while (true) { 

      Pattern p = Pattern.compile(s); //compile string, check for formats 

      Matcher x = p.matcher(\badd\b\s\d\d\s\d\d\s\btogether\b); //format add 12 12 together 
      Matcher y = p.matcher(\bsubtract\b\s\d\d\s\d\d\s\bfrom\b); //format subtract 05 from 13 
      Matcjer z = p.matcher(\badd\b\s\d\d\s\bto\b\s\d\d); //format add 02 to 03 

      boolean b = p.matches; 

      boolean l = x.matches; 
      boolean i = y.matches; 
      boolean g = z.matches; 

      if (l.equals(true)) 
      return (\d\d " + " \d\d " = " \d\d+\d\d); 
      else if (i.equals(true)) 
      return (\d\d " + " \d\d " = " \d\d-\d\d); 
      else if (g.equals(true)) 
      return (\d\d " + " \d\d " = " \d\d+\d\d); 
     } 
     } 
    } 

Answer 1

ugh où commencer ...

Tout d'abord Pattern.compile() attend le regex (les chaînes de format), tandis que la chaîne matcher() attend pour tester contre

@Samir vous a montré ce qui était mal avec les regexes dans le code lui-même (je les ai édité un peu pour plus de clarté)

l.matches a besoin ()

vous ne pouvez pas appeler des méthodes sur variabl booléenne primitive es if(b) est suffisante pour vérifier s'il est vrai ou non

et d'obtenir sous-correspondances spécifiques que vous devez utiliser capturing groups

pour concaténer des chaînes de caractères que vous pouvez utiliser +

à quelque chose de sortie au système de la console. out.println doit être utilisé non retour

avec les erreurs les plus évidentes résolus:

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

class Calculator { 
    public static void main(String[] args){ 
    Scanner imp = new Scanner(System.in); 
    System.out.println("yes> "); 


    while (true) { 
     String s = imp.nextLine();//put getting the input inside the loop or it's infinite 

     if (s.equals("bye")) { 
      System.exit(0); 
     } 

     Matcher x = Pattern.compile("add\\s(\\d+)\\s(\\d+)\\stogether").matcher(s); //format add 12 12 together 
     Matcher y = Pattern.compile("subtract\\s(\\d+)\\sfrom\\s(\\d+)").matcher(s); //format subtract 05 from 13 
     Matcjer z = Pattern.compile("add\\s(\\d+)\\sto\\s(\\d+)").matcher(s); //format add 02 to 03 


     boolean l = x.matches(); 
     boolean i = y.matches(); 
     boolean g = z.matches(); 

     if (l){ 
     System.out.println(l.group(1) + " + " + l.group(2) + " = " + 
      (Integer.parseInt(l.group(1))+Integer.parseInt(l.group(2)))); 
     }else if (i){ 
     System.out.println(i.group(1) + " - " + i.group(2) + " = " + 
      (Integer.parseInt(i.group(1))+Integer.parseInt(i.group(2)))); 
     }else if (g){ 
     System.out.println(g.group(1) + " + " + g.group(2) + " = " + 
      (Integer.parseInt(g.group(1))+Integer.parseInt(g.group(2)))); 
     } 
    } 
    } 
} 

Answer 2

Avez-vous essayé de regarder votre code dans un IDE tel que Eclipse ou IntelliJ IDEA? Ils vont mettre en évidence les erreurs pour vous. Le principal que je vois est que vous ne mettez pas les expressions régulières dans les chaînes. Java n'a pas d'expressions rationnelles natives, vous devrez donc les fournir sous forme de chaînes. Voici un exemple:

Matcher x = p.matcher("\\badd\\b\\s\\d\\d\\s\\d\\d\\s\\btogether\\b"); //format add 12 12 together 

Remarquez comment j'ai doublé les antislashs. C'est parce que c'est le caractère d'échappement dans Java ainsi que dans les expressions rationnelles. Le compilateur interprétera la chaîne ci-dessus comme \badd\b\s\d\d\s\d\d\s\btogether\b, puis l'analyseur d'expression régulière interprétera correctement les caractères d'échappement.