Jak mogę korzystać z mapy i otrzymać indeks również w Scali?

Czy istnieje wbudowana lista / sekwencja, która zachowuje się jak mapi zapewnia również indeks elementu?

Myślę, że szukasz 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

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

Masz również odmiany, takie jak:

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

lub:

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

Posługiwać się . mapa w. zipWithIndex

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

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

Wynik:

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

Proponowane rozwiązania obarczone są tym, że tworzą zbiory pośrednie lub wprowadzają zmienne, które nie są bezwzględnie konieczne. Ostatecznie wszystko, co musisz zrobić, to śledzić liczbę kroków iteracji. Można to zrobić za pomocą zapamiętywania. Wynikowy kod może wyglądać tak

myIterable map (doIndexed(someFunction))

doIndexed-Function owija funkcję wewnętrznego, który odbiera zarówno wskaźnik się elementów myIterable. Może to być znane z JavaScript.

Oto sposób na osiągnięcie tego celu. Rozważ następujące narzędzie:

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

To już wszystko, czego potrzebujesz. Możesz to zastosować na przykład w następujący sposób:

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

co powoduje wyświetlenie listy

List(97, 99, 101)

W ten sposób możesz używać zwykłych funkcji Traversable kosztem opakowywania efektywnej funkcji. Narzut to tworzenie obiektu do zapamiętywania i znajdującego się w nim licznika. W przeciwnym razie to rozwiązanie jest tak samo dobre (lub złe) pod względem pamięci lub wydajności, jak użycie niezindeksowanego map. Cieszyć się!

Jest CountedIteratorw 2.7.x (który można uzyskać z normalnego iteratora z .counted). Wydaje mi się, że w wersji 2.8 został wycofany (lub po prostu usunięty), ale dość łatwo jest wprowadzić własny. Musisz być w stanie nazwać iterator:

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)

Lub zakładając, że Twoja kolekcja ma stały czas dostępu, możesz zmapować listę indeksów zamiast rzeczywistej kolekcji:

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

Użyj .map w .zipWithIndex ze strukturą danych 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"
}

Wyniki

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

Można to zrobić na dwa sposoby.

ZipWithIndex: tworzy licznik automatycznie zaczynający się od 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")
  }

Wynik obu kodów będzie:

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

Zip : użyj metody zip ze strumieniem, aby utworzyć licznik. Daje to sposób kontrolowania wartości początkowej.

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

Wynik:

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

Jeśli potrzebujesz przeszukać również wartości mapy (tak jak musiałem):

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