Java 8 lambda: convertir Collection de Carte de l'élément, l'itération de la position

Voici une approche:

List<String> list = Arrays.asList("a", "b", "c");

Map<String, Integer> map =
    IntStream.range(0, list.size())
        .boxed()
        .collect(toMap(i -> list.get(i), i -> i));

Pas nécessairement un one-liner ou plus courte que la simple boucle, mais il fonctionne à l'aide d'un courant parallèle si vous modifiez toMap à toConcurrentMap.

Noter également, cela suppose que vous avez un accès aléatoire de la liste, pas une Collection. Si vous avez un Collection que vous pouvez faire aucune hypothèse sur, il n'ya pas beaucoup que vous pouvez faire d'autre que de parcourir de façon séquentielle et incrémenter un compteur.

Mise à JOUR

L'OP a précisé que l'entrée est un Collection et pas un List de sorte que le ci-dessus ne s'applique pas. Il semble que nous pouvons supposer que très peu de choses sur l'entrée Collection. L'OP a précisé itération de l'ordre. Avec un séquentiel d'itérateur, les éléments seront dans certains ordonnance, mais aucune garantie ne peut être fait à ce sujet. Il peut changer d'exécuter pour exécuter, ou même d'une itération à l'autre (bien que ce serait inhabituel dans la pratique, à moins que la collection sous-jacente est modifié).

Si l'exact itération doit être préservée, je ne crois pas qu'il y a un moyen de le préserver dans le résultat Map sans une itération à l'entrée Collection de manière séquentielle.

Si, toutefois, l'exacte itération de l'ordre n'est pas important, et la condition est que la sortie Map ont des valeurs uniques pour chaque élément d'entrée, alors il serait possible de faire quelque chose comme ceci en parallèle:

Collection<String> col = apiCall();
Iterator<String> iter = col.iterator();

Map<String, Integer> map =
    IntStream.range(0, col.size())
        .parallel()
        .boxed()
        .collect(toConcurrentMap(i -> { synchronized (iter) { return iter.next(); }},
                                 i -> i));

C'est maintenant loin à partir d'un seul-liner. Il n'est également pas clair pour moi, combien il est utile. 🙂 Mais il ne démontrent qu'il est possible de faire quelque chose comme ceci en parallèle. Notez que nous avons eu pour synchroniser l'accès à la collection d'entrée de l'itérateur puisqu'il sera appelé à partir de plusieurs threads. Notez également que c'est une utilisation inhabituelle de l'itérateur, puisque nous n'avons jamais appel hasNext et nous supposons qu'il est possible d'appeler des next exactement le nombre de fois retourné par l'entrée de la collection size().

OriginalL'auteur Stuart Marks

Si vous n'avez pas l'esprit à l'aide de la 3e partie des bibliothèques, mon cyclope-réagir lib a des extensions pour tous les JDK Collection types, avec un grand nombre de puissants operations attachés, de sorte que vous pourriez mettre en œuvre la présente comme suit :-

    CollectionX<String> col = CollectionX.fromCollection(orgCol);
    col.zipWithIndex()
       .toMap(k->k.v1, v->v.v2);

cyclope-réagir Collection extensions sont impatients, donc, vous obtiendrez de meilleures performances avec nos Flux extension, ReactiveSeq (qui s'étend à jOOλ du Seq, qui à son tour est une extension du JDK de java.util.flux de données.Cours d'eau, il met également en œuvre le réactif-api de flux).

    ReactiveSeq.fromCollection(col)
               .zipWithIndex()
               .toMap(k->k.v1, v->v.v2);

OriginalL'auteur John McClean

Essayer

    int[] pos = { 0 };
    list.forEach( a -> map.put(a, pos[0]++));

OriginalL'auteur Syam S