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: speichertIntTyp-Array.
  • DoubleArray: speichertDoubleTyp-Array.
  • Array<T>: generisches Array, kann jeden Typ speichern.
Type Bitbreite
Double 64
Float 32
Long 64
Int 32
Short 16
Byte 8

Beispiele

fun main() {
    // 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
}
  1. 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.

  2. 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