Kotlin Grundlegende Datentypen
Kotlins grundlegende numerische Typen umfassen Byte, Short, Int, Long, Float, Double usw.
Im Gegensatz zu Java sind Zeichen kein numerischer Typ, sondern ein eigenständiger Datentyp.
Ganzzahltypen
- Byte: 8-bit, Bereich von -128 bis 127.
- Short: 16-bit, Bereich von -32,768 bis 32,767.
- Int: 32-Bit, Bereich von -2^31 bis 2^31 - 1.
- Long: 64-Bit, Bereich von -2^63 bis 2^63 - 1.
Gleitkommatypen
- Float: 32-Bit, einfache Genauigkeit, mit 6-7 signifikanten Stellen.
- Double: 64-Bit, doppelte Genauigkeit, mit 15-16 signifikanten Stellen.
Zeichentyp
- Char: 16-Bit-Unicode-Zeichen.
Boolescher Typ
- Boolean: hat zwei Werte:
trueundfalse。
String-Typ
- String: eine Folge von Zeichen.
Array-Typ
Kotlin bietet Array-Typen, um Elemente desselben Typs zu speichern, zum Beispiel:
- IntArray: speichert
IntTyp-Array. - DoubleArray: speichert
DoubleTyp-Array. - Array<T>: generisches Array, kann jeden Typ speichern.
| Type | Bitbreite |
|---|---|
| Double | 64 |
| Float | 32 |
| Long | 64 |
| Int | 32 |
| Short | 16 |
| Byte | 8 |
Beispiele
// Ganzzahltypen
val byteValue: Byte = 127
val shortValue: Short = 32767
val intValue: Int = 2147483647
val longValue: Long = 9223372036854775807L
// Gleitkommatypen
val floatValue: Float = 3.14F
val doubleValue: Double = 3.141592653589793
// Zeichentyp
val charValue: Char = 'A'
// Boolean-Typ
val booleanValue: Boolean = true
// String-Typ
val stringValue: String = "Hallo, Kotlin!"
// Array-Typ
val intArray: IntArray = intArrayOf(1, 2, 3, 4, 5)
val doubleArray: DoubleArray = doubleArrayOf(1.1, 2.2, 3.3)
val stringArray: Array<String> = arrayOf("Kotlin", "Java", "Python")
// Alle Werte ausgeben
println("Byte-Wert: $byteValue")
println("Short-Wert: $shortValue")
println("Int-Wert: $intValue")
println("Long-Wert: $longValue")
println("Float-Wert: $floatValue")
println("Double-Wert: $doubleValue")
println("Char-Wert: $charValue")
println("Boolean-Wert: $booleanValue")
println("String-Wert: $stringValue")
println("Int Array: ${intArray.joinToString()}")
println("Double Array: ${doubleArray.joinToString()}")
println("String Array: ${stringArray.joinToString()}")
}
Literale Konstanten
Das Folgende sind literale Konstanten aller Typen:
- Dezimal: 123
- Long-Ganzzahlen enden mit einem großen L: 123L
- Hexadezimal beginnt mit 0x: 0x0F
- Binär beginnt mit 0b: 0b00001011
- Hinweis: Oktal wird nicht unterstützt
Kotlin unterstützt außerdem Gleitkommawerte in traditioneller Notation:
- Standardnotation für Doubles:
123.5,123.5e10 - Floats verwenden das Suffix f oder F:
123.5f
Sie können Unterstriche verwenden, um numerische Konstanten lesbarer zu machen:
val oneMillion = 1_000_000 val creditCardNumber = 1234_5678_9012_3456L val socialSecurityNumber = 999_99_9999L val hexBytes = 0xFF_EC_DE_5E val bytes = 0b11010010_01101001_10010100_10010010
Zwei Zahlen vergleichen
In Kotlin können zum Vergleich zweier Zahlen Standard-Vergleichsoperatoren verwendet werden, darunter==、!=、<、>、<=und>=. Diese Operatoren können grundlegende Datentypen vergleichen, wie z. B.Int、Double、Floatusw.
fun main() {
val a: Int = 5
val b: Int = 10
val c: Double = 5.0
// 相等和不相等比较
println("a == b: ${a == b}") // 输出 false
println("a != b: ${a != b}") // 输出 true
// 大小比较
println("a < b: ${a < b}") // 输出 true
println("a > b: ${a > b}") // 输出 false
println("a <= b: ${a <= b}") // 输出 true
println("a >= b: ${a >= b}") // 输出 false
// 不同类型的比较
println("a == c: ${a == c}") // 输出 true,Kotlin 自动将 Int 转换为 Double 进行比较
println("a < c: ${a < c}") // 输出 false
println("a > c: ${a > c}") // 输出 false
}
Typumwandlung: Kotlin führt beim Vergleich unterschiedlicher Datentypen automatisch eine Typumwandlung durch. Zum Beispiel im obigen Beispiel,
aJaIntTyp, undcJaDoubleTyp, wird Kotlin automatisch konvertierenaaufDoubleTyp für den Vergleich.Gleichheit: In Kotlin,
==Operator wird für den Vergleich struktureller Gleichheit verwendet, d. h. für den Vergleich von Werten, während===Operator wird für den Vergleich referenzieller Gleichheit verwendet, d. h. ob die Objekte dieselbe Instanz sind. Beim Vergleich grundlegender Datentypen wird der==Operator normalerweise verwendet.
fun main() {
val x: Int = 1000
val y: Int = 1000
println("x == y: ${x == y}") // 输出 true,值相等
println("x === y: ${x === y}") // 输出 false,不同的实例
val z: Int = x
println("x === z: ${x === z}") // 输出 true,引用相同
}In diesem Beispiel,xundyWerte sind gleich, aber sie sind unterschiedliche Instanzen, daherx === yzurückgibtfalse. Aberxundzverweisen auf dieselbe Instanz, alsox === zzurückgibttrue。
Typumwandlung
Aufgrund unterschiedlicher Darstellungen sind kleinere Typen keine Untertypen größerer Typen, und kleinere Typen können nicht implizit in größere Typen konvertiert werden. Das bedeutet, wir können einen Byte-Wert nicht ohne explizite Konvertierung einer Int-Variablen zuweisen.
val b: Byte = 1 // OK, 字面值是静态检测的 val i: Int = b // 错误
Stattdessen können wir seine toInt()-Methode verwenden.
val b: Byte = 1 // OK, 字面值是静态检测的 val i: Int = b.toInt() // OK
Jeder Datentyp besitzt die folgenden Methoden, die in andere Typen konvertieren können:
toByte(): Byte toShort(): Short toInt(): Int toLong(): Long toFloat(): Float toDouble(): Double toChar(): Char
In einigen Fällen ist auch eine automatische Typkonvertierung möglich, vorausgesetzt, dass der korrekte Datentyp aus dem Kontext abgeleitet werden kann und die mathematischen Operatoren entsprechend überladen sind. Zum Beispiel ist Folgendes korrekt:
val l = 1L + 3 // Long + Int => Long
Bitweise Operatoren
Für die Typen Int und Long gibt es ebenfalls eine Reihe von bitweisen Operatoren, die verwendet werden können, nämlich:
shl(bits) – 左移位 (Java’s <<) shr(bits) – 右移位 (Java’s >>) ushr(bits) – 无符号右移位 (Java’s >>>) and(bits) – 与 or(bits) – 或 xor(bits) – 异或 inv() – 反向
Zeichen
Anders als in Java kann Char in Kotlin nicht direkt mit Zahlen operieren, und Char muss in einfache Anführungszeichen eingeschlossen werden'. Zum Beispiel gewöhnliche Zeichen '0', 'a'.
fun check(c: Char) {
if (c == 1) { // 错误:类型不兼容
// ……
}
}
Zeichenliterale werden in einfache Anführungszeichen eingeschlossen: '1'. Sonderzeichen können mit Backslashes maskiert werden. Die folgenden Escape-Sequenzen werden unterstützt: \t, \b, \n, \r, \', \", \\ und \$. Um andere Zeichen zu kodieren, verwenden Sie die Syntax für Unicode-Escape-Sequenzen: '\uFF00'.
Wir können ein Zeichen explizit in eine Int-Zahl konvertieren:
fun decimalDigitValue(c: Char): Int {
if (c !in '0'..'9')
throw IllegalArgumentException("Out of range")
return c.toInt() - '0'.toInt() // 显式转换为数字
}
Wenn eine nullbare Referenz benötigt wird, werden Zahlen und Zeichen geboxt. Boxing-Operationen bewahren die Identität nicht.
Boolean
Boolean wird durch den Typ Boolean dargestellt, der zwei Werte hat: true und false.
Wenn eine nullbare Referenz benötigt wird, werden boolesche Werte geboxt.
Eingebaute boolesche Operationen umfassen:
|| – Short-circuit logical OR && – Short-circuit logical AND ! - Logical NOT
Arrays
Arrays werden mit der Array-Klasse implementiert und besitzen außerdem eine size-Eigenschaft sowie get- und set-Methoden. Da [] die get- und set-Methoden überlädt, können wir den Wert an der entsprechenden Position des Arrays einfach per Index abrufen oder setzen.
Es gibt zwei Möglichkeiten, ein Array zu erstellen: Eine besteht in der Verwendung der Funktion arrayOf(); die andere in der Verwendung von Factory-Funktionen. Wie unten gezeigt, haben wir auf zwei Arten zwei Arrays erstellt:
fun main(args: Array<String>) {
//[1,2,3]
val a = arrayOf(1, 2, 3)
//[0,2,4]
val b = Array(3, { i -> (i * 2) })
//读取数组内容
println(a[0]) // 输出结果:1
println(b[1]) // 输出结果:2
}
Wie oben erwähnt, steht der []-Operator für den Aufruf der Memberfunktionen get() und set().
Hinweis: Im Gegensatz zu Java sind Arrays in Kotlin invariant.
Neben der Array-Klasse gibt es auch ByteArray, ShortArray, IntArray, die Arrays verschiedener Typen repräsentieren, Boxing-Operationen eliminieren und daher effizienter sind. Ihre Verwendung ist dieselbe wie bei Array:
val x: IntArray = intArrayOf(1, 2, 3) x[0] = x[1] + x[2]
Zeichenketten
Wie in Java ist String unveränderlich. Mit der eckigen Klammer []-Syntax kann man leicht ein Zeichen im String abrufen und außerdem den String mit einer for-Schleife durchlaufen:
for (c in str) {
println(c)
}Kotlin unterstützt Strings, die durch drei Anführungszeichen """ eingeschlossen werden, und unterstützt mehrzeilige Strings, zum Beispiel:
fun main(args: Array<String>) {
val text = """
多行字符串
多行字符串
"""
println(text) // 输出有一些前置空格
}
String kann die Methode trimMargin() verwenden, um zusätzlichen Leerraum zu entfernen.
fun main(args: Array<String>) {
val text = """
|多行字符串
|Example
|多行字符串
|Example
""".trimMargin()
println(text) // 前置空格删除了
}
Standardmäßig wird | als Begrenzungspräfix verwendet, aber man kann ein anderes Zeichen wählen und es als Parameter übergeben, z. B. trimMargin(">").
String-Vorlagen
Strings können Template-Ausdrücke enthalten, d. h. kleine Codefragmente, die ausgewertet und deren Ergebnisse in den String eingefügt werden. Template-Ausdrücke beginnen mit einem Dollarzeichen ($) und bestehen aus einem einfachen Namen:
fun main(args: Array<String>) {
val i = 10
val s = "i = $i" // 求值结果为 "i = 10"
println(s)
}
Oder beliebige Ausdrücke, die in geschweifte Klammern eingeschlossen sind:
fun main(args: Array<String>) {
val s = "example"
val str = "$s.length is ${s.length}" // 求值结果为 "example.length is 6"
println(str)
}
Templates werden sowohl in Raw-Strings als auch in escaped Strings unterstützt. Wenn Sie das literale $-Zeichen in einem Raw-String darstellen müssen (der kein Backslash-Escaping unterstützt), können Sie die folgende Syntax verwenden:
fun main(args: Array<String>) {
val price = """
${'$'}9.99
"""
println(price) // 求值结果为 $9.99
}
Weitere Erweiterungen