¿Cómo puedo usar el mapa y recibir un índice también en Scala?

¿Hay alguna Lista / Secuencia incorporada que se comporte mapy proporcione también el índice del elemento?

Creo que estás buscando 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

De: http://www.artima.com/forums/flat.jsp?forum=283&thread=243570

También tienes variaciones como:

for((e,i) <- List("Mary", "had", "a", "little", "lamb").zipWithIndex) println(i+" "+e)

o:

List("Mary", "had", "a", "little", "lamb").zipWithIndex.foreach( (t) => println(t._2+" "+t._1) )

Utilizar . mapa en. zipWithIndex

val myList = List("a", "b", "c")

myList.zipWithIndex.map { case (element, index) => 
   println(element, index) 
   s"${element}(${index})"
}

Resultado:

List("a(0)", "b(1)", "c(2)")

Las soluciones propuestas adolecen del hecho de que crean colecciones intermedias o introducen variables que no son estrictamente necesarias. Porque, en última instancia, todo lo que necesita hacer es realizar un seguimiento del número de pasos de una iteración. Esto se puede hacer mediante la memorización. El código resultante podría verse así

myIterable map (doIndexed(someFunction))

La doIndexed-Función envuelve la función interior que recibe tanto un índice como los elementos de myIterable. Esto puede resultarle familiar gracias a JavaScript.

He aquí una forma de lograr este propósito. Considere la siguiente utilidad:

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)
    }
}

Esto ya es todo lo que necesitas. Puede aplicar esto, por ejemplo, de la siguiente manera:

import TraversableUtil._
List('a','b','c').map(doIndexed((i, char) => char + i))

que resulta en la lista

List(97, 99, 101)

De esta manera, puede usar las funciones habituales de Traversable a expensas de envolver su función efectiva. La sobrecarga es la creación del objeto de memorización y el contador que contiene. De lo contrario, esta solución es tan buena (o mala) en términos de memoria o rendimiento como el uso sin indexar map. ¡Disfrutar!

Hay CountedIteratoren 2.7.x (que puede obtener de un iterador normal con .counted). Creo que ha quedado obsoleto (o simplemente se ha eliminado) en 2.8, pero es bastante fácil lanzar el suyo. Necesita poder nombrar el iterador:

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)

O, asumiendo que su colección tiene un tiempo de acceso constante, podría mapear la lista de índices en lugar de la colección real:

val ls = List("a","b","c")
0.until(ls.length).map( i => doStuffWithElem(i,ls(i)) )

Utilice .map en .zipWithIndex con estructura de datos de mapa

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"
}

Resultados

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

Hay dos formas de hacer esto.

ZipWithIndex: crea un contador que comienza automáticamente con 0.

  // zipWithIndex with a map.
  val days = List("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat")
  days.zipWithIndex.map {
        case (day, count) => println(s"$count is $day")
  }
  // Or use it simply with a for.
  for ((day, count) <- days.zipWithIndex) {
        println(s"$count is $day")
  }

La salida de ambos códigos será:

0 is Sun
1 is Mon
2 is Tue
3 is Wed
4 is Thu
5 is Fri
6 is Sat

Zip : use el método zip con un Stream para crear un contador. Esto le brinda una forma de controlar el valor inicial.

for ((day, count) <- days.zip(Stream from 1)) {
  println(s"$count is $day")
}

Resultado:

1 is Sun
2 is Mon
3 is Tue
4 is Wed
5 is Thu
6 is Fri
7 is Sat

Si también necesita buscar los valores del mapa (como tuve que hacerlo):

val ls = List("a","b","c")
val ls_index_map = ls.zipWithIndex.toMap