Le moyen le plus rapide de vérifier une chaîne est alphanumérique en Java [fermé]
En l'état actuel des choses, cette question ne convient pas à notre format de questions-réponses. Nous nous attendons à ce que les réponses soient étayées par des faits, des références ou une expertise, mais cette question suscitera probablement un débat, des arguments, des sondages ou une discussion prolongée. Si vous pensez que cette question peut être améliorée et éventuellement rouverte, visitez l'aide centre pour des conseils. Fermé il y a 8 ans.
Quel est le moyen le plus rapide de vérifier qu'une chaîne ne contient que des caractères alphanumériques.
J'ai du code qui va mâcher beaucoup de CPU et je me demande s'il y aura un moyen plus rapide que d'utiliser des expressions régulières pré-compilées.
3 answers
Utilisez la chaîne .correspondances () , comme:
String myString = "qwerty123456";
System.out.println(myString.matches("[A-Za-z0-9]+"));
Ce n'est peut-être pas l'approche absolue "la plus rapide" possible. Mais en général, il ne sert à rien d'essayer de rivaliser avec les personnes qui écrivent la "bibliothèque standard" de la langue en termes de performance.
J'ai écrit les tests qui comparent l'utilisation d'expressions régulières (selon d'autres réponses) à la non-utilisation d'expressions régulières. Tests effectués sur une machine quad core OSX10.8 exécutant Java 1.6
Il est intéressant d'utiliser des expressions régulières s'avère environ 5 à 10 fois plus lent que d'itérer manuellement sur une chaîne. De plus, la fonction isAlphanumeric2() est légèrement plus rapide que isAlphanumeric(). L'un prend en charge le cas où les nombres Unicode étendus sont autorisés, et l'autre est pour quand seulement ASCII standard les numéros sont autorisés.
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.isLetterOrDigit(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;
}
}
Une expression régulière sera probablement assez efficace, car vous spécifiez des plages: [0-9a-zA-Z]. En supposant que le code d'implémentation pour les expressions régulières est efficace, cela nécessiterait simplement une comparaison des limites supérieure et inférieure pour chaque plage. Voici essentiellement ce que devrait faire une expression régulière compilée:
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, car chaque caractère devra être vérifié, et les comparaisons ne pourraient pas vraiment être plus simples.