Nous avons une entrée de chaîne et les combinaisons suivantes sont valides (par exemple, Ainsi, compte tenu de l'entrée ci-dessus, comment puis-je vérifier si la chaîne contient plusieurs astérisques. dimanche , * dimanche * , sun * jour * , * soleil * jour , su * nda * y )
S'il ne contient qu'un seul astérisque, il s'agit d'une mauvaise entrée.
6 Réponses :
au moins deux manières:
regex
boucle
Vous pouvez supprimer le . * à l'avant et à la fin de la regex et utilisez trouver () à la place. Cela pourrait réellement être un peu plus rapide.
Vous pouvez utiliser si vous voulez exactement em> deux astérisques: P> string.matches code> avec une expression régulière: "^[^*]*(?:\\*[^*]*){2}$"
Quelqu'un pourrait-il s'il vous plaît expliquer cette expression régulière?
Le premier pourrait être décrit comme suit: commence par un nombre de caractères, puis sur la lunette (deux fois) pour trouver un astérisque suivi de plus de caractères. La seconde pourrait être décrite comme suit: commence avec quoi que ce soit en plus d'astérisques, puis regardez-vous (deux fois) pour trouver un astérisque suivi de toute autre chose.
Je pense que ceux-ci ont des insectes en eux, car ils regardent deux fois, mais rien n'empêche la lunette de trouver la même chose deux fois. Je pense que si vous remplaciez le {2} avec {45}, il continuerait de faire correspondre les cordes que 1 ou 2.
Notez également qu'il y a une double barre oblique inverse qui ne fait pas partie de regex, mais est nécessaire (c'est-à-dire en Java) pour obtenir une barre de Blackslash dans le moteur Regex pour échapper à l'astérisque.
int asterisk1 = input.indexOf('*');
boolean hasTowAsterisks = asterisk1 != -1 && input.indexOf('*', asterisk1+1) != -1;
Edit: this solution assumed that the requirement was "has at least two asterisks".
boolean hasTwoAsteriks(String str) {
int i;
if((i = str.indexOf("*")) != -1) {
if ((i = str.indexOf("*", i+1)) != -1)
return true;
return false;
}
Voici une alternative non-regex qui fonctionne avec n'importe quelle chaîne littérale: essentiellement l'algorithme est le suivant:
Et pour le modifier pour vérifier exactement deux astérisques , changez simplement la troisième ligne vers retour (index! = -1) && .
Pour la complétude (bien que plusieurs bonnes réponses aient été fournies, j'aime les meilleurs de Mark et Joachim), voici deux versions basées sur string.split (regex) et String.split (regex, limite) :
(modifier, correction de bugs :) p> J'ai écrit Un peu de référence sur la base de nos réponses (je sais, les repères ne signifient pas grand chose, mais ils sont amusants, et que le mien est probablement merde, je sais.) De toute façon, voici les résultats d'un échantillon : P>
*********************************************************************************
Testing strings with one or less asterisk
Processor: bhups
Finished. Duration: 40 ms, errors: 0
Processor: Bozho (loop version)
Finished. Duration: 33 ms, errors: 0
Processor: Bozho (regex version)
Finished. Duration: 806 ms, errors: 0
Processor: Joachim Sauer
Finished. Duration: 24 ms, errors: 0 <-- winner
Processor: Mark Byers
Finished. Duration: 1068 ms, errors: 0
Processor: seanizer
Finished. Duration: 408 ms, errors: 0
*********************************************************************************
Testing strings with exactly two asterisks
Processor: bhups
Finished. Duration: 14 ms, errors: 0 <-- winner
Processor: Bozho (loop version)
Finished. Duration: 21 ms, errors: 0
Processor: Bozho (regex version)
Finished. Duration: 693 ms, errors: 0
Processor: Joachim Sauer
Finished. Duration: 14 ms, errors: 0 <-- winner
Processor: Mark Byers
Finished. Duration: 491 ms, errors: 0
Processor: seanizer
Finished. Duration: 340 ms, errors: 0
*********************************************************************************
Testing strings with more than two asterisks (not all processors will be included)
Skipping processor bhups
Processor: Bozho (loop version)
Finished. Duration: 63 ms, errors: 0 <-- winner
Skipping processor Bozho (regex version)
Skipping processor Joachim Sauer
Processor: Mark Byers
Finished. Duration: 1555 ms, errors: 0
Processor: seanizer
Finished. Duration: 860 ms, errors: 0
Vous avez raison, je l'ai trouvé moi-même juste avant de lire votre commentaire. corrigé.
Ça devrait être exactement deux