Existe-t-il un moyen plus rapide d'analyser une chaîne pour les entiers valides en Java?

Si les performances sont le problème dans votre cas, je ne pense pas que l'API Stream soit une bonne solution.

static ArrayList<Integer> getIntegers(String requestData) {
            char[] charArray = requestData.toCharArray();
             ArrayList<Integer> numbers = new ArrayList<>();
            for(char c : charArray) {

                if(Character.isDigit(c)) {
                    numbers.add(Integer.valueOf(c) - 48);
                }
            }
            return numbers;
        }

Que diriez-vous d'utiliser une pile?

Nous pouvons mettre à jour le problème des accolades équilibrées .

Lors de l'itération de la chaîne, si le caractère est notBracket () , alors ce doit être un nombre. Inutile de dire que vous ignorez toutes les virgules. Simultanément, il vérifiera également la structure du tableau.

Cela a une complexité amortie de O (n) .

Vous pouvez obtenir de meilleures performances en analysant des modèles positifs (par exemple \ d + ) au lieu de négatifs ( [^ \ d] + ).

List<Integer> extractNumbersStreamTokenizer(String str) throws IOException {
    StreamTokenizer s = new StreamTokenizer(new StringReader(str));
    ArrayList<Integer> numbers = new ArrayList<>();
    int token;
    while ((token = s.nextToken()) != StreamTokenizer.TT_EOF) {
        if (token == StreamTokenizer.TT_NUMBER) {
            numbers.add((int) s.nval);
        }
    }
    return numbers;
}

J'ai bricolé un peu et créé la classe suivante:

List<Integer> integers = new JsonNumberParser(jsonRequest).parse();

Bien sûr, vous pouvez mettre tout cela dans une seule méthode, mais vous obtiendrez alors une duplication de code concernant le ajout de Integers.

Le fonctionnement de cet analyseur est qu'il utilise un tampon, pour tamponner les chiffres, jusqu'à ce que nous rencontrions une virgule. De cette façon, nous pouvons avoir de grands nombres (jusqu'à 64 chiffres dans cette implémentation) dans le json.

Vous pouvez utiliser ceci comme indiqué dans l'exemple suivant:

class JsonNumberParser {
    private final String json;
    private final int length;
    private final List<Integer> result;
    private final char[] buffer = new char[64];
    private int bufferIndex = 0;

    public JsonNumberParser(String json) {
        this.json = json;
        length = json.length();
        result = new ArrayList<>(length);
    }

    public List<Integer> parse() {
        char c;
        for (int i = 0; i < length; i++) {
            c = json.charAt(i);
            // if we encounter a comma and the buffer contains data
            if (c == ',' && bufferIndex > 0) {
                // then we add the new number
                addBuffer();
                // and reset the buffer
                while (bufferIndex > 0) {
                    buffer[--bufferIndex] = '\0';
                }
            } else if (c == '-' || (c >= '0' && c <= '9')) {
                buffer[bufferIndex++] = c;
            }
        }
        // add the last possible number, if there was any
        if (bufferIndex > 0) {
            addBuffer();
        }

        // return the result
        return result;
    }

    private void addBuffer() {
        result.add(Integer.valueOf(new String(buffer, 0, bufferIndex)));
    }
}

En ce qui concerne les performances, je m'attends à ce que ce soit beaucoup plus rapide que d'utiliser un Regex . Mais je n'ai malheureusement pas de configuration de référence sous la main

Gardez à l'esprit que ce n'est pas un validateur, donc une chaîne json: [[]}] produirait simplement une Liste p >

(Peut-être) Améliorations : J'ai réfléchi et cherché un peu plus. Voici quelques améliorations qui pourraient améliorer les performances:

1. On pourrait simplement réinitialiser le buffer en l'attribuant avec un new int [64] , ce qui produirait plus de déchets, mais à la fin peut être plus rapide.

2. L'analyse du nombre pourrait être amélioré en utilisant la réponse suggérée ici . Ce qui utilise simplement de vieilles mathématiques et aucune création de chaînes et analyse d'entiers.

Cette réponse va déjà dans la bonne direction. La première étape importante est de déplacer l'opération coûteuse Pattern.compile hors de la méthode, car l'instance de Pattern peut être réutilisée.

De plus, l'itération sur le nombre correspond enregistre vous dès la création du tableau de split . Maintenant, vous pouvez également ignorer la création de sous- String :

static final Pattern NUMBER = Pattern.compile("-?\\d+");
static ArrayList<Integer> getIntegers(String requestData) {
    ArrayList<Integer> numbers = new ArrayList<>();
    Matcher m = NUMBER.matcher(requestData);
    while(m.find()) numbers.add(parseInt(requestData, m.start(), m.end()));
    return numbers;
}

static int parseInt(CharSequence cs, int start, int end) {
    int pos = start;
    if(pos >= end) throw format(cs, start, end);
    boolean negative = cs.charAt(pos) == '-';
    if((negative || cs.charAt(pos) == '+') && ++pos==end)
        throw format(cs, start, end);
    int value = 0;
    for(; pos < end; pos++) {
        int next = cs.charAt(pos) - '0';
        if(next < 0 || next > 9) throw format(cs, start, end);
        if(value < Integer.MIN_VALUE/10) throw size(cs, start, pos, end);
        value = value * 10 - next;
    }
    if(value > 0 || !negative && value == Integer.MIN_VALUE)
        throw size(cs, start, pos, end);
    return negative? value: -value;
}
private static RuntimeException format(CharSequence cs, int start, int end) {
    return start > end? new IndexOutOfBoundsException(end+" < "+start):
        new NumberFormatException(start == end?
            "empty string": cs.subSequence(start, end).toString());
}
private static RuntimeException size(CharSequence cs, int start, int pos, int end) {
    for(; pos < end; pos++) 
        if(cs.charAt(pos) < '0' || cs.charAt(pos) > '9') return format(cs, start, end);
    return new NumberFormatException(cs.subSequence(start, end)+" outside the int range");
}

Integer.parseInt (CharSequence s, int beginIndex, int endIndex, int radix) a été ajouté dans Java 9. Si vous utilisez une version plus ancienne, vous pouvez en créer votre propre variante. Pour simplifier, ne prend désormais en charge qu'une base de 10:

static final Pattern NUMBER = Pattern.compile("\\d+");
static ArrayList<Integer> getIntegers(String requestData) {
    ArrayList<Integer> numbers = new ArrayList<>();
    Matcher m = NUMBER.matcher(requestData);
    while(m.find()) numbers.add(Integer.parseInt(requestData, m.start(), m.end(), 10));
    return numbers;
}