Wie füge ich ein bestimmtes Element in den String ein - scala

Ich stehe vor dem Problem, herauszufinden, wie ein Element an einer bestimmten Position mit scala gelöscht werden kann.

Wie füge ich mit scala ein Zeichen an einer bestimmten Position in eine Zeichenfolge ein und wie füge ich mit scala ein Zeichen an einer bestimmten Position in eine Zeichenfolge ein?

Antworten:

Verwenden patch von @BenReich ist möglicherweise der idiomatischste und ordentlichste Ansatz dafür; Ein anderer Weg beinhaltet zum Beispiel die Verwendung von take und drop über eine Zeichenfolge als Folge von Char, so was,

val s = ("a" to "e").mkString
s: String = abcde

scala> s.take(2) ++ s.drop(3)  // remove third char
res0: String = abde

scala> s.take(2) ++ "CCC" ++ s.drop(3)  // replace third char with a string
res1: String = abCCCde

scala> s.take(2) ++ s.drop(4)  // remove from third to fourth chars
res2: String = abe

Beachten Sie, dass dies nicht der effizienteste Ansatz für große Zeichenfolgen ist.

Das meiste davon kann mit dem getan werden patch Methode:

val x = "abcdefgh"
//Replace 1 element starting at the 4th position with "" (thereby eliminating the fourth element)
x.patch(4, "", 1) //"abcdfgh"

//Replace 0 elements starting at the 4th position with "A" (thereby adding an element after the fourth element)
x.patch(4, "A", 0) //"abcdAefgh"

Die Methode ist definiert am GenSeqLike, das ist ziemlich hoch oben in der Typhierarchie, so dass Sie verwenden können patch auf andere Arten als String:

 List(1, 2, 3, 4, 5, 6, 7).patch(4, Seq(), 1) //List(1, 2, 3, 4, 6, 7)

Lesen Sie die Dokumentation von patch Hier.

Sie können auch bereichern GenSeqLike Um diese Art von Methode einfacher verfügbar zu machen:

import scala.collection.GenSeqLike
implicit class RichGenSeqLike[T, Repr <% GenSeqLike[T, Repr]](val seq: Repr) {
import scala.collection.generic.CanBuildFrom
def dropAt[That](n: Int)(implicit bf: CanBuildFrom[Repr, T, That]): That = seq.patch(n, Seq.empty[T], 1)
def addAt[That](n: Int)(ts: T*)(implicit bf: CanBuildFrom[Repr, T, That]): That = seq.patch(n, ts, 0)
}

Und dann kannst du:

List(1, 2, 3).dropAt(1) //List(1, 3)
"abc".dropAt(1) //"ac"

List(1, 2, 3).addAt(1)(4) //List(1, 4, 2, 3)
List(1, 2, 3).addAt(1)(4, 5, 6) //List(1, 4, 5, 6, 2, 3)
"abc".addAt(1)("A") //aAbc
"abc".addAt(1)("A", "B") //aABbc
"abc".addAt(1)("ABC":_*) //aABCbc

Wenn Sie dies zu Ihrer Standardbibliothek hinzufügen, könnten Sie natürlich in Betracht ziehen, einige Grenzen zu überprüfen.

Sie können "Unterzeichenfolge" verwenden, um die Zeichenfolge in zwei Teile aufzuteilen, und sie dann nach dem Hinzufügen des erforderlichen Zeichens erneut kombinieren.