Table de hachage avec des Flux en Java 8 Flux à percevoir la valeur de la Carte

Prenons un hashmap

Map<Integer, List> id1 = new HashMap<Integer,List>();

J'ai inséré quelques valeurs dans les deux hashmap.

Par Exemple,

    List<String> list1 = new ArrayList<String>();

    list1.add("r1");
    list1.add("r4");

    List<String> list2 = new ArrayList<String>();
    list2.add("r2");
    list2.add("r5");

    List<String> list3 = new ArrayList<String>();
    list3.add("r3");
    list3.add("r6");

    id1.put(1,list1);
    id1.put(2,list2);
    id1.put(3,list3);
    id1.put(10,list2);
    id1.put(15,list3);

T1) Maintenant, je veux appliquer une condition de filtre sur la clé dans la table de hachage et de récupérer la valeur correspondante(Liste).

Par exemple: Ici, Ma requête est la clé=1, et la sortie doit être "list1"

J'ai écrit

id1.entrySet().stream().filter( e -> e.getKey() == 1);

Mais je ne sais pas comment récupérer une liste de la sortie de ce volet de l'opération.

T2) Encore une fois je veux appliquer une condition de filtre sur la clé dans la table de hachage et de récupérer la liste de listes.

Par exemple: Ici, Ma requête est la clé=1%(j'.e-clés peuvent être 1,10,15), et la sortie doit être 'liste1','liste 2','list3'(liste de listes).

N'utilisez pas de demi-cuite types Génériques. Très probablement, votre carte devrait être Map<Integer, List<String>> plutôt que Map<Integer, List>

InformationsquelleAutor Deepak Shajan | 2015-04-14

Si vous êtes sûr que vous allez obtenir au plus un élément unique qui a traversé le filtre (qui est garanti par votre filtre), vous pouvez utiliser findFirst :

Optional<List> o = id1.entrySet()
                      .stream()
                      .filter( e -> e.getKey() == 1)
                      .map(Map.Entry::getValue)
                      .findFirst();

Dans le cas général, si le filtre peut correspondre à plusieurs Listes, vous pouvez les regrouper dans une Liste de Listes :

List<List> list = id1.entrySet()
                     .stream()
                     .filter(.. some predicate...)
                     .map(Map.Entry::getValue)
                     .collect(Collectors.toList());

InformationsquelleAutor Eran

29

Ce que vous devez faire est de créer un Stream de la Map's .entrySet():
```
//Map<K, V> --> Set<Map.Entry<K, V>> --> Stream<Map.Entry<K, V>>
map.entrySet().stream()
```
De l', vous pouvez .filter() sur ces entrées. Par exemple:
```
//Stream<Map.Entry<K, V>> --> Stream<Map.Entry<K, V>>
.filter(entry -> entry.getKey() == 1)
```
Et pour obtenir les valeurs de il vous .map():
```
//Stream<Map.Entry<K, V>> --> Stream<V>
.map(Map.Entry::getValue)
```
Enfin, vous avez besoin de collecter dans un List:
```
//Stream<V> --> List<V>
.collect(Collectors.toList())
```
Si vous avez une seule entrée, de l'utiliser (NOTE: ce code suppose qu'il existe une valeur; sinon, utilisez .orElse(); voir la javadoc de Facultatif pour plus de détails):
```
//Stream<V> --> Optional<V> --> V
.findFirst().get()
```
- oui, ce code suppose que la valeur existe; OP n'est pas très clair à ce sujet. Ahwell
InformationsquelleAutor fge
4

Pour votre T2, il y a déjà des réponses à votre question. Pour votre T1, et, plus généralement, lorsque vous savez que la clé de filtrage doit donner une valeur unique, il n'y a pas besoin d'utiliser les cours d'eau à tous.

Suffit d'utiliser get ou getOrDefault, j'.e:
```
List<String> list1 = id1.getOrDefault(1, Collections.emptyList());
```
InformationsquelleAutor user2336315

Vous pouvez aussi faire comme ceci

public Map<Boolean, List<Student>> getpartitionMap(List<Student> studentsList) {

    List<Predicate<Student>> allPredicates = getAllPredicates();
    Predicate<Student> compositePredicate =  allPredicates.stream()
                             .reduce(w -> true, Predicate::and)
     Map<Boolean, List<Student>> studentsMap= studentsList
                .stream()
                .collect(Collectors.partitioningBy(compositePredicate));
    return studentsMap;
}

public List<Student> getValidStudentsList(Map<Boolean, List<Student>> studentsMap) throws Exception {

    List<Student> validStudentsList =  studentsMap.entrySet()
             .stream()
             .filter(p -> p.getKey() == Boolean.TRUE)
             .flatMap(p -> p.getValue().stream())
             .collect(Collectors.toList());

    return validStudentsList;
}

public List<Student> getInValidStudentsList(Map<Boolean, List<Student>> studentsMap) throws Exception {

    List<Student> invalidStudentsList = 
             partionedByPredicate.entrySet()
             .stream()
             .filter(p -> p.getKey() == Boolean.FALSE)
             .flatMap(p -> p.getValue().stream())
             .collect(Collectors.toList());

    return invalidStudentsList;

}

Avec flatMap vous obtiendrez juste List<Student> au lieu de List<List<Student>>.

Grâce

InformationsquelleAutor Basit

L'aide d'un jeu de clés-

id1.keySet().stream()
        .filter(x -> x == 1)
        .map(x -> id1.get(x))
        .collect(Collectors.toList())

InformationsquelleAutor Shreya Mour

Vous devez vous connecter pour publier un commentaire.