Le moyen le plus rapide pour vérifier une chaîne alphanumérique en Java

Quel est le moyen le plus rapide pour vérifier qu'une Chaîne ne contient que des caractères alphanumériques.

J'ai un peu de code qui va mâcher beaucoup de CPU et je me demande si il va y avoir un moyen plus rapide que l'utilisation de pré-compilé des expressions régulières.

Mise à JOUR: Donc beaucoup de votes contre, le soin de l'expliquer? Stackoverflow ne doit pas être utilisé pour discuter de l'algorithme à utiliser pour réaliser une tâche peut être plus rapide?

L'optimisation prématurée? Indice de référence? Profilage?
Il n'y a pas de code à montrer, je suis demander ce que le est.
Certaines personnes ont une propension à faire prématuré de l'optimisation, donc, il est bon de poser la question.
stackoverflow.com/questions/11241690/...

OriginalL'auteur Jacob | 2012-10-11

  1. 29

    Utilisation Chaîne de caractères.correspond à(), comme:

    String myString = "qwerty123456";
System.out.println(myString.matches("[A-Za-z0-9]+"));

    Qui ne peut pas être absolue, "le plus rapide" approche possible. Mais en général il n'y a pas beaucoup d'intérêt à essayer de rivaliser avec les personnes qui écrivent de la langue de la "bibliothèque standard" en termes de performances.

    Oui. C# est une fonction standard pour cela. Il semble Java ne fonctionne pas.
    Mais il y a un point. Lorsque vous exécutez le code dans une boucle des millions de fois, et vous pouvez le faire tourner 5 fois plus rapide, il peut avoir un impact significatif à votre message, le temps de traitement, et que les impacts du nombre de serveurs que vous pourriez avoir besoin pour le traitement des messages.
    Je crois que c'est exagéré. Au mieux, vous en faites un petit aspect de la code 5 fois plus rapide. Qui peut être intéressant, le forum votre performance est limitée par cet aspect. Il peut très bien ne pas l'être. Par exemple, si une partie de votre message pipeline de traitement implique l'écriture d'une base de données ou système de fichiers ou de faire tout réseau de communications, ce probable que votre facteur limitant. Il n'y a pas beaucoup de monde réel de cas où la vitesse d'un regex pour vérifier par 5x sera en fait accélérer l'application par 5x (ou n'importe où près de 5x). Et la différence est de moins en moins de lisibilité, de flexibilité et d'extensibilité.
    ...il est important d'optimiser où et quand cela a du sens, oui. Cependant la plupart du temps pour la plupart des applications du monde réel "j'ai fait plus vite en remplacement d'un pare-configurable, regex fonction avec un fixe et statique de la boucle" n'est pas une bonne optimisation.
    Oui, mais vous ne connaissez pas le contexte, le code est utilisé, de sorte que vous ne pouvez pas juger. Dans ce cas particulier, j'ai utilisé ce code pour accélérer un script qui a été le traitement des gigaoctets de fichiers journaux, se raser en 10 minutes ou si la tâche.

    OriginalL'auteur aroth

  2. 21

    J'ai écrit les tests qui permettent de vérifier la "bonne" réponse. Des Tests effectués sur un quad core OSX10.8 machine en cours d'exécution Java 1.6

    Il est intéressant de noter à l'aide d'expressions régulières s'avère être d'environ 5 à 10 fois plus lent que manuellement une itération sur une chaîne. En outre, le isAlphanumeric2() fonction est légèrement plus rapide que isAlphanumeric().

    public class QuickTest extends TestCase {
private final int reps = 1000000;
public void testRegexp() {
for(int i = 0; i < reps; i++)
("ab4r3rgf"+i).matches("[a-zA-Z0-9]");
}
public void testIsAlphanumeric() {
for(int i = 0; i < reps; i++)
isAlphanumeric("ab4r3rgf"+i);
}
public void testIsAlphanumeric2() {
for(int i = 0; i < reps; i++)
isAlphanumeric2("ab4r3rgf"+i);
}
public boolean isAlphanumeric(String str) {
for (int i=0; i<str.length(); i++) {
char c = str.charAt(i);
if (!Character.isDigit(c) && !Character.isLetter(c))
return false;
}
return true;
}
public boolean isAlphanumeric2(String str) {
for (int i=0; i<str.length(); i++) {
char c = str.charAt(i);
if (c < 0x30 || (c >= 0x3a && c <= 0x40) || (c > 0x5a && c <= 0x60) || c > 0x7a)
return false;
}
return true;
}
}

    OriginalL'auteur Jacob

  3. 2

    Une regex va probablement être très efficace, car vous ne spécifier des plages: [0-9a-zA-Z]. En supposant que la mise en œuvre du code de regexes est efficace, ce serait tout simplement besoin d'une limite supérieure et limite inférieure de comparaison pour chaque gamme. Voici en gros ce compilé regex doit faire:

    boolean isAlphanumeric(String str) {
for (int i=0; i<str.length(); i++) {
char c = str.charAt(i);
if (c < 0x30 || (c >= 0x3a && c <= 0x40) || (c > 0x5a && c <= 0x60) || c > 0x7a)
return false;
}
return true;
}

    Je ne vois pas comment votre code pourrait être plus efficace que cela, parce que chaque personnage devra être vérifiée, et les comparaisons ne pouvait pas vraiment être en toute simplicité.

    Ses éventuellement, va être entre les ce et String.matches(). J'ai été un peu en espérant que quelqu'un l'a fait avant. Regarde comme je vais avoir à écrire le test moi-même (:
    Tout dépend de l'utilisation. Il n'y a pas de moyen standard de la création de l'idéal de l'algorithme pour l'ensemble de la chaîne de match scénarios. Regex peut servir dans une grande mesure, mais juste parce qu'il semble complexe et ringard, n'est-ce pas de la rendre plus efficace. Pour+ de 100 itérations par seconde, je serais certainement envisager une personnalisation de l'algorithme.

    OriginalL'auteur snibbets