Durchlaufen Mitglieder von collection in Scala

Was ist ein effizienter Weg, um zu Durchlaufen und nur die Mitglieder einer collection in Scala, basierend auf index-position?

Angesichts dieser Liste:

val fruits: List[String] = List("apples", "oranges", "pears", "bananas")

Möchte ich überspringen, äpfel und Birnen, und den Prozess, Orangen und Bananen. Danke!

Update-basierend auf den Antworten gegeben:

Wow, jeder der top-drei-Antworten Verdienst. Ich bedeutete ursprünglich das Wort "effizient" aus einer Scala-Collections syntax Perspektive, und ich war eigentlich nur auf der Suche für einen glatten Weg, um die Unterliste für die nachfolgende iteration. @Senia macht einen guten job die Einführung der Schiebetür () - Funktion, ideal für diesen Anwendungsfall, aber ich habe auch wie @Brian mehr verallgemeinerte Ansatz mit zipWithIndex().

Allerdings, wenn ich den tatsächlichen Wortlaut der Frage als die ursprünglich gestellte, und die rechnerische Effizienz von @sourcedelica die Antwort, ich denke er nimmt den Preis für diese ein.

Keine der Antworten so weit interate durch die Mitglieder. Stattdessen produzieren Sie eine Liste der Mitglieder (die dann iteriert über, natürlich). Es muss eine einfache Möglichkeit, direkt Durchlaufen ove Sie, obwohl?

InformationsquelleAutor kgx | 2012-10-08

scala scala-collections

Hier ist eine Möglichkeit, direkt zu iterieren über die ungeraden:

val fruits: List[String] = List("apples", "oranges", "pears", "bananas")
//> fruits  : List[String] = List(apples, oranges, pears, bananas)

val oddFruitsIterator = 
  Iterator.from(1, 2).takeWhile(_ < fruits.size).map(fruits(_))
//> oddFruits  : Iterator[String] = non-empty iterator

oddFruitsIterator.foreach(println)                      
//> oranges
//> bananas

Wenn es eine große Sammlung und/oder Sie werden tun eine Menge der Iterationen, dann werden Sie wollen prüfen, konvertieren es zu einem IndexedSeq erste, also die fruits(_) ist O(1). Zum Beispiel:

val fruitsIs = fruits.toIndexedSeq
val oddFruits = Iterator.from(1, 2).takeWhile(_ < fruitsIs.size).map(fruitsIs(_))

Beachten Sie, dass der iterator selbst ist getrennt von der Sammlung, die es Durchlaufen. Hier ist ein weiteres Beispiel macht das klar:

scala> val oddSeqIterator = 
   (seq: Seq[String]) => Iterator.from(1, 2).takeWhile(_ < seq.size).map(seq(_))
oddSeqIterator: Seq[String] => Iterator[String] = <function1>

scala> val fruits: List[String] = List("apples", "oranges", "pears", "bananas")
fruits: List[String] = List(apples, oranges, pears, bananas)

scala> oddSeqIterator(fruits)
res0: Iterator[String] = non-empty iterator

scala> res0.foreach(println)
oranges
bananas

InformationsquelleAutor sourcedelica

scala> List("apples", "oranges", "pears", "bananas").drop(1).sliding(1, 2).flatten.toList
res0: List[java.lang.String] = List(oranges, bananas)

InformationsquelleAutor senia

14
```
val fruits: List[String] = List("apples", "oranges", "pears", "bananas")

fruits.zipWithIndex.filter(_._2 % 2 == 1).map(_._1)

res0: List[String] = List(oranges, bananas)
```
zipWithIndex Paare jedes element in der Liste mit einem index zu geben:

List[(String, Int)] = List((apples,0), (oranges,1), (pears,2), (bananas,3))

filtern der ungeraden Elemente mit filter(_._2 % 2 == 1) geben:

List[(String, Int)] = List((oranges,1), (bananas,3))

anzeigen der Liste[(String, Int)], um nur eine Liste[String] indem das erste element jedes Tupels mit .map(_._1) geben:

List[String] = List(oranges, bananas)
- Alternativ, wenn Sie ein filter gefolgt von einem map können Sie kombinieren Sie mit collect z.B. fruits.zipWithIndex.collect{case(item,idx) if idx % 2 == 1 => item}
- sehr schöner Beitrag das ein in der Tat ! Scala collection-Paket rechtfertigt seine Verwendung in distributed computing.
InformationsquelleAutor Brian
1

Ich würde vorschlagen, eine andere Methode, mit Rekursion, die zu machen scheint, so wenig Operationen wie möglich in meiner Meinung nach, auch wenn es weniger Phantasie als andere Lösungen.
```
def iterateOdd(myList:List[String]):List[String] = myList match{
  case _::odd::tail => odd::iterateOdd(tail)
  case _ => Nil
}
```
Oder, wenn Sie wollen einfach nur zu verarbeiten, Mitglieder
```
def iterateOdd(myList:List[String]):Unit = myList match{
  case _::odd::tail => println(odd); iterateOdd(tail)
  case _ =>   
}
```
InformationsquelleAutor Christopher Chiche
0

Noch eine andere alternative, basierend auf einer Kombination von List::gruppiert um der partition Elemente von pair-Mädchen (die bietet eine einfache Möglichkeit für den Zugriff auf Elemente in merkwürdigen Stellungen) und Iterator::collect um Sammlungen mit ungerade Länge:
```
//val fruits = List("apples", "oranges", "pears", "bananas", "tomatoes")
fruits.grouped(2).collect { case a :: b => b }.toList
//List("oranges", "bananas")
```
InformationsquelleAutor Xavier Guihot
-1
- Ich habe einen anderen Ansatz zum lösen dieser Art von problem.
- Wir können den Vorteil der Liste.range(start,Ende) - Methode.
Liste.range(0,5) ergibt die Liste(0,1,2,3,4)
- Können wir generieren Liste von Indizes und wir können die filter
  
  scala> val Früchte: List[String] = List("äpfel", "Orangen", "Birnen", "Bananen")
  
  scala> Liste.range(0,Früchte.Länge).filter(_%2!=0).map(x=>Obst(x))
  
  res0: List[String] = List(Orangen, Bananen)
- Liste.range(0,5) ergibt die Liste(0,1,2,3,4)
InformationsquelleAutor Manoj Kumar Dhakd

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.