Tutorial Kotlin: Cadenas de texto y manipulación

Operaciones básicas con cadenas

En Kotlin, las cadenas de texto (String) son inmutables, lo que significa que una vez creadas no pueden modificarse. Sin embargo, es posible crear nuevas cadenas basadas en las existentes mediante diversas operaciones.

La concatenación es una operación fundamental que permite unir dos o más cadenas para formar una sola. En Kotlin, el operador + se utiliza para concatenar cadenas de manera sencilla:

val saludo = "Hola"
val nombre = "Ana"
val mensaje = saludo + ", " + nombre + "!"
println(mensaje) // Imprime: Hola, Ana!

Para acceder a un carácter específico dentro de una cadena, se puede emplear la notación de índices similar a la de los arrays. Los índices comienzan en cero, y es posible obtener caracteres individuales:

val palabra = "Kotlin"
val primerCaracter = palabra[0]     // 'K'
val tercerCaracter = palabra[2]     // 't'
val ultimoCaracter = palabra[palabra.length - 1] // 'n'

La propiedad length es útil para obtener la longitud de una cadena, es decir, el número total de caracteres que contiene:

val frase = "Lenguaje de programación"
val longitud = frase.length
println("La frase tiene $longitud caracteres") // Imprime: La frase tiene 24 caracteres

Para extraer subcadenas, el método substring permite obtener una porción de la cadena original especificando el índice inicial y el índice final (este último es opcional):

val texto = "Desarrollador"
val subcadena1 = texto.substring(0, 5) // "Desar"
val subcadena2 = texto.substring(5)    // "rollador"
println(subcadena1)
println(subcadena2)

Es común necesitar verificar si una cadena contiene una secuencia específica de caracteres. El método contains devuelve true si la subcadena está presente y false en caso contrario:

val mensaje = "Bienvenidos al mundo de Kotlin"
val contieneMundo = mensaje.contains("mundo")
println("¿El mensaje contiene 'mundo'? $contieneMundo") // Imprime: ¿El mensaje contiene 'mundo'? true

Para comparar el contenido de dos cadenas, se utiliza el operador ==. Este operador compara los valores de las cadenas y no sus referencias en memoria:

val cadenaA = "kotlin"
val cadenaB = "kotlin"
val sonIguales = cadenaA == cadenaB   // true
println("¿Las cadenas son iguales? $sonIguales")

Si se desea realizar una comparación que ignore las mayúsculas y minúsculas, el método equals con el parámetro ignoreCase es la opción adecuada:

val cadena1 = "Kotlin"
val cadena2 = "kotlin"
val sonIgualesIgnorandoCase = cadena1.equals(cadena2, ignoreCase = true) // true
println("¿Las cadenas son iguales ignorando mayúsculas? $sonIgualesIgnorandoCase")

Para localizar la posición de una subcadena o carácter dentro de una cadena, los métodos indexOf y lastIndexOf son de utilidad. Devuelven el índice donde se encuentra la subcadena o -1 si no se encuentra:

val frase = "Aprender Kotlin es divertido"
val indiceKotlin = frase.indexOf("Kotlin")     // 9
val indiceNoExiste = frase.indexOf("Java")     // -1
println("La palabra 'Kotlin' está en el índice $indiceKotlin")

Los métodos startsWith y endsWith permiten comprobar si una cadena comienza o termina con una secuencia determinada:

val archivo = "documento.pdf"
val esPDF = archivo.endsWith(".pdf")
val comienzaConDoc = archivo.startsWith("doc")
println("¿El archivo es un PDF? $esPDF")
println("¿El archivo comienza con 'doc'? $comienzaConDoc")

Para modificar el caso de los caracteres en una cadena, se utilizan los métodos uppercase() y lowercase() que convierten todos los caracteres a mayúsculas o minúsculas respectivamente:

val entrada = "Kotlin"
val todoMayusculas = entrada.uppercase()   // "KOTLIN"
val todoMinusculas = entrada.lowercase()   // "kotlin"
println(todoMayusculas)
println(todoMinusculas)

Cuando se trabaja con entradas de usuario, es común que existan espacios en blanco adicionales. El método trim() elimina los espacios al inicio y al final de una cadena, facilitando su procesamiento:

val usuario = "   invitado   "
val usuarioLimpio = usuario.trim()
println("Bienvenido, '$usuarioLimpio'")    // Imprime: Bienvenido, 'invitado'

En operaciones más avanzadas, es posible reemplazar partes de una cadena utilizando el método replace, que sustituye todas las ocurrencias de una secuencia específica por otra:

val textoOriginal = "La programación en Java es interesante"
val textoModificado = textoOriginal.replace("Java", "Kotlin")
println(textoModificado)   // Imprime: La programación en Kotlin es interesante

Estas operaciones básicas con cadenas permiten manipular y gestionar textos de manera efectiva en Kotlin, facilitando el desarrollo de aplicaciones que requieren procesamiento de información textual.

Formateo de cadenas

El formateo de cadenas en Kotlin es una herramienta esencial que permite incorporar valores y expresiones dentro de una cadena de texto de manera clara y concisa. Para ello, Kotlin proporciona las plantillas de cadenas, que facilitan la inclusión de variables y resultados de expresiones directamente en el texto.

Para insertar el valor de una variable en una cadena, se utiliza el símbolo $ seguido del nombre de la variable:

val nombre = "Carlos"
val saludo = "Hola, $nombre!"
println(saludo) // Imprime: Hola, Carlos!

Cuando se desea incluir una expresión más compleja dentro de la cadena, se encierra dicha expresión entre llaves {} precedidas por el símbolo $:

val a = 5
val b = 3
println("La suma de $a y $b es ${a + b}") // Imprime: La suma de 5 y 3 es 8

Las plantillas de cadenas permiten mejorar la legibilidad del código y reducir errores que podrían surgir con la concatenación tradicional. Además, es posible utilizar métodos y propiedades dentro de las expresiones:

val texto = "Kotlin"
println("El texto '$texto' tiene ${texto.length} caracteres") // Imprime: El texto 'Kotlin' tiene 6 caracteres

Para manejar cadenas que contienen caracteres especiales o que abarcan múltiples líneas, Kotlin ofrece las cadenas crudas o raw strings, delimitadas por """ (tres comillas dobles). Estas cadenas preservan el formato original, incluyendo saltos de línea y espacios:

val mensaje = """
    |Querido usuario,
    |
    |    Le informamos que su suscripción ha sido activada.
    |
    |Atentamente,
    |El equipo de soporte
""".trimMargin()
println(mensaje)

En este ejemplo, el método trimMargin() elimina el carácter | usado como marcador de margen y ajusta la indentación adecuadamente.

Cuando se requiere formatear números con decimales específicos o dar formato a fechas y otros tipos, se pueden utilizar las funciones de la clase String y librerías estándar. Por ejemplo, para formatear un número con dos decimales:

val precio = 9.99
println("El precio es €${"%.2f".format(precio)}") // Imprime: El precio es €9.99

Es importante destacar que, aunque Kotlin es interoperable con Java, y por lo tanto puede utilizar String.format() de Java, se recomienda utilizar las características propias de Kotlin para mantener la consistencia y aprovechar las ventajas del lenguaje.

Las plantillas de cadenas también permiten anidar expresiones y llamadas a funciones, lo que brinda una gran flexibilidad al construir cadenas dinámicamente:

fun obtenerDescuento(cantidad: Int): Int {
    return if (cantidad > 10) 10 else 0
}

val cantidad = 15
println("Para una compra de $cantidad artículos, el descuento es del ${obtenerDescuento(cantidad)}%") // Imprime: Para una compra de 15 artículos, el descuento es del 10%

Al trabajar con cadenas que incluyen el símbolo $ o {}, y se desea representarlos literalmente, es necesario escapar estos caracteres utilizando \:

val expresion = "Expresión: \$a + \$b"
println(expresion) // Imprime: Expresión: $a + $b

Las cadenas crudas también permiten evitar el uso de caracteres de escape para comillas y saltos de línea, facilitando la manipulación de textos más complejos o bloques de código:

val consultaSQL = """
    SELECT * FROM usuarios
    WHERE activo = true
    ORDER BY fecha_registro DESC
"""
println(consultaSQL)