J'apprends regex et j'ai ce fragment de code: essayez un autre moyen: i commentaire ce problème dans cet extrait que ci-dessus. Y a-t-il quelqu'un qui peut expliquer pourquoi? Merci beaucoup!
4 Réponses :
Vous pouvez correspondeur réinitialiser ()
réinitialise ce matcheur.
La réinitialisation d'un correspondeur élimine toutes ses informations d'état explicites et définit sa position ajoutée à zéro. La région du matcheur est définie sur la région par défaut, qui est toute sa séquence de caractères. L'ancrage et la transparence des limites de la région de ce matcheur ne sont pas affectées.Si vous voulez que le thread Safe, mettez-le à l'intérieur
Synchroniser Block
Je ne sais pas sur synchroniser bloc. J'ai besoin de compléter ma tâche dans aujourd'hui après-midi. Y a-t-il un autre moyen d'archiver thread-coffre-fort?
Voir un exemple ici: docs.oracle.com/javase/tatuly/essential / Concurrence / ...
Problème est que vous créez une nouvelle correspondance code> à chaque fois dans si code> condition et pendant code> blocs de boucle ici: String str = ",Share %,\"Date Purchased\",Display Name,Address,Phone,Fax,Mobile,Email,";
Matcher beginningFileMatcher = Pattern.compile(FILE_BEGINNING_PATTERN).matcher(str);
// find() method starts at the beginning of this matcher's region, or, if
// a previous invocation of the method was successful and the matcher has
// not since been reset, at the first character not matched by the previous
// match.
//
int count = 0;
while (beginningFileMatcher.find()) { // find not match, we need beginningFileMatcher.reset() but its not
if (count == 0)
System.out.println("Regex match!");
// thread-safe.
count++;
System.out.println("COUNT ++++++++++++++ :" + count);
}
//try another way.
String s = ",Share %,\"Date Purchased\",Display Name,Address,Phone,Fax,Mobile,Email,";
Pattern beginningFilePattern = Pattern.compile(FILE_BEGINNING_PATTERN);
Matcher matcher = beginningFilePattern.matcher(s);
int countCount = 0;
while (matcher.find()) { // make sure to use matcher object
if (countCount == 0)
System.out.println("Thread-safe regex match!");
countCount++;
System.out.println("COUNT ++++++++++++++ :" + countCount);
}
Il n'est pas clair dans la question mais opt posté 2 version de son code. Premier avec un seul matcheur et deuxième avec la boucle infinie. Votre solution est la même que celle de l'OP en premier. Il ne lui donnera toujours pas le résultat correct si le matcheur ne correspond à une seule fois
Il corrige le problème de la boucle infinie que OP posté en raison de la raison de l'état en réponse.
@anubhava: Merci, mais y a-t-il une autre façon de le faire, mais assurez-vous toujours le fil-faire?
Le do-tout est une bonne idée, mais il retournera 1 si le motif ne correspond pas
@anubhava: Quand je fais: DébutFilematcher.Reset () puis utilise le matcheur dans la boucle.
@LogBaseex: Vérifiez la réponse mise à jour. Il n'est pas nécessaire d'utiliser .reset () n'importe où.
@anubhava: cela a fonctionné bien, monsieur. Mais je cherche toujours un moyen de simplifier. Supposons que j'ai un fichier CSV avec 1000 lignes. Je dois extraire le nom avant la première virgule de chaque ligne si ce nom correspond à ma regex (E.g: ^ (\ w) \ s (\ w) (? =,) ). Ce que je veux faire, c'est remplacer toutes les regex correspondances avec la chaîne vide et comptez le nombre de lignes correspondant à un seul bloc de code. Avez-vous de bonnes idées?
Cela peut être fait facilement à l'aide de regex: (? M) ^ \\ w + \\ s + \\ w + (? =,) dans cet appel: data = data.replaceall ("(? m) ^ \\ w + \\ s + \\ w + (? =,) "," "); où data est l'objet de chaîne contenant des données CSV complètes.
Avec une ancre, ça a bien fonctionné, mais si je veux compter combien de lignes correspondues, je dois le faire dans une autre boucle. Toute suggestion, monsieur? @anubhava
Oui Pour obtenir un compte, vous avez besoin d'une boucle de tandis que (correspondeur.find ()) et vous pouvez obtenir le nombre de remplaçants à la fois dans la même boucle. Donc au lieu de data.replaceall vous pouvez faire correspondeur.replacefirst (""); Comptez ++
Je pense que le problème est que, lorsque vous appelez davantagefileppattern.matcher (s) .Find () , vous créez une nouvelle instance de la correspondance à l'intérieur du pendant état. Chacun de ces nouveaux matchers vérifiera à nouveau depuis le début au lieu d'essayer de trouver la prochaine occurrence. Vous devriez essayer de faire votre réinitialiser () appeler la menace de sécurité, mais conservez la même instance de correspondant.
Chaque version de votre code a un problème différent.
pour la version 2 (boucle inifinite): vous créez le matcheur dans la boucle. Cela signifie que sur chaque itération, il y aura un nouveau mateleur, à partir du début de votre chaîne. Donc, l'appel à Votre première solution est ce que vous devez faire, créer une correspondance une fois, puis l'utiliser en appelant Trouver Code> dans une boucle. p> Le problème est que vous appelez Et si la chaîne ne contient que 1 résultat correspondant? p> Si vous ne réinitialisez pas le correspondeur avant de boucler, vous devez compter le résultat du trouver code> renvoie toujours le même résultat, le cas échéant. P> trouver code> dans 2 endroits différents. D'abord dans le bloc si code>, pour voir s'il y a des correspondances dans votre chaîne, alors dans la boucle. P>
si code> bloque li>
compteur code> est défini sur 0 code> li>
Nombre: 0 code> li>
ul> si code> bloque dans votre compteur. Voici une solution avec des modifications minimales: p> final static String FILE_BEGINNING_PATTERN = "^(,Share %)";
public static void main(String[] args) {
String str = ",Share %,\"Date Purchased\",Display Name,Address,Phone,Fax,Mobile,Email,";
Matcher beginningFileMatcher = Pattern.compile(FILE_BEGINNING_PATTERN).matcher(str);
int count = 0;
if (beginningFileMatcher.find()) {
System.out.println("Regex match!");
count++; // already a match, increment the counter
}
while (beginningFileMatcher.find()) {
count++;
System.out.println("COUNT ++++++++++++++ :" + count);
}
}
Si vous devez vérifier une fois, utilisez
si , pourquoipendant ?si (DébutFilePattern.matcher (s) .Find ())non liée:
compteur doit être initialisé à1 si le premiersi le bloc est vrai.@ Wiktorstribiżew: Ceci est le code de test. J'ai besoin de compter combien d'occurrences existent pour une condition de contrôle à un autre endroit.
@Jhamon: Je ne sais pas pourquoi? Je suis vraiment confus.
En tout cas, il n'y aura qu'une correspondance, car
^ (, partager%) nécessite une correspondance au début de la chaîne.Dans la première solution, la première correspondance est trouvée par le
Rechercher dans le bloc si , doncla valeur de compte doit être 1, puis lePendant que compterait les autres correspondances (le cas échéant). Le meilleur moyen serait de supprimer le bloc IF et n'utilisez que le moment.@Jhamon: Non,
Nombre ne sera pas1 cartandis que (Débutfilematcher.find ()) ne s'exécute pas. Étant donné quetrouver () retournera simplement fausse deuxième fois.@anubhava C'est le problème, il devrait être 1 lorsque le
si est vrai car il y avait une correspondance précédenteJe ne comprends pas votre obsession de la sécurité du fil. Votre code n'implique pas de multithreading, alors pourquoi vous inquiétez-vous de la sécurité des threads?
@ Thomaskläger: Désolé pour ma stupidité, il y a une chose que je suis vraiment confondue. Le programme Java est-il en cours d'exécution avec un mode de concurrence dans des noms d'ordinateur modernes tels que un ordinateur avec des multi-noyaux de l'intérieur ou un programme Java uniquement en mode Concurrence si j'utilise déjà
thread ouexécutable Dans mon code?Une application Java simple comme votre exemple est toujours unique. Seulement lorsque vous commencez à utiliser des threads (via la classe , via
exécutantservice et des classes associées ou à l'aide de Swing) aurez-vous à vous soucier de la sécurité du thread. Mais même un objet que vous créez et que vous utilisez dans une seule méthode est uniquement utilisé à partir d'un seul fil. (Un autre thread pourrait exécuter cette même méthode en même temps, mais cet autre thread créerait et utiliserait son propre objet.)@ Thomaskläger: merci!