Comment puis-je utiliser la carte et recevez un index ainsi en Scala?

Est-il de la Liste/Séquence intégrée qui se comporte comme map et fournit l'élément de l'index ainsi?

InformationsquelleAutor Geo | 2010-02-06

140

Je crois que vous êtes à la recherche pour zipWithIndex?
```
scala> val ls = List("Mary", "had", "a", "little", "lamb")
scala> ls.zipWithIndex.foreach{ case (e, i) => println(i+" "+e) }
0 Mary
1 had
2 a
3 little
4 lamb
```
À partir de: http://www.artima.com/forums/flat.jsp?forum=283&thread=243570

Vous avez aussi des variantes comme:
```
for((e,i) <- List("Mary", "had", "a", "little", "lamb").zipWithIndex) println(i+" "+e)
```
ou:
```
List("Mary", "had", "a", "little", "lamb").zipWithIndex.foreach( (t) => println(t._2+" "+t._1) )
```
- Eh bien, je suppose que le zipWithIndex méthode pour obtenir l'index à l'intérieur d'une boucle/map/whatever.
- Comparer à quoi?
- Par exemple, en comparant à une while boucle, ce qui est probablement parmi les plus rapides des options.
- Un Tableau et une boucle while est probablement aussi vite qu'elle peut obtenir.
- Si vous êtes à la recherche pour les performances dont vous avez besoin à un compromis entre l'immutabilité. Regardez à l'intérieur de la zipWithIndex fonction. Il utilise juste un var pour construire une nouvelle collection de paires. Vous pouvez utiliser la même méthode d'incrémentation d'une variable sans la construction de la nouvelle collection, tout comme vous le feriez en Java. Mais ce n'est pas fonctionnelle. Pense que si vous avez réellement besoin.
- Il semble donc que même zipWithIndex lui-même n'est pas fonctionnelle. De toute façon je pense qu'il devrait être mentionné que l'utilisation de view vous devriez être en mesure d'empêcher la création et traversant une Liste complémentaire.
- Ne pas utiliser de vue, l'utilisation iterator, les vues sont sur le point de sortir.
- ziggystar: stackoverflow.com/a/25675034/1163081
- Si vous êtes concernés par l'efficacité de voir: stackoverflow.com/questions/9137644/...
- Est-il possible d'utiliser zipWithIndex et d'obtenir des indices de type Int, au lieu de Long, sans l'aide de cartographie? Et à propos de l'étincelle, ne serait pas zipWithIndex être plus efficace en raison de la distribution de données?
InformationsquelleAutor Viktor Klang
49

Utilisation .carte dans .zipWithIndex
```
val myList = List("a", "b", "c")

myList.zipWithIndex.map { case (element, index) => 
   println(element, index) 
   s"${element}(${index})"
}
```
Résultat:
```
List("a(0)", "b(1)", "c(2)")
```
- C'est la première décent exemple j'ai vu un map comme demandé, au lieu de juste l'impression à l'intérieur d'un foreach.
InformationsquelleAutor Paulo Cheque
8

Les solutions proposées souffrent du fait qu'ils créent intermédiaire de collections ou d'introduire des variables qui ne sont pas strictement nécessaires. Pour en fin de compte tout ce que vous devez faire est de garder une trace du nombre d'étapes d'une itération. Cela peut être fait en utilisant memoizing. Le code résultant peut ressembler à
```
myIterable map (doIndexed(someFunction))
```
La doIndexedFonction des enveloppements à l'intérieur d'une fonction qui reçoit un indice d'un des éléments de myIterable. Cela pourrait vous être familière à partir de JavaScript.

Ici est une façon d'atteindre ce but. Envisager l'utilitaire suivant:
```
object TraversableUtil {
    class IndexMemoizingFunction[A, B](f: (Int, A) => B) extends Function1[A, B] {
        private var index = 0
        override def apply(a: A): B = {
            val ret = f(index, a)
            index += 1
            ret
        }
    }

    def doIndexed[A, B](f: (Int, A) => B): A => B = {
        new IndexMemoizingFunction(f)
    }
}
```
C'est déjà tout ce que vous devez. Vous pouvez appliquer la présente par exemple comme suit:
```
import TraversableUtil._
List('a','b','c').map(doIndexed((i, char) => char + i))
```
qui résultats dans la liste
```
List(97, 99, 101)
```
De cette façon, vous pouvez utiliser l'habituel Traversable-fonctions au détriment de l'emballage de votre fonction. La surcharge est la création de la memoizing objet et le compteur qui y sont. Sinon, cette solution est aussi bon (ou mauvais) en termes de mémoire ou la performance à l'aide de indexée map. Profitez-en!
- C'est très une solution élégante à ce problème. +1 pour ne pas en créer un temporaire de la collection. Ne fonctionne pas dans une collection parallèle, mais encore une très belle solution.
- Si vous ne voulez pas créer un temporaire de la collection, il suffit d'utiliser coll.view.zipWithIndex au lieu de coll.zipWithIndex
InformationsquelleAutor Matt Brasen
5

Il est CountedIterator en 2.7.x (que vous pouvez obtenir à partir d'un itérateur .comptés). Je crois qu'il a été déprécié (ou tout simplement supprimé) en 2.8, mais il est assez facile de rouler votre propre. Vous avez besoin d'être en mesure de nommer l'itérateur:
```
val ci = List("These","are","words").elements.counted
scala> ci map (i => i+"=#"+ci.count) toList
res0: List[java.lang.String] = List(These=#0,are=#1,words=#2)
```
InformationsquelleAutor Rex Kerr
3

Ou, en supposant que votre collection est la constante de temps d'accès, vous pouvez mapper la liste des index à la place de la collection:
```
val ls = List("a","b","c")
0.until(ls.length).map( i => doStuffWithElem(i,ls(i)) )
```
- D'une façon plus élégante de le faire c'est tout simplement: ls.indices.map(i => doStuffWithElem(i, ls(i))
- Et, voyant que indices est mis en œuvre comme 0 until length c'est à peu près la même chose 😛
- downvote en raison de la complexité de l'itération avec ls(i) prend O(n^2)
- Juste assez. Mon exemple de List était en effet pauvres. Je n'en dit cependant que c'est adapté si votre collection est la constante de temps d'accès. Doivent avoir sélectionné Array.
InformationsquelleAutor Cristian Vrabie

Utilisation .carte dans .zipWithIndex avec la Carte la structure de données

val sampleMap = Map("a" -> "hello", "b" -> "world", "c" -> "again")

val result = sampleMap.zipWithIndex.map { case ((key, value), index) => 
    s"Key: $key - Value: $value with Index: $index"
}

Résultats

 List(
       Key: a - Value: hello with Index: 0, 
       Key: b - Value: world with Index: 1, 
       Key: c - Value: again with Index: 2
     )

InformationsquelleAutor fgfernandez0321

0

Si vous avez besoin de recherche sur la carte des valeurs (comme je l'ai eu à):
```
val ls = List("a","b","c")
val ls_index_map = ls.zipWithIndex.toMap 
```
InformationsquelleAutor Yair Beer

Vous devez vous connecter pour publier un commentaire.