Wie kann ein Iterator in Scala zurückkehren?
Frage
Was muss ich tun, um der Lage sein, einen Iterator aus einer Methode / Klasse zurückzukehren? Wie würde man diese Eigenschaft zu einer Klasse hinzufügen?
Lösung
können Sie erweitern Iterator , welche erfordert dass Sie die next
und hasNext
Methoden implementieren:
class MyAnswer extends Iterator[Int] {
def hasNext = true
def next = 42
}
Aber, werden Sie mehr Flexibilität, wenn Sie erweitern Iterable , die Sie elements
(oder iterator
in 2.8) erfordert implementieren:
class MyAnswer extends Iterable[Int] {
def iterator = new Iterator[Int] {
def hasNext = true
def next = 42
}
}
Ein gemeinsames Idiom scheint einen Iterator zu einem gewissen Privatsammlung zu belichten, wie folgt aus:
class MyStooges extends Iterable[String] {
private val stooges = List("Moe", "Larry", "Curly")
def iterator = stooges.iterator
}
Andere Tipps
Für ein Verfahren, nur Ausbeute :
def odd(from: Int, to: Int): List[Int] =
for (i <- List.range(from, to) if i % 2 == 1) yield i
hatte Diese beiden Antworten Hilfe von den Pfosten unten und dank @Dima.
-
Wie implementiere ich einen Iterator für eine bestehende einfach verketteten Liste?
-
warum diese iterable Implementierung produziert eine Stackoverflow?
Nehmen wir an, Sie eine Klasse verknüpften Liste haben. Und die Forderung ist es, alle Elemente in der Liste zu drucken.
trait LinkedList {
def nodeValue: Int
def tailList: LinkedList
}
class Node(val nodeValue: Int, val tailList: LinkedList) extends LinkedList
object Nil extends LinkedList {
def nodeValue = throw new IllegalAccessException("head of Nil")
def tailList = throw new IllegalAccessException("tail of Nil")
}
val singleLinkedList = new Node(1,Nil)
val chainedLinkedList = new Node(2,singleLinkedList)
print(chainedLinkedList)
A$A44$A$A44$Node@7b7a2c78res0: Unit = ()
Lets Iterator nun zu dieser Klasse implementieren.
trait LinkedList extends Iterator[Int]{
def nodeValue: Int
def tailList: LinkedList
}
class Node(val nodeValue: Int, val tailList: LinkedList) extends LinkedList {
var ptr: LinkedList = this
//The following two are mandatory for extending Iterator
override def hasNext: Boolean = ptr match { case Nil => false; case _=> true}
override def next(): Int = {
val result = ptr.nodeValue
ptr = ptr.tailList
result
}
}
object Nil extends LinkedList {
def nodeValue = throw new IllegalAccessException("head of Nil")
def tailList = throw new IllegalAccessException("tail of Nil")
//The following two are mandatory for extending Iterator
override def hasNext: Boolean = false
override def next(): Int = throw new IllegalAccessException("next of Nil")
}
val singleLinkedList = new Node(1,Nil)
val chainedLinkedList = new Node(2,singleLinkedList)
//Printing this first Time
chainedLinkedList.foreach(println)
//Prints 2 1
//Printing second Time
chainedLinkedList.foreach(println)
//No output
In der Iterator Implementierung einmal ptr das Ende erreicht, könnte es nicht weiter vorangeschritten zurück. Iterable Implementierung löst diese.
trait LinkedList extends Iterable[Int]{
val nodeValue: Int
val tailList: LinkedList
override def toString(): String = this.mkString(" -> ")
}
class Node(val nodeValue: Int, val tailList: LinkedList) extends LinkedList {
override def iterator: Iterator[Int] = Iterator
.iterate(this: LinkedList)(_.tailList)
.takeWhile(_ != Nil)
.map(_.nodeValue)
}
object Nil extends LinkedList {
lazy val nodeValue= throw new IllegalAccessException("head of Nil")
lazy val tailList = throw new IllegalAccessException("tail of Nil")
override def iterator: Iterator[Int] = Iterator.empty
}
val singleLinkedList = new Node(1,Nil)
val chainedLinkedList = new Node(2,singleLinkedList)
//Printing this first Time
chainedLinkedList.foreach(println)
Output 2 -> 1
chainedLinkedList.foreach(println)
Output 2 -> 1