Remplacer les valeurs de Chaîne avec la valeur de Hachage de la Carte

Je suis nouveau à la Programmation Java. J'ai créé un tableau associatif qui contient mes paires Clé-Valeur à utiliser en remplacement de la saisie de l'utilisateur avec la valeur correspondant à la clé respective.

c'est à dire

        HashMap<String,String> questionKey = new HashMap<>();             

         for (item : itemSet()) {
             questionKey.put(String.valueOf(item.getOrder()+1), item.getKey());                                
         }                    
        String list = commandObject.getObjectItem().getList();

        if (list.contains("q")){                
            list.replaceAll("q01", questionKey.get("1"));               
            commandObject.getObjectItem().setList(list);
        }

Je me sers de ce dans une formule d'évaluation

Note: les Utilisateurs bénéficient d'une certaine formule spécifique d'entrée (valeur1 + valeur2 + valeur3)

Je vais prendre que (valeur1 valeur2 valeur3) et de le convertir (value1key value2key value3key)

Mise à jour:

La Question que je le comprends mieux maintenant était censé être pour aider à mieux comprendre comment utiliser une table de hachage afin d'évaluer la saisie de l'utilisateur. La plus claire, la question serait

Quelle serait la meilleure approche pour évaluer une expression, c'est à dire

La Saisie de l'utilisateur = "var1 + var2"

Valeur attendue: valueOf(var1) + valueOf(var2)

Qui est la question/problème?
Votre code n'est pas même à distance de la compilation. Même pas sûr de ce que vous essayez d'atteindre est compréhensible. Veuillez fournir le code compilable, trace de la pile le cas échéant, et une meilleure portée.
et la question est..?
Pour Clarifier ce est un traitement au Printemps et je suis tenter de prendre l'entrée de l'utilisateur et de le remplacer avec le correspondant keyValue lorsque le formulaire est envoyé à la base de données comme référence pour plus tard, la formule de calcul.
Je peux poster le code de pseudo avec un peu plus de détails si cela vous aide.

OriginalL'auteur DD84 | 2013-09-03

18
```
@Test
public void testSomething() {
    String str = "Hello ${myKey1}, welcome to Stack Overflow. Have a nice ${myKey2}";
    Map<String, String> map = new HashMap<String, String>();
    map.put("myKey1", "DD84");
    map.put("myKey2", "day");
    for (Map.Entry<String, String> entry : map.entrySet()) {
        str = str.replace("${" + entry.getKey() + "}", entry.getValue());
    }
    System.out.println(str);        
}
```
De sortie:

Bonjour DD84, bienvenue à Débordement de Pile. Have a nice day

Pour quelque chose de plus complexe, je préfère utiliser OGNL.

J'ose poser des questions dans les forums ou sur ce site parce que tout ce que je reçois est ridicule, même en tant que débutant. J'essaie d'apprendre tout comme n'importe qui d'autre. @AlfredoOsorio merci pour votre réponse, mais faire sarcastique de la nature-je choisir de ne pas l'accepter comme ma réponse.
Juste assez
Juste un conseil amical, la chose importante ici est d'apprendre. Je ne pense pas que le Sarcasme devrait prendre effet d'ici quelque sorte. Il suffit de le prendre pour l'instant et puis peut-être après quelques mois à répondre à certaines de Alfredo questions. 🙂
Merci pour les conseils. Je vais prendre cela en considération.

OriginalL'auteur Alfredo Osorio

import java.util.HashMap;

class Program
{
    public static void main(String[] args)
    {
        String pattern = "Q01 + Q02";
        String result = "";

        HashMap<String, String> vals = new HashMap<>();

        vals.put("Q01", "123");
        vals.put("Q02", "123");

        for(HashMap.Entry<String, String> val : vals.entrySet())
        {
            result = pattern.replace(val.getKey(), val.getValue());
            pattern = result;
        }

        System.out.println(result);

    }
}

Il est plus efficace d'utiliser StringBuilder dans result variable. Rappelez-vous String est immuable.
Il est plus efficace pour effectuer une itération sur la chaîne que sur la carte. La chaîne peut être court, et la carte peut contenir des millions d'entrées.

OriginalL'auteur DD84

Java 8 révèle une approche fonctionnelle qui est donné dans ce post.

Vous êtes en création d'une nouvelle fonction pour chaque mot de votre carte et de la chaîne d'ensemble.
e.g:

public static void main(String[] args) {
    Map<String, String> dictionary = new HashMap<>();
    String stringToTranslate = "key1 key2"
    dictionary.put("key1", "value1");
    dictionary.put("key2", "value2");
    String translation = dictionary.entrySet().stream()
        .map(entryToReplace -> (Function<String, String>) s -> s.replace(entryToReplace.getKey(), 
             s.replace(entryToReplace.getValue())
        .reduce(Function.identity(), Function::andThen)
        .apply(stringToTranslate);
}

Il est plus efficace pour effectuer une itération sur la chaîne que sur la carte. La chaîne peut être court, et la carte peut contenir des millions d'entrées.

OriginalL'auteur David Barda

Vous devez vous connecter pour publier un commentaire.