Séparer la chaîne en paires clé-valeur

Vous pourriez faire un seul appel à la fonction split() et un seul passage sur la Chaîne à l'aide du code suivant. Mais cela suppose bien sûr que la Chaîne est valide en premier lieu:

    Map<String, String> map = new HashMap<String, String>();
    String test = "pet:cat::car:honda::location:Japan::food:sushi";

    //split on ':' and on '::'
    String[] parts = test.split("::?");

    for (int i = 0; i < parts.length; i += 2) {
        map.put(parts[i], parts[i + 1]);
    }

    for (String s : map.keySet()) {
        System.out.println(s + " is " + map.get(s));
    }

Ci-dessus est probablement un peu plus efficace que votre solution, mais si vous trouvez que votre code plus clair, puis le garder, car il n'y a presque aucune chance que cette optimisation a un impact significatif sur les performances, à moins que vous faire des millions de fois. De toute façon, si c'est si important, alors vous devriez mesurer et de comparer.

EDIT:

pour ceux qui se demandent ce ::? signifie dans le code ci-dessus: String.split() prend une expression régulière comme argument. Un séparateur est une sous-chaîne correspondant à l'expression régulière. ::? est une expression régulière qui signifie: 1 colon, suivi de 0 ou 1 du côlon. Elle permet ainsi de considérer :: et : comme séparateurs.

Votre solution est en effet quelque peu inefficace.

La personne qui vous a donné la chaîne à analyser est aussi un peu un clown. Il y a de la norme de l'industrie des formats de sérialisation, comme JSON ou XML, pour lequel la rapidité, l'efficacité analyse existent. Inventer la roue carrée n'est jamais une bonne idée.

Première question: vous intéressez-vous? Est-il assez lent, qu'il diminue les performances de votre application? Probablement pas, mais il n'y a qu'une seule façon de le savoir. Tester les performances de votre code.

Cela dit, la plus efficace des solutions existent. Ci-dessous est un exemple

public static void main (String[] args) throws java.lang.Exception
{
    String test = "pet:cat::car:honda::location:Japan::food:sushi";
    boolean stateiskey = true;

    Map<String, String> map = new HashMap<>();
    int keystart = 0;
    int keyend = 0;
    int valuestart = 0;
    int valueend = 0;

    for(int i = 0; i < test.length(); i++){
        char nextchar = test.charAt(i);
        if (stateiskey) {
            if (nextchar == ':') {
              keyend = i;           
              stateiskey = false;
              valuestart = i + 1;
            }
        } else {
            if (i == test.length() - 1 || (nextchar == ':' && test.charAt(i + 1) == ':')) {
                valueend = i;
                if (i + 1 == test.length()) valueend += 1; //compensate one for the end of the string
                String key = test.substring(keystart, keyend);
                String value = test.substring(valuestart, valueend);
                keystart = i + 2;
                map.put(key, value);
                i++;
                stateiskey = true;
            }
        }
    }

    System.out.println(map);
}

Cette solution est une machine à état fini avec seulement deux états. Il ressemble à tous les personnages que deux fois, une fois quand il teste pour une limite, et une fois quand il le copie dans la nouvelle chaîne de caractères dans votre carte. C'est le montant minimum.

Il n'est pas de créer des objets qui ne sont pas nécessaires, comme stringbuilders, des chaînes ou des tableaux, ce qui maintient la collecte de pression faible.

Il entretient de bonnes localité. Le caractère suivant sans doute est toujours dans le cache, de sorte que la recherche n'est pas cher.

Il arrive à un coût exorbitant qui n'est probablement pas la peine:

• C'est beaucoup plus compliqué et moins évident
• Il y a toutes sortes de pièces en mouvement
• Il est plus difficile de débogage lors de votre chaîne est dans un format inattendu
• Vos collègues vous déteste
• Vous vous déteste quand vous devez déboguer quelque chose

En vaut la peine? Peut-être. À quelle vitesse avez-vous besoin de cette chaîne analysée exactement?

Un rapide et sale de référence à https://ideone.com/8T7twy me dit que pour cette chaîne, cette méthode est environ 4 fois plus rapide. Pour les chaînes plus longues, la différence est probablement un peu plus.

Mais votre version est encore seulement 415 millisecondes pour 100.000 répétitions, où celui-ci est de 99 millisecondes.

Votre programme est absolument parfait.

Juste parce que vous avez demandé pour une utilisation plus optimale de code.

J'ai réduit votre mémoire en prenant quelques variables, au lieu de prendre de tableaux et de stockage.

Regarder votre chaîne, il suit un crépitement.

key : value :: key : value ::....

Que pouvons-nous faire de tout cela?

obtenir la clé jusqu'à ce qu'il est : , une fois qu'il atteint : d'obtenir la valeur, jusqu'à ce qu'il atteigne '::'.

package qwerty7;
import java.util.HashMap;
public class Demo {
public static void main(String ar[])
{
StringBuilder s = new StringBuilder("pet:cat::car:honda::location:Japan::food:sushi");
boolean isKey = true;
String key = "", value = "";
HashMap<String, String> hm = new HashMap();
for(int i = 0; i < s.length(); i++)
{
char ch = s.charAt(i);
char nextChar = s.charAt(i+1);
if(ch == ':' && nextChar != ':')
{
isKey = false;
continue;
}
else if(ch == ':' && nextChar == ':')
{
hm.put(key, value);
isKey = true;
key = "";
value = "";
i+=1;
continue;
}
if(isKey)
{
key += ch;
}
else
{
value += ch;
}
if(i == s.length() - 1)
{
hm.put(key, value);
}
}
for (String x : hm.keySet()) {
System.out.println(x + " is " + hm.get(x));
}
}
}

Faisant, cela ne prendra pas beaucoup d'itérations sur le fractionnement à chaque fois.

Ne prend pas trop de mémoire.

Complexité temporelle O(n)

De sortie:

car is honda
location is Japan
pet is cat
food is sushi