Kotlin tipos de datos básicos

Los tipos numéricos básicos de Kotlin incluyen Byte, Short, Int, Long, Float, Double, etc.

A diferencia de Java, el carácter no pertenece a los tipos numéricos; es un tipo de dato independiente.

Tipos de enteros

• Byte: 8 bits, rango de -128 a 127.
• Short: 16 bits, rango de -32,768 a 32,767.
• Int: 32 bits, rango de -2^31 a 2^31 - 1.
• Long: 64 bits, rango de -2^63 a 2^63 - 1.

Tipos de coma flotante

• Float: 32 bits, precisión simple, con 6-7 dígitos significativos.
• Double: 64 bits, doble precisión, con 15-16 dígitos significativos.

Tipo carácter

• Char: Carácter Unicode de 16 bits.

Tipo booleano

• Boolean: Tiene dos valores:trueyfalse。

Tipo cadena

• String: Una secuencia de caracteres.

Tipo array

Kotlin proporciona tipos de array para almacenar elementos del mismo tipo, por ejemplo:

• IntArray: AlmacenaIntarrays de tipo.
• DoubleArray: AlmacenaDoublearrays de tipo.
• Array<T>: Array genérico, puede almacenar cualquier tipo.

Constantes literales

A continuación se muestran las constantes literales de todos los tipos:

• Decimal: 123
• Entero largo termina con L mayúscula: 123L
• El hexadecimal comienza con 0x: 0x0F
• El binario comienza con 0b: 0b00001011
• Nota: el octal no es compatible

Kotlin también admite valores de coma flotante con notación tradicional:

• Escritura predeterminada de Doubles:123.5, 123.5e10
• Los Floats usan el sufijo f o F:123.5f

Puedes usar guiones bajos para que las constantes numéricas sean más legibles:

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

Comparar dos números

En Kotlin, comparar dos números puede usar los operadores de comparación estándar, incluyendo==、!=、<、>、<=y>=Estos operadores pueden comparar tipos de datos básicos, comoInt、Double、Floatetc.

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. Conversión de tiposKotlin realiza automáticamente la conversión de tipos al comparar diferentes tipos de datos. Por ejemplo, en el ejemplo anterior,aSíInttipo, mientras quecSíDoubletipo, Kotlin automáticamente convierteaaDoubletipo para comparar.

2. IgualdadEn Kotlin, el operador==se usa para la comparación de igualdad estructural, es decir, comparación de valores, mientras que el operador===se usa para la comparación de igualdad de referencia, es decir, si los objetos son la misma instancia. Al comparar tipos de datos básicos, normalmente se usa el operador==.

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，引用相同
}

En este ejemplo,xyylos valores son iguales, pero son instancias diferentes, por lo tantox === ydevuelvefalse. Sin embargo,xyzhacen referencia a la misma instancia, por lo quex === zdevuelvetrue。

Conversión de tipos

Debido a las diferentes representaciones, los tipos más pequeños no son subtipos de los tipos más grandes y los tipos más pequeños no se pueden convertir implícitamente a tipos más grandes. Esto significa que no podemos asignar un valor de tipo Byte a una variable Int sin una conversión explícita.

val b: Byte = 1 // OK, 字面值是静态检测的
val i: Int = b // 错误

Podemos usar su método toInt() en su lugar.

val b: Byte = 1 // OK, 字面值是静态检测的
val i: Int = b.toInt() // OK

Cada tipo de dato tiene los siguientes métodos para convertirse a otros tipos:

toByte(): Byte
toShort(): Short
toInt(): Int
toLong(): Long
toFloat(): Float
toDouble(): Double
toChar(): Char

En algunos casos también se puede usar la conversión automática de tipos, siempre que el tipo de dato correcto se pueda inferir del contexto y los operadores matemáticos estén sobrecargados en consecuencia. Por ejemplo, lo siguiente es correcto:

val l = 1L + 3 // Long + Int => Long

Operadores de bits

Para los tipos Int y Long, también hay una serie de operadores de bits disponibles, que son:

shl(bits) – 左移位 (Java’s <<)
shr(bits) – 右移位 (Java’s >>)
ushr(bits) – 无符号右移位 (Java’s >>>)
and(bits) – 与
or(bits) – o 
xor(bits) – 异或
inv() – 反向

Carácter

A diferencia de Java, en Kotlin Char no puede operar directamente con números; Char debe estar encerrado'entre comillas simples. Por ejemplo, caracteres normales como '0', 'a'.

fun check(c: Char) {
    if (c == 1) { // 错误：类型不兼容
        // ……
    }
}

Los caracteres literales se escriben entre comillas simples: '1'. Los caracteres especiales se pueden escapar con una barra invertida. Se admiten estas secuencias de escape: \t, \b, \n, \r, \', \", \\ y \$. Para codificar otros caracteres se usa la sintaxis de secuencia de escape Unicode: '\uFF00'.

Podemos convertir explícitamente un carácter a un número Int:

fun decimalDigitValue(c: Char): Int {
    if (c !in '0'..'9')
        throw IllegalArgumentException("Out of range")
    return c.toInt() - '0'.toInt() // 显式转换为数字
}

Cuando se necesita una referencia nullable, tipos como números y caracteres se encajan (boxing). La operación de boxing no conserva la identidad.

Booleano

El booleano se representa con el tipo Boolean, que tiene dos valores: true y false.

Si se necesita una referencia nullable, el booleano se encaja.

Las operaciones booleanas incorporadas son:

|| – OR lógico de cortocircuito  
&& – AND lógico de cortocircuito  
! - NOT lógico

Array

Los arrays se implementan con la clase Array, y además tienen una propiedad size y métodos get y set. Dado que el uso de [] sobrecarga los métodos get y set, podemos obtener o establecer fácilmente el valor en la posición correspondiente del array mediante un índice.

Hay dos formas de crear arrays: una es usar la función arrayOf(); la otra es usar una función de fábrica. Como se muestra a continuación, creamos dos arrays de ambas formas respectivamente:

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
}

Como se mencionó anteriormente, el operador [] representa la llamada a las funciones miembro get() y set().

Nota: a diferencia de Java, en Kotlin los arrays son invariantes.

Además de la clase Array, también existen ByteArray, ShortArray, IntArray, que se utilizan para representar arrays de cada tipo, evitando la operación de boxing, por lo que son más eficientes. Su uso es igual que Array:

val x: IntArray = intArrayOf(1, 2, 3)
x[0] = x[1] + x[2]

Cadena

Igual que en Java, String es inmutable. La sintaxis de corchetes [] permite obtener fácilmente un carácter de la cadena, y también se puede recorrer con un bucle for:

for (c in str) {
    println(c)
}

Kotlin admite cadenas rodeadas por tres comillas """ y soporta cadenas de varias líneas, por ejemplo:

fun main(args: Array<String>) {
    val text = """
    多行字符串
    多行字符串
    """
    println(text)   // 输出有一些前置空格
}

String puede eliminar el espacio en blanco sobrante mediante el método trimMargin().

fun main(args: Array<String>) {
    val text = """
    |多行字符串
    |Ejemplo
    |多行字符串
    |Ejemplo
    """.trimMargin()
    println(text)    // 前置空格删除了
}

Por defecto, | se usa como prefijo de margen, pero puedes elegir otro carácter y pasarlo como argumento, por ejemplo trimMargin(">").

Plantillas de cadena

Las cadenas pueden contener expresiones de plantilla, es decir, pequeños fragmentos de código que se evalúan y cuyo resultado se combina en la cadena. Las expresiones de plantilla comienzan con el signo de dólar ($) y consisten en un nombre simple:

fun main(args: Array<String>) {
    val i = 10
    val s = "i = $i" // 求值结果为 "i = 10"
    println(s)
}

O cualquier expresión entre llaves:

fun main(args: Array<String>) {
    val s = "ejemplo"
    val str = "$s.length is ${s.length}" // 求值结果为 "ejemplo.length is 6"
    println(str)
}

Tanto las cadenas nativas como las cadenas con escape admiten plantillas. Si necesitas representar el carácter $ literal en una cadena nativa (que no admite escape con barra invertida), puedes usar la siguiente sintaxis:

fun main(args: Array<String>) {
    val price = """
    ${'$'}9.99
    """
    println(price)  // 求值结果为 $9.99
}