Ich habe folgenden Code:
val dm = List[String]()
val dk = List[Map[String,Object]]()
.....
dm.add("text")
dk.add(Map("1" -> "ok"))
Es wird jedoch die Laufzeit java.lang.UnsupportedOperationException ausgelöst.
Ich muss eine leere Liste oder leere Karten deklarieren und einige, wo später im Code sie füllen müssen.
add
Operation gibtList
?scala.collection.JavaConversions
? Wenn Sie dies getan haben, sehen Sie genau den Grund, warum ichJavaConverters
stattdessen empfehle :dm
unddk
werden in eine Java-Sammlung konvertiert, und dann dieadd
Methode, die für diese Sammlung aufgerufen wird. Schlimmer nochdm
unddk
werden nicht geändert, auch wenn Sie keinen Fehler erhalten haben. Übrigens ist der Fehler, dass dies nicht der Fall1 -> "ok"
ist .Map[Int,String]
Map[String, Object]
Antworten:
Scala-Listen sind standardmäßig unveränderlich. Sie können kein Element "hinzufügen", aber Sie können eine neue Liste erstellen, indem Sie das neue Element davor anhängen. Da es sich um eine neue Liste handelt, müssen Sie die Referenz neu zuweisen (damit Sie keinen Wert verwenden können).
var dm = List[String]() var dk = List[Map[String,AnyRef]]() ..... dm = "text" :: dm dk = Map(1 -> "ok") :: dk
Der Bediener
::
erstellt die neue Liste. Sie können auch die kürzere Syntax verwenden:dm ::= "text" dk ::= Map(1 -> "ok")
NB: Verwenden Sie in Scala nicht den Typ
Object
aberAny
,AnyRef
oderAnyVal
.quelle
List
ist unveränderlich. Dies ist die empfohlene für die meisten Anwendungen.mutable.List
-List
ist ein konkreter Typ, dessen einzige Implementierung unveränderlich ist. Es gibt unveränderliche Klassen wieLinkedList
undDoubleLinkedList
, die meistens Hilfsklassen sind. Das Scala-Äquivalent von JavaArrayList
istArrayBuffer
und das Äquivalent von JavaLinkedList
istListBuffer
. Das Merkmal, das Java entspricht,List
istSeq
- von dem es gibtcollection.Seq
und erweitert,collection.immutable.Seq
undcollection.mutable.Seq
.::=
und+=
?::
ist definiert,+=
funktioniert also nicht. Bei anderer Sammlung (nicht in der Standardbibliothek): Wenn::=
oder+=
implementiert sind, wird die Implementierung verwendet. Andernfalls wird der Compilerx::=y
zux = y::x
undx+=y
inrox=x+y
. Im zweiten Fall sind sie gleich, wenn die Implementierung von::
die gleiche ist wie die Implementierung von+
...Wenn Sie etwas mutieren müssen, verwenden Sie
ArrayBuffer
oderLinkedBuffer
stattdessen. Es wäre jedoch besser, diese Aussage anzusprechen:Füllen Sie stattdessen die Liste mit Code, der die Elemente zurückgibt. Es gibt viele Möglichkeiten, dies zu tun, und ich werde einige Beispiele nennen:
// Fill a list with the results of calls to a method val l = List.fill(50)(scala.util.Random.nextInt) // Fill a list with the results of calls to a method until you get something different val l = Stream.continually(scala.util.Random.nextInt).takeWhile(x => x > 0).toList // Fill a list based on its index val l = List.tabulate(5)(x => x * 2) // Fill a list of 10 elements based on computations made on the previous element val l = List.iterate(1, 10)(x => x * 2) // Fill a list based on computations made on previous element, until you get something val l = Stream.iterate(0)(x => x * 2 + 1).takeWhile(x => x < 1000).toList // Fill list based on input from a file val l = (for (line <- scala.io.Source.fromFile("filename.txt").getLines) yield line.length).toList
quelle
Wie bereits erwähnt, ist dies nicht die beste Möglichkeit, Listen in Scala zu verwenden ...
scala> val list = scala.collection.mutable.MutableList[String]() list: scala.collection.mutable.MutableList[String] = MutableList() scala> list += "hello" res0: list.type = MutableList(hello) scala> list += "world" res1: list.type = MutableList(hello, world) scala> list mkString " " res2: String = hello world
quelle
list ::= "text"
folgt ist O (1), was konstant ist und das Beste ist, was Sie tun können.Wie in einer obigen Antwort erwähnt , ist die Scala-Liste eine unveränderliche Sammlung. Sie können eine leere Liste mit erstellen
.empty[A]
. Dann können Sie eine Methode verwenden:+
,+:
oder::
um Element in die Liste hinzuzufügen.scala> val strList = List.empty[String] strList: List[String] = List() scala> strList:+ "Text" res3: List[String] = List(Text) scala> val mapList = List.empty[Map[String, Any]] mapList: List[Map[String,Any]] = List() scala> mapList :+ Map("1" -> "ok") res4: List[Map[String,Any]] = List(Map(1 -> ok))
quelle
Standardmäßig sind Sammlungen in Scala unveränderlich, sodass Sie eine + -Methode haben, die eine neue Liste mit dem hinzugefügten Element zurückgibt. Wenn Sie wirklich so etwas wie eine Add-Methode benötigen, benötigen Sie eine veränderbare Sammlung, z. B. http://www.scala-lang.org/api/current/scala/collection/mutable/MutableList.html mit einer + = -Methode.
quelle
Vielleicht können Sie ListBuffers in Scala verwenden, um eine leere Liste zu erstellen und später Zeichenfolgen hinzuzufügen, da ListBuffers veränderbar sind. Außerdem sind alle List-Funktionen für die ListBuffers in Scala verfügbar.
import scala.collection.mutable.ListBuffer val dm = ListBuffer[String]() dm: scala.collection.mutable.ListBuffer[String] = ListBuffer() dm += "text1" dm += "text2" dm = ListBuffer(text1, text2)
Wenn Sie möchten, können Sie dies mithilfe von .toList in eine Liste konvertieren
quelle
In Ihrem Fall verwende ich:
val dm = ListBuffer[String]()
undval dk = ListBuffer[Map[String,anyRef]]()
quelle