Quoi de neuf avec cette expression régulière ne correspond pas?

Question

public class PatternTest { 
    public static void main(String[] args) { 
    System.out.println("117_117_0009v0_172_5738_5740".matches("^([0-9_]+v._.)")); 
    } 
} 

Ce programme imprime "faux". Quelle?!

Je me attends à correspondre au préfixe de la chaîne: « 117_117_0009v0_1 »

Je sais ce genre de choses, vraiment que je fais ... mais pour la vie de moi, que je suis les yeux fixés sur ce pendant 20 minutes et j'ai essayé toutes les variations auxquelles je peux penser et il me manque évidemment quelque chose de simple et évident ici. En espérant que les nombreux yeux de SO puissent le choisir pour moi avant que je perde la tête à ce sujet.

Merci!

---

La version finale de travail a pris fin comme:

String text = "117_117_0009v0_172_5738_5740"; 
String regex = "[0-9_]+v._."; 

Pattern p = Pattern.compile(regex); 

Mather m = p.matcher(text); 
if (m.lookingAt()) { 
    System.out.println(m.group()); 
} 

Une découverte non évidente/rappel pour moi qui avant d'accéder à des groupes de matcher, l'un des matches() regarderLes() ou trouver() doit être appelé. Si ce n'est pas une exception IllegalStateException est lancée avec le message inutile "Match introuvable". Malgré cela, groupCount() retournera non-zéro, mais il ment. Ne le croyez pas.

J'ai oublié à quel point cette API est moche. Argh ...

Answer 1

par défaut Java colle dans les opérateurs ^ et $, donc quelque chose comme cela devrait fonctionner:

public class PatternTest { 
    public static void main(String[] args) { 
    System.out.println("117_117_0009v0_172_5738_5740".matches("^([0-9_]+v._.).*$")); 
    } 
} 

retours:

vrai

contenu du match:

117_117_0009v0_1 

Ceci est le code que j'utilisé pour extraire le match:

 Pattern p = Pattern.compile("^([0-9_]+v._.).*$"); 
     String str = "117_117_0009v0_172_5738_5740"; 

     Matcher m = p.matcher(str); 
     if (m.matches()) 
     { 
      System.out.println(m.group(1)); 
     } 

Answer 2

I Donno Java saveur d'expression régulière Cependant cette expression régulière PCRE devrait fonctionner ^([\d_]+v\d_\d).+ ne sais pas pourquoi vous utilisez ._. au lieu de \d_\d

Answer 3

Si vous voulez vérifier si une chaîne commence avec le certain modèle que vous devez utiliser Matcher.lookingAt() meth od:

Pattern pattern = Pattern.compile("([0-9_]+v._.)"); 
Matcher matcher = pattern.matcher("117_117_0009v0_172_5738_5740"); 
if (matcher.lookingAt()) { 
    int groupCount = matcher.groupCount(); 
    for (int i = 0; i <= groupCount; i++) { 
    System.out.println(i + " : " + matcher.group(i)); 
    } 
} 

Javadoc:

boolean java.util.regex.Matcher.lookingAt()

tente de faire correspondre la séquence d'entrée, à partir du début de la région , contre le modèle.Comme la méthode des appariements , cette méthode commence toujours au début de la région, ; Contrairement à cette méthode, il n'est pas nécessaire que corresponde à la totalité de la région . Si la correspondance réussit, alors plus d'informations peuvent être obtenues via les méthodes de début, de fin et de groupe. `` GroupCount() `est simplement un wrapper pour la méthode Pattern du même nom