Java Expression régulière offre un avantage de performance?

À la fin, il est en effet itérant sur la chaîne et vérifiant chaque personnage en essayant de trouver une correspondance pour le motif fourni. De plus, il utilise une recul (s'il y a plusieurs façons qui pourraient éventuellement correspondre, le moteur les essayera tous), ce qui pourrait entraîner une très mauvaise performance pour certains cas inhabituels (peu probable que vous rencontriez cela, mais théoriquement possible). Dans le pire des cas, les performances du moteur d'expression régulier Java sont O (2 ^{n ), où n est la longueur de la chaîne d'entrée.}

Il existe des algorithmes pour une correspondance de modèles beaucoup plus rapide fournissant des performances O (n), mais avec moins de caractéristiques comparant les expressions régulières Java.

ici est un article qui discute de cette question dans les détails.

Mais dans la plupart des cas, le moteur d'expression régulier ne sera pas le goulot d'étranglement de la performance de votre application. Il est assez rapide, donc généralement ne vous inquiétez pas à ce sujet à moins que votre profileur ne le pointe. Et il fournit une description déclarative de l'algorithme qui est très utile car la mise en œuvre d'algorithme d'itération presque toujours sera beaucoup plus verbeuse et beaucoup moins lisible.

Juste pour le plaisir, j'ai géré ce micro de référence. Les résultats de la dernière exécution (c.-à-d. Post JVM Warm Up / Jit) sont ci-dessous (les résultats sont assez cohérents d'une course à un autre quand même): XXX PRE>

En d'autres termes, les caractères sont très efficaces, Integer.parseint est aussi efficace que CHAR si la chaîne est un nombre, mais tergue terriblement si la chaîne n'est pas un nombre. Regex est entre les deux. P>

conclusion forte> p>

Si vous analysez une chaîne dans un numéro et que vous vous attendez à ce que la chaîne soit un nombre en général, en utilisant Entreger. Paysint est la meilleure solution (efficace et lisible). La pénalité que vous obtenez lorsque la chaîne n'est pas un nombre ne doit pas être faible si ce n'est pas trop fréquent. P>

PS: Mon regex n'est peut-être pas optimal, n'hésitez pas à commenter. P>

public class TestNumber {

    private final static List<String> numbers = new ArrayList<>();
    private final static List<String> words = new ArrayList<>();

    public static void main(String args[]) {
        long start, end;
        Random random = new Random();

        for (int i = 0; i < 1000000; i++) {
            numbers.add(String.valueOf(i));
            words.add(String.valueOf(i) + "x");
        }

        for (int i = 0; i < 5; i++) {
            start = System.nanoTime();
            regex(numbers);
            System.out.println("regex with numbers " + (System.nanoTime() - start) / 1000000);
            start = System.nanoTime();
            chars(numbers);
            System.out.println("chars with numbers " + (System.nanoTime() - start) / 1000000);
            start = System.nanoTime();
            exception(numbers);
            System.out.println("exceptions with numbers " + (System.nanoTime() - start) / 1000000);

            start = System.nanoTime();
            regex(words);
            System.out.println("regex with words " + (System.nanoTime() - start) / 1000000);
            start = System.nanoTime();
            chars(words);
            System.out.println("chars with words " + (System.nanoTime() - start) / 1000000);
            start = System.nanoTime();
            exception(words);
            System.out.println("exceptions with words " + (System.nanoTime() - start) / 1000000);
        }
    }

    private static int regex(List<String> list) {
        int sum = 0;
        Pattern p = Pattern.compile("[0-9]+");
        for (String s : list) {
            sum += (p.matcher(s).matches() ? 1 : 0);
        }
        return sum;
    }

    private static int chars(List<String> list) {
        int sum = 0;

        for (String s : list) {
            boolean isNumber = true;
            for (char c : s.toCharArray()) {
                if (c < '0' || c > '9') {
                    isNumber = false;
                    break;
                }
            }
            if (isNumber) {
                sum++;
            }
        }
        return sum;
    }

    private static int exception(List<String> list) {
        int sum = 0;

        for (String s : list) {
            try {
                Integer.parseInt(s);
                sum++;
            } catch (NumberFormatException e) {
            }
        }
        return sum;
    }
}