Comment puis-je trouver une clé dans une carte basée sur un modèle correspondant en Java

Je veux trouver les clés dans une carte avec un motif correspondant.

Ex:-   
    Map<String, String> map = new HashMap<String, String>();
    map.put("address1", "test test test");
    map.put("address2", "aaaaaaaaaaa");
    map.put("fullname", "bla bla");

De carte ci-dessus, je veux récupérer les valeurs de clés qui a le préfixe "adresse". De sorte que dans cet exemple, la sortie doit être les deux premiers résultats ("adresse1" et "adresse2").

Comment puis-je obtenir dynamiquement?

Grâce.

source d'informationauteur

java regex

Vous pouvez saisir le keySet de la carte, puis filtrer pour obtenir des clés qui commence par "adresse" et d'ajouter les clés valides pour une nouvelle série.

Avec Java 8, c'est un peu moins verbeux:

Set<String> set = map.keySet()
                     .stream()
                     .filter(s -> s.startsWith("address"))
                     .collect(Collectors.toSet());

Si vous avez Java 8 fonctions, quelque chose comme cela devrait fonctionner:

    Set<String> addresses = map.entrySet()
                               .stream()
                               .filter(entry -> entry.getKey().startsWith("address"))
                               .map(Map.Entry::getValue)
                               .collect(Collectors.toSet());

Quelque chose comme ceci:

    for (Entry<String, String> entry : map.entrySet()) {
        if (entry.getKey().startsWith("address")) {
            //do stuff with entry
        }
    }

Vous aurez à boucle au moyen de la Touche Set et match le modèle

for(String key : map.keySet()) {
   if(! key.startsWith("address")) {
       continue;
   }

   //do whatever you want do as key will be match pattern to reach this code.
}

J'ai créé une interface...

import java.util.Map;

@FunctionalInterface
public interface MapLookup {
    <V> List<V> lookup(String regularExpression, Map<String,V> map);
}

Et la mise en œuvre

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class MapLookupImpl implements MapLookup {
    @Override
    public <V> List<V> lookup(String regularExpression, Map<String, V> map) {
        final Pattern pattern = Pattern.compile(regularExpression);
        List<String> values  = map.keySet()
                .stream()
                .filter(string -> pattern.matcher(string).matches())
                .collect(Collectors.toList());
        if(values!= null && !values.isEmpty()){
            return values.stream().map((key) -> map.get(key)).collect(Collectors.toList());

        }
        return new ArrayList<>();
    }
}

Le test

public static void main(String[] args){

    Map<String, Integer> map = new HashMap<>();
    map.put("foo",3);
    map.put("bar",42);
    map.put("foobar",-1);

    MapLookup lookup = new MapLookupImpl();

    List<Integer> values = lookup.lookup("\\woo\\w*",map);

    System.out.println(values);
}

Le résultat

[-1, 3]

Ou peut-être que c'est exagéré. Je peux voir une utilisation répétée pour cela, mais.

Pour ceux qui veulent la pré-java8 version:

    public class PreJava8MapLookup implements MapLookup {
    @Override
    public <V> List<V> lookup(String regularExpression, Map<String, V> map) {
        Matcher matcher = Pattern.compile(regularExpression).matcher("");
        Iterator<String> iterator = map.keySet().iterator();
        List<V> values = new ArrayList<>();
        while(iterator.hasNext()){
            String key = iterator.next();
            if(matcher.reset(key).matches()){
                values.add(map.get(key));
            }
        }
        return values;
    }
}

0

Si vous n'avez pas besoin de beaucoup de performance, la navigation sur toutes les touches de votre carte (map.entrySet) pour obtenir ceux correspondant à votre modèle devrait être suffisant.

Si vous avez besoin d'une bonne performance, une solution que j'ai utilisée pour résoudre ce type de problème est l'utilisation d'une base de données en mémoire telles que H2: vous mettez vos données dans une table mémoire, create unique index sur la clé et vous permettra d'obtenir de bonnes performances pour les 2 cas:
- L'obtention d'une valeur associée à la clé (select value from in_mem_table where key = ?'), classique de l'utilisation d'une table de hachage
- Obtention de valeurs associées à une "pattern" (select value from in_mem_table where key like 'adress%')
0

Une façon est de créer une fonction qui permet de rechercher toutes les carte de clés avec une adresse, mais qui permettrait d'éliminer l'avantage de la carte, puisque l'objectif est sans doute d'être rapide.
Une autre façon est de créer une liste ou un tableau contenant toutes les clés en commençant par l'adresse, mais qui vaut seulement si vous voulez juste les clés avec adresse.

Maintenant, avez-vous besoin pour être en mesure de chercher pour rien ou juste d'une chose en particulier? Et avez-vous besoin de la carte ou peut-il être autre chose, comme un tableau ou une liste?

Vous devez vous connecter pour publier un commentaire.