Tipos de Datos en Kotlin – Parte 3 (Final)

6 minuto(s)

En esta página:

En la parte 2 o la anterior llamada Tipos de Datos en Kotlin – Parte 2, apreciamos un segundo grupo de tipos de datos que existen en el Lenguaje de Programación Kotlin, tales como los tipos enteros sin signo, que tiene en su haber a los arrays y rangos sin firmar y los literales enteros sin signo, también vimos los tipos de datos Booleano que básicamente esta compuesto por true y false. Por último hablamos de los tipos de datos Char o Caracteres. En esta tercera y última parte veremos un último grupo de tipos de datos que existen en Kotlin, vamos con ello.

Partes

Parte 1
Parte 2
Parte 3 (Final)

Antes de continuar con este Post, te invito a leer los siguientes artículos:

Asimismo antes de continuar, te invito a escuchar el Podcast: “Donde buscar ayuda sobre Programación” y “5 Habilidades que Debe Tener un Desarrollador Backend” (Anchor Podcast):

Spotify:	Sound Cloud:	Apple Podcasts	Anchor Podcasts

Bien ahora continuemos con el Post: Tipos de Datos en Kotlin – Parte 3 (Final).

Strings

Las strings o cadenas en Kotlin están representadas por el tipo String. Generalmente, el valor de un string es una secuencia de caracteres entre comillas dobles (“):


// String 
val str = "abcd 123"

// String

val str = "abcd 123"

Los elementos de una cadena son caracteres a los que puedes acceder a través de la operación de indexación: s[i]. Puedes iterar sobre estos caracteres con un bucle for:


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

for (c in str) {

println(c)

}

Las cadenas son inmutables. Una vez que inicializas una cadena, no puedes cambiar su valor ni asignarle un nuevo valor. Todas las operaciones que transforman cadenas devuelven sus resultados en un nuevo objeto String, dejando la cadena original sin cambios:


val str = "abcd"
println(str.uppercase()) // Crear e imprimir un nuevo objeto String 
println(str) // La cadena original sigue siendo la misma

val str = "abcd"

println(str.uppercase()) // Crear e imprimir un nuevo objeto String

println(str) // La cadena original sigue siendo la misma

Para concatenar cadenas, utiliza el operador +. Esto también funciona para concatenar cadenas con valores de otros tipos, siempre que el primer elemento de la expresión sea una cadena:


val s = "abc" + 1
println(s + "def")

val s = "abc" + 1

println(s + "def")

En la mayoría de los casos, es preferible utilizar plantillas de cadenas o cadenas sin formato a la concatenación de cadenas.

String Literales

Kotlin tiene dos tipos de literales de cadena: Cadenas escapadas o Cadenas en bruto, veamos de tratan ambas a continuación.

Cadenas Escapadas

Las cadenas escapadas pueden contener caracteres escapados. Aquí hay un ejemplo de una cadena escapada:


// Cadena escapada 
val s = "Hola, mundo!\n"

// Cadena escapada

val s = "Hola, mundo!\n"

El escape se realiza de forma convencional, con una barra invertida (\). Consulta la página Chars para ver la lista de secuencias de escape admitidas.

Cadenas en bruto

Las cadenas sin procesar pueden contener líneas nuevas y texto arbitrario. Está delimitado por una comilla triple (“””), no contiene escapes y puede contener saltos de línea y cualquier otro carácter:


val text = """
    for (c in "foo")
        print(c)
"""

val text = """

for (c in "foo")

print(c)

"""

Para eliminar los espacios en blanco iniciales de las cadenas sin procesar, usa la función trimMargin():


val text = """
    |Tell me and I forget.
    |Teach me and I remember.
    |Involve me and I learn.
    |(Benjamin Franklin)
    """.trimMargin()

val text = """

|Tell me and I forget.

|Teach me and I remember.

|Involve me and I learn.

|(Benjamin Franklin)

""".trimMargin()

De manera predeterminada, se usa un símbolo de pipe | como prefijo de margen, pero puedes elegir otro carácter y pasarlo como parámetro, como trimMargin(“>”).

Plantillas de String

Los literales de cadena pueden contener expresiones de plantilla – fragmentos de código que se evalúan y cuyos resultados se concatenan en la cadena. Una expresión de plantilla comienza con un signo de dólar ($) y consta de un nombre:


val i = 10
println("i = $i") // Imprime "i = 10"

val i = 10

println("i = $i") // Imprime "i = 10"

o una expresión entre llaves:


val s = "abc"
println("$s.length is ${s.length}") // Imprime "abc.length es 3"

val s = "abc"

println("$s.length is ${s.length}") // Imprime "abc.length es 3"

Puedes usar plantillas tanto en cadenas sin formato como con escape. Para insertar el signo de dólar $ en una cadena sin formato (que no admite el escape de barra invertida o backslash) antes de cualquier símbolo, que se permite como comienzo de un identificador, usa la siguiente sintaxis:


val price = """
${'$'}_9.99
"""

val price = """

${'$'}_9.99

"""

Ahora pasemos al siguiente y último tipo de datos de Kotlin.

Arrays

Las arrays o matrices en Kotlin están representadas por la clase Array. Tiene funciones get() y set() que se convierten en convenciones [] de sobrecarga de operadores y la propiedad size, junto con otras funciones miembro útiles:


class Array<T> private constructor() {
    val size: Int
    operator fun get(index: Int): T
    operator fun set(index: Int, value: T): Unit

    operator fun iterator(): Iterator<T>
    // ...
}

class Array<T> private constructor() {

val size: Int

operator fun get(index: Int): T

operator fun set(index: Int, value: T): Unit

operator fun iterator(): Iterator<T>

// ...

}

Para crear una matriz, usa la función arrayOf() y pásele los valores de los elementos, de modo que arrayOf(1, 2, 3) cree una matriz [1, 2, 3]. Alternativamente, la función arrayOfNulls() se puede usar para crear una matriz de un tamaño dado llena de elementos null.

Otra opción es usar el constructor Array que toma el tamaño del array y la función que devuelve valores de los elementos del array dado su índice:


// Crea un Array<String> con los valores ["0", "1", "4", "9", "16"]
val asc = Array(5) { i -> (i * i).toString() }
asc.forEach { println(it) }

// Crea un Array<String> con los valores ["0", "1", "4", "9", "16"]

val asc = Array(5) { i -> (i * i).toString() }

asc.forEach { println(it) }

La operación [] representa llamadas a funciones miembro get() y set().

Las arrays o matrices en Kotlin son invariantes. Esto significa que Kotlin no nos permite asignar un Array<String> a un Array<Any>, lo que evita una posible falla en el tiempo de ejecución (pero puedes usar Array<out Any>, consulta Type Projections).

Arrays de Tipo Primitivos

Kotlin también tiene clases que representan arreglos de tipos primitivos sin sobrecarga: ByteArray, ShortArray, IntArray, etc. Estas clases no tienen una relación de herencia con la clase Array, pero tienen el mismo conjunto de métodos y propiedades. Cada uno de ellos también tiene una función de fábrica correspondiente:


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

val x: IntArray = intArrayOf(1, 2, 3)

x[0] = x[1] + x[2]


// Array de int de tamaño 5 con valores [0, 0, 0, 0, 0]
val arr = IntArray(5)

// Ejemplo de inicialización de los valores en la matriz con una constante
// Array de int de tamaño 5 con valores [42, 42, 42, 42, 42]
val arr = IntArray(5) { 42 }

// Ejemplo de inicialización de los valores en la matriz usando una lambda 
// Array de int de tamaño 5 con valores [0, 1, 2, 3, 4] (valores inicializados a su valor de índice)
var arr = IntArray(5) { it * 1 }

// Array de int de tamaño 5 con valores [0, 0, 0, 0, 0]

val arr = IntArray(5)

// Ejemplo de inicialización de los valores en la matriz con una constante

// Array de int de tamaño 5 con valores [42, 42, 42, 42, 42]

val arr = IntArray(5) { 42 }

// Ejemplo de inicialización de los valores en la matriz usando una lambda

// Array de int de tamaño 5 con valores [0, 1, 2, 3, 4] (valores inicializados a su valor de índice)

var arr = IntArray(5) { it * 1 }

Bien, hasta aquí llegamos con todos los tipos de datos que existen en Kotlin. Como se mencionó en la primera parte de este post, hemos visto aspectos teóricos de estos tipos de datos y más adelante desarrollaremos proyectos en donde podamos ver como funcionan y se ven estos tipos de datos en una tabla de una base de datos.

Conclusión

En este post que consta de 3 partes, hemos visto los tipos de datos que existen en el Lenguaje de Programación Kotlin, recuerda usarlos adecuadamente cuando crees tus proyectos, una ves que entiendas como funcionan y los domines, lograrás realizar un correcta gestión de los datos en tu proyecto creado con Kotlin. Recuerda prácticar, esto te hará crecer.