Como posso usar o mapa e receber um índice também no Scala?

Existe alguma lista / sequência embutida que se comporta como mape fornece o índice do elemento também?

Eu acredito que você está procurando por 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

Você também tem variações como:

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

Usar . mapa em. 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)")

As soluções propostas sofrem do fato de criarem coleções intermediárias ou introduzirem variáveis ​​que não são estritamente necessárias. Afinal, tudo o que você precisa fazer é controlar o número de etapas de uma iteração. Isso pode ser feito usando memoizing. O código resultante pode parecer

myIterable map (doIndexed(someFunction))

o doIndexed -Function envolve a função interior que recebe um índice e os elementos de myIterable. Isso pode ser familiar para você do JavaScript.

Aqui está uma maneira de atingir esse propósito. Considere o seguinte utilitário:

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

Isso já é tudo que você precisa. Você pode aplicar isso, por exemplo, da seguinte forma:

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

que resulta na lista

List(97, 99, 101)

Desta forma, você pode usar as funções normais de Traversable à custa de empacotar sua função efetiva. A sobrecarga é a criação do objeto memoizing e do contador nele. Caso contrário, esta solução é tão boa (ou ruim) em termos de memória ou desempenho quanto usar não indexado map. Aproveitar!

Existe CountedIteratorem 2.7.x (que você pode obter de um iterador normal com .counted). Eu acredito que ele foi descontinuado (ou simplesmente removido) no 2.8, mas é fácil de fazer o seu próprio. Você precisa ser capaz de nomear o 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)

Ou, supondo que sua coleção tenha tempo de acesso constante, você pode mapear a lista de índices em vez da coleção real:

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

Use .map em .zipWithIndex com estrutura de dados Map

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
     )

Há duas maneiras de fazer isso.

ZipWithIndex: Cria um contador automaticamente começando com 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")
  }

A saída de ambos os 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 o método zip com um Stream para criar um contador. Isso fornece uma maneira de controlar o 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

Se você precisar pesquisar os valores do mapa também (como eu tive):

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