Kotlin-Strings und String-Templates

In diesem Artikel werden Sie mit Beispielen Kotlin-Strings, String-Templates und einige gängige String-Attribute und -Funktionen lernen.

Kotlin String（字符串）

字符串是字符序列。例如，"Hello there!"是字符串字面量。

在Kotlin中，所有字符串都是String类的对象。 这意味着，诸如“Hello here！”之类的字符串文字被实现为该类的实例。

如何创建一个字符串变量？

这是在Kotlin中定义 String 变量的方法。例如，

val myString = "Hey there!"

在这里，myString是String类型的变量。

您可以声明 String 类型的变量，并在一条语句中指定其类型，然后在程序中稍后在另一条语句中初始化该变量。

val myString: String
...　..　...
myString = "Howdy"

如何访问字符串的字符？

要访问字符串的元素（字符），请使用索引访问运算符。例如，

val myString = "Hey there!"
val item = myString[2]

在这里，item 变量包含 myString 字符串的第三个字符y。 这是因为Kotlin中的索引从 0 开始而不是 1。

val myString = "Hey there!"
var item: Char
item = myString[0]　　　　//　item = 'H'
item = myString[9]　　　　//　item = '!'
item = myString[10]　　　//　错误！字符串索引超出范围
item = myString[-1]　　//　错误！字符串索引超出范围

示例：遍历字符串

如果您需要遍历字符串的元素，则可以使用for循环轻松实现。

fun main(args: Array<String>) {
　　　　val myString = "Hey!"
　　　　for (item in myString) {
　　　　　　　　println(item)
　　　　}
}

Die Ausgabe beim Ausführen des Programms ist:

H
e
y
!

Kotlin 中的字符串是不可变的

像Java一样，字符串在Kotlin中是不可变的。这意味着您不能更改字符串的单个字符。例如，

var myString = "Hey!"
myString[0] = 'h'　　　　　　//　Error! Strings

但是，如果使用关键字var声明了字符串变量，则可以重新分配该变量。（推荐阅读:Kotlin var vs val)

示例：重新分配字符串变量。

fun main(args: Array<String>) {
　　　　var myString = "Hey!"
　　　　println("myString = $myString")
　　　　myString = "Hello!"
　　　　println("myString = $myString")
}

Die Ausgabe beim Ausführen des Programms ist:

myString = Hey!
myString = Hello!

String-Literal

Literale sind die Quellcode-Repräsentation von festen Werten. Zum Beispiel ist "Hey there!" ein direkter Aufruf im Programm, der keine Berechnung erfordert und daher ein String-Literal (wieVariable)

In Kotlin gibt es zwei Arten von String-Literalen:

1.escaped String

Zeichen können in einem escaped String bereits escaped sein. Zum Beispiel

val myString = "Hey there!\n"

Hier ist \n ein Escape-Zeichen, das verwendet wird, um einen Zeilenumbruch an der gewünschten Stelle im Text einzufügen.

Hier ist die Liste der Escape-Zeichen, die Kotlin unterstützt:

• \t -　 Einfügen von Tabulator

• \b - Einfügen von Backspace

• \n - Einfügen von Zeilenumbruch

• \r - Einfügen von Zeilenumbruch

• \' - Einfügen von einfachen Anführungszeichen

• \" - Einfügen von doppelten Anführungszeichen

• \\ - Einfügen von Backslash

• \$ - Einfügen von Dollarzeichen

2.ursprünglicher String

Der ursprüngliche String kann Zeilenumbrüche (keine Zeilenumbrüche) und beliebigen Text enthalten. Der ursprüngliche String wird durch dreifache Anführungszeichen """ getrennt. Zum Beispiel:

fun main(args: Array<String>) {
　　　　val myString = """
　　　　for (character in "Hey!")
　　　　　　　　println(character)
"""
　　　　print(myString)
}

Die Ausgabe beim Ausführen des Programms ist:

　　　　for (character in "Hey!")
　　　　　　　　println(character)

Sie können die trimMargin()-Funktion verwenden, um führende Leerzeichen aus dem ursprünglichen String zu entfernen. Zum Beispiel:

Beispiel: Drucke den ursprünglichen String aus

fun main(args: Array<String>) {
　　　　println("Ausgabe ohne trimMargin()-Funktion:")
　　　　val myString = """
　　　　|Kotlin ist interessant.
　　　　|Kotlin wird von JetBrains gesponsert und entwickelt.
"""
　　　　println(myString)
　　　　println("Ausgabe mit der trimMargin()-Funktion:\n")
　　　　println(myString.trimMargin())
}

Die Ausgabe beim Ausführen des Programms ist:

Ausgabe ohne trimMargin()-Funktion:
　　　　|Kotlin ist interessant.
　　　　|Kotlin wird von JetBrains gesponsert und entwickelt.
Ausgabe mit der trimMargin()-Funktion:
Kotlin ist interessant.
Kotlin wird von JetBrains gesponsert und entwickelt.

Standardmäßig verwendet die trimMargin()-Funktion | als Präfix für den Abstand. Sie können es jedoch ändern, indem Sie einem neuen String übergeben.

Beispiel: trimMargin()-Funktion mit Parameter

fun main(args: Array<String>) {
　　　　val myString = """
　　　　!!!　Kotlin ist interessant.
　　　　!!!　Kotlin wird von JetBrains gesponsert und entwickelt.
"""
　　　　println(myString.trimMargin("!!!　"))
}

Die Ausgabe beim Ausführen des Programms ist:

Kotlin ist interessant.
Kotlin wird von JetBrains gesponsert und entwickelt.

Kotlin String-Templates

Kotlin hat eine großartige Funktion namens String-Templates, die es ermöglicht, Strings mit Template-Expressionen zu enthalten.

String-Templates beginnen mit dem Dollarzeichen $. Hier sind einige Beispiele:

Beispiel: Kotlin-String-Templates

fun main(args: Array<String>) {
　　　　val myInt =　5;
　　　　val myString = "myInt = $myInt"
　　　　println(myString)
}

Die Ausgabe beim Ausführen des Programms ist:

myInt =　5

Dies liegt daran, dass der Ausdruck $myInt (ein Ausdruck, der mit einem $-Zeichen beginnt) ausgewertet und an den String angehängt wird.

Beispiel: String-Templates mit ursprünglichen Strings

fun main(args: Array<String>) {
　　　　val a =　5
　　　　val b =　6
　　　　val myString = """
　　　　|${if (a > b) a else b}
"""
　　　　println("Der größere Wert ist: ${myString.trimMargin()}")
}

Die Ausgabe beim Ausführen des Programms ist:

Der größere Wert ist:　6

Mehrere String-Attribute und -Funktionen

Da Literale in Kotlin als Instanzen der String-Klasse implementiert sind, können Sie mehrere Methoden und Eigenschaften dieser Klasse verwenden.

• length-Eigenschaft - Gibt die Länge der Zeichenfolge zurück.

• compareTo-Funktion -Vergleicht diesen String (Objekt) mit dem angegebenen Objekt. Wenn das Objekt dem angegebenen Objekt entspricht, wird 0 zurückgegeben.
  

• get-Funktion - Gibt den Buchstaben an der angegebenen Stelle zurück. Sie können den Index-Operator anstatt der get-Funktion verwenden, da der Index-Operator intern die get-Funktion aufruft.

• plus-Funktion - Gibt einen neuen String zurück, der durch das Anhängen des Strings erhalten wird, der diesem Funktion übergeben wird. Sie können + Der Operator ersetzt die plus-Funktion, weil+Der Operator ruft im Hintergrund die plus-Funktion auf.
  

• subSequence-Funktion - Gibt eine neue Zeichenfolge zurück, die von den angegebenen Start- und Endindizes definiert wird.

Beispiel: String-Attribute und -Funktionen

fun main(args: Array<String>) {
　　　　val s1　　= "Hey there!"
　　　　val s2　= "Hey there!"
　　　　var result: String
　　　　println("s1Die Länge des Strings ${s1.length}) "
　　　　result = if (${s1.compareTo(s2) == 0) "gleich" else "ungleich"
　　　　println("Der String s1und s2ist ${result})
　　　　//　s1.get()2) entspricht ${s1[2]
　　　　println("der dritte Buchstabe ist ${s1.get()2}).toString())
　　　　result = s1.plus(" How are you?")　//　result = s1　+　" How are you?"
　　　　println("result = $result")
　　　　println("Der Unterstring ist "${s1.subSequence(4,　7}}
}

Beim Ausführen des Programms wird ausgegeben:

s1Die Länge der Zeichenkette ist　10.
Zeichenkette s1und s2Ist gleich.
Der dritte Buchstabe ist y.
result = Hey there! How are you?
Der Unterstring ist "the"