5. Clases de Kotlin de uso común
Aquí presentamos algunas clases y funciones de uso común: cadenas, arreglos, colecciones, archivos y expresiones regulares. Kotlin ofrece dos bibliotecas para este fin: su propia biblioteca estándar (paquetes [kotlin.text], [kotlin.collections], [kotlin.io]…), que agrega cientos de funciones a los tipos básicos —la mayoría en forma de funciones de extensión (Capítulo 4)— y el JDK (la API Java SE), que Kotlin utiliza directamente, sin ninguna adaptación. A esto se suman las operaciones funcionales sobre colecciones ([filter], [map], [groupBy]…) y las secuencias, que son la forma estándar en Kotlin de buscar, ordenar, agrupar o transformar los elementos de una colección: cumplen la misma función que la API Stream de Java. Anteriormente mostramos cómo encontrar información sobre los miles de clases y funciones disponibles. Este recurso es indispensable para los desarrolladores de Kotlin, incluso los experimentados.
Los ejemplos de este capítulo, salvo la aplicación de ejemplo del final, son programas de un solo archivo, organizados como en el Capítulo 3 dentro del proyecto Gradle [05-classes-kotlin] del código del curso: el programa [Strings01.kt] está en el paquete [strings01] (carpeta [src/main/kotlin/strings01]) y puede ejecutarse con el comando [gradlew -q run -Pmain=strings01.Strings01Kt] o haciendo clic en el triángulo verde de IntelliJ o IDEA. A diferencia de los capítulos anteriores, se ejecutan en una máquina configurada en inglés (configuración regional en inglés). Tenga en cuenta que todo archivo Kotlin importa automáticamente los paquetes [kotlin.*], [kotlin.text.*], [kotlin.collections.*], [kotlin.ranges.*], [kotlin.sequences.*], [kotlin.io.*]… así como [java.lang.*]: por lo tanto, las funciones de la biblioteca estándar pueden usarse sin la instrucción [import]. Sin embargo, las clases de los demás paquetes del JDK ([java.util], [java.text], [java.time], [java.nio.file]…) deben importarse, mientras que en el curso de Java esto lo resolvían los archivos fuente compactos.
5.1. Búsqueda de ayuda sobre las clases de Kotlin
La biblioteca estándar de Kotlin contiene varios miles de funciones, y un programa Kotlin para la JVM también tiene acceso a las más de 4,000 clases públicas del JDK. Nadie las conoce todas: los desarrolladores de Kotlin consultan constantemente su documentación. Esta documentación está disponible en línea, de forma gratuita, y se mantiene actualizada para cada versión.
5.1.1. Documentación en línea
El punto de partida es el sitio web kotlinlang.org de JetBrains. Allí encontrará:
- la referencia de la biblioteca estándar: https://kotlinlang.org/api/core/kotlin-stdlib/. Describe, paquete por paquete ([kotlin.text], [kotlin.collections], [kotlin.io]…), todas las clases, interfaces y funciones de la biblioteca —incluidas las funciones de extensión— clasificadas según el tipo que extienden: la página de [String] enumera así tanto sus miembros ([length], [get]…) como las decenas de funciones de extensión que se le aplican ([substringBefore], [padStart], [lines]…);
- un cuadro de búsqueda en la parte superior de cada página donde puede escribir el nombre de una clase o función ([buildString], [joinToString]…);
- la documentación del lenguaje (Language Guide), con páginas sobre cadenas, colecciones, secuencias y más, así como una página “What’s New” que describe las novedades de cada versión. Los cambios del lenguaje se discuten públicamente en forma de propuestas, el proceso KEEP (Kotlin Evolution and Enhancement Process), disponible en github.com/Kotlin/KEEP;
- play.kotlinlang.org, el “área de pruebas” (sandbox) de Kotlin: aquí puede escribir y ejecutar un programa en el navegador sin instalar nada.
Para las clases del JDK utilizadas por un programa Kotlin ([java.time.LocalDate], [java.text.Collator], [java.nio.file.Files]…), la referencia sigue siendo la de la API Java SE 25: https://docs.oracle.com/en/java/javase/25/docs/api/. Describe las clases con la sintaxis de Java, que hay que convertir: un [int] es un [Int], un [String[]] es un [Array<String>], un método [getName()] se usa como una propiedad [name]…
La página de una clase o función, por ejemplo kotlin.String, proporciona:
- el paquete de la clase y las plataformas en las que existe (Kotlin también se ejecuta en JavaScript y en código nativo: algunas funciones son específicas de la JVM);
- su declaración, sus tipos padre y las interfaces que implementa;
- una descripción general, a menudo acompañada de ejemplos ejecutables;
- una lista de sus constructores, propiedades, funciones, miembros y extensiones, seguida de los detalles de cada uno: parámetros, valor de retorno, posibles excepciones y la versión de Kotlin en la que se introdujo (en la sección “Since Kotlin”).
La documentación está en inglés. Una búsqueda con el nombre de la función precedido de "kotlin" ("kotlin joinToString") normalmente lo lleva directamente a la página correcta.
5.1.2. KDoc y la ayuda del editor
Al igual que Javadoc para Java, esta documentación se genera a partir de comentarios de documentación escritos en el código fuente, llamados KDoc en Kotlin. Un comentario de este tipo comienza con [/**] y se coloca inmediatamente antes de una clase, propiedad o función. La función de cálculo del impuesto de la aplicación de ejemplo de este capítulo podría documentarse así:
El comentario comienza con una oración de resumen; las [@param] etiquetas describen los parámetros, y [@return] describe el valor de retorno ([@throws] describiría una excepción, y [@property] describiría una propiedad de clase). A diferencia de Javadoc, que usa etiquetas HTML, el texto de un comentario KDoc se escribe en Markdown: [*italic*], [**bold**], listas y enlaces a otros elementos del código escritos entre corchetes, como [[salary]] o [[TaxBracket]]. La herramienta Dokka de JetBrains, agregada al proyecto como un complemento de Gradle ([id("org.jetbrains.dokka")]), genera páginas HTML similares a las de la referencia de Kotlin.
El editor de código (IntelliJ IDEA, Visual Studio Code con la extensión de Kotlin) aprovecha estos comentarios y ofrece ayuda inmediata sin salir del código:
- el autocompletado: después de escribir [aString.], el editor sugiere una lista de propiedades y funciones aplicables al objeto, que incluye tanto miembros como funciones de extensión (estas últimas se indican con el tipo que extienden, por ejemplo [for String in kotlin.text]), junto con sus parámetros y tipos de retorno;
- La documentación rápida: al pasar el cursor sobre el nombre de una clase o función (o al presionar Ctrl+Q en IntelliJ IDEA) se muestra su KDoc o, para una clase del JDK, su Javadoc;
- La ayuda de parámetros: al escribir el paréntesis de apertura de una llamada (o al presionar Ctrl+P en IntelliJ IDEA), el editor muestra las distintas sobrecargas de la función, el nombre y la función de cada parámetro, y los valores predeterminados, si los hay;
- Ir a la definición (Ctrl+B en IntelliJ, IDEA, F12 en VS Code): muestra el código fuente de la clase o función. Gradle descarga el código fuente de la biblioteca estándar de Kotlin, y el JDK incluye el código fuente de su propia biblioteca (archivo [lib/src.zip]): esto permite leer el código de [joinToString] o de [java.util.ArrayList], lo cual es muy instructivo. El código de la biblioteca estándar de Kotlin suele ser muy corto, ya que se apoya en clases del JDK;
- Show Kotlin Bytecode (menú Tools > Kotlin > Show Kotlin Bytecode , luego el botón Decompile): muestra, en forma de código Java equivalente, lo que el compilador generó a partir del código Kotlin. Es la manera de entender en qué se convierte una función de extensión, una propiedad o un [when].
Por último, para probar una función sin escribir un programa, IntelliJ IDEA ofrece los archivos scratch (File > New > Scratch File > Kotlin): allí se escriben instrucciones y sus resultados se muestran junto a cada línea. En la línea de comandos, el lanzador del compilador (Capítulo 2) evalúa una expresión: [kotlinr -e 'println("abc".repeat(3))'] muestra [abcabcabc].
5.2. Cadenas
5.2.1. El tipo String
El tipo [String] (paquete [kotlin]) representa cadenas de caracteres. En la JVM, una cadena de Kotlin es un objeto [java.lang.String]: el compilador asocia los dos tipos, y una cadena se pasa de Kotlin a Java (y viceversa) sin ninguna conversión. Sin embargo, el tipo [String] tal como lo ve Kotlin tiene solo cuatro miembros ([length], [get], [subSequence], [compareTo]) y el operador [plus]: todas las demás operaciones son funciones de extensión de la biblioteca estándar (paquete [kotlin.text]), que se invocan como métodos. Los métodos Java de [java.lang.String] que tienen un equivalente en Kotlin están ocultos: ["abc".strip()] es rechazado por el compilador ([unresolved reference 'strip' on receiver of type 'String']); en su lugar, use ["abc".trim()]. A continuación se presentan algunos ejemplos:
propiedad o función | función |
[length: Int] | propiedad: número de caracteres de la cadena |
[operator fun get(index: Int): Char] | Carácter n.º [index]; el primer carácter es el n.º 0. Se escribe [s[index]] |
[startsWith(prefix: String, ignoreCase = false)] | devuelve [true] si la cadena comienza con [prefix] |
[endsWith(suffix: String, ignoreCase = false)] | devuelve [true] si la cadena termina con [suffix] |
[contains(other: CharSequence, ignoreCase = false)] | devuelve [true] si la cadena contiene [other]; también puede escribirse como [other in s] |
[equals(other: String?, ignoreCase = false)] | devuelve [true] si la cadena tiene el mismo contenido que [other]; el operador [==] llama a [equals] |
[indexOf(string: String, startIndex = 0, ignoreCase = false)] | primera aparición de [string] en la cadena, a partir de la posición [startIndex], o -1. Otra sobrecarga busca un carácter |
[lastIndexOf(char: Char, ...)] | Igual que [indexOf] pero devuelve la última posición en lugar de la primera |
[joinToString(separator = ", ", prefix = "", postfix = "")] | función de extensión de colecciones y arreglos: concatena los elementos, separándolos con [separator] |
[replace(oldChar: Char, newChar: Char, ignoreCase = false)] | Devuelve una copia de la cadena en la que el carácter [oldChar] ha sido reemplazado por [newChar]; una versión sobrecargada reemplaza una cadena por otra |
[split(vararg delimiters: String, ...): List<String>] | la cadena se trata como una secuencia de campos separados por uno de los separadores [delimiters], tomados literalmente; el resultado es la lista de estos campos. Una función sobrecargada toma una expresión regular [Regex] |
[substring(startIndex: Int, endIndex: Int)] | una subcadena formada por los caracteres desde la posición [startIndex] (inclusive) hasta la posición [endIndex] (exclusive); [substring(range: IntRange)] acepta un rango |
[substringBefore(delimiter)], [substringAfter(delimiter)] | de la cadena anterior, tras la primera aparición de [delimiter] ([substringBeforeLast], [substringAfterLast]: la última) |
[lowercase()], [uppercase()] | convierte la cadena a minúsculas, a mayúsculas |
[trim()] | elimina los espacios iniciales y finales de la cadena ([trimStart], [trimEnd]: solo de un lado) |
[repeat(n: Int)] | repite la cadena [n] veces |
[reversed()] | invierte la cadena |
[isEmpty()], [isBlank()] | devuelve [true] si la cadena está vacía o si contiene solo espacios |
[lines(): List<String>] | devuelve la lista de líneas de la cadena |
[format(vararg args: Any?)] | devuelve la cadena, usada como formato, en la que las posiciones [%s], [%d]… han sido reemplazadas por los argumentos |
Observe los numerosos parámetros [ignoreCase], que tienen el valor predeterminado [false]: Kotlin no requiere, como Java, métodos separados [equals] y [equalsIgnoreCase]; escribimos [s.equals(other, ignoreCase = true)] usando argumentos con nombre (Capítulo 3).
Es importante notar que una cadena de tipo [String] es inmutable; no puede modificarse después de crearse. Cuando una función devuelve una cadena, esa cadena es distinta de la cadena a la que se aplicó la función. Así, [s1.trim()] devuelve la cadena [s2], y [s1] y [s2] son dos cadenas diferentes: [s1] no ha cambiado.
Una cadena de Kotlin no es un arreglo, pero gracias al operador [get] (Capítulo 4), podemos acceder a su n-ésimo carácter con la misma notación que para un elemento de un arreglo, mientras que Java requiere una notación diferente. De igual modo, el número de caracteres es la propiedad [c.length], y el tamaño de un arreglo es la propiedad [array.size]: Kotlin no tiene la inconsistencia que existe en Java entre el método [length()] para las cadenas y el campo [length] para los arreglos.
El programa [Strings01.kt] es el siguiente:
Resultados:
Comentarios:
- líneas 7–8: length es una propiedad, y el operador [[10]] devuelve el carácter n.º 10, que es el undécimo carácter de la cadena;
- líneas 10, 12: una búsqueda sin éxito devuelve -1;
- línea 13: los dos parámetros de [substring] son las posiciones del primer carácter que se conserva y del primer carácter que se descarta: devuelve los 7 caracteres de las posiciones 4 a 10. Esta es la convención general tanto en Kotlin como en Java para especificar un rango de índices (inicio incluido, fin excluido): se utiliza en muchas funciones;
- línea 14: una sobrecarga de
*[substring]toma un intervalo*[IntRange]*(Capítulo 3), donde ambos extremos están incluidos: [4..10] se refiere a los mismos caracteres que los parámetros [(4, 11)]. También podríamos haber escrito [4 until 11] o [4..<11]*; - Línea 15: [uppercase] y [lowercase] (Kotlin 1.5) no dependen del idioma de la máquina (usan reglas Unicode, que son independientes del idioma); las antiguas funciones de Java [toUpperCase] y [toLowerCase], que sí dependían de él (en turco, la “i” minúscula se convierte en “İ”), están obsoletas en Kotlin;
- Líneas 18–22: el tipo [String] no tiene una función de inserción: se concatenan el comienzo de la cadena, el texto insertado y el final de la cadena, o se usa [replaceRange], que reemplaza los caracteres de un rango por texto: reemplazar el rango vacío que comienza en la posición 9 equivale a insertar. Veremos que la clase [StringBuilder] tiene una función [insert];
- línea 24: [split] divide la cadena en campos y devuelve una lista ([List<String>], que se describe más adelante), y no un arreglo como en Java. Observe que esta es una diferencia importante con Java: con un parámetro [String], el separador de [split] se trata literalmente; para que sea una expresión regular—que trataremos al final del capítulo— debe pasarse un objeto [Regex]. [\s+] designa una secuencia de uno o más caracteres de espacio en blanco (espacio, tabulación, salto de línea, etc.). Se escribe en una cadena sin procesar (raw string) delimitada por tres comillas dobles, donde el carácter [\] es un carácter normal y no necesita duplicarse (volveremos sobre esto más adelante);
- línea 25: la propiedad [indices] de una lista (o arreglo) es el rango de sus índices, en este caso [0..5];
- línea 28: [joinToString] realiza la operación inversa de [split]. Es una función de extensión para listas y arreglos, mientras que Java ofrece el método estático [String.join];
- línea 29: [trim] elimina los espacios iniciales y finales. El [trim] de Kotlin reconoce todos los espacios Unicode (usa la función [Char.isWhitespace]): por lo tanto, corresponde al método Java [strip], y no al método Java [trim], que reconoce únicamente los espacios del código ASCII;
- Líneas 31–35: algunas funciones de la biblioteca de Kotlin que no tienen un equivalente directo en la clase Java [String]: [substringBefore] y [substringAfterLast] devuelven lo que está antes del primer espacio y lo que está después del último, sin calcular posiciones; [reversed] invierte la cadena; [count] cuenta los caracteres que cumplen una condición, expresada mediante una lambda: [{ it == 'e' }] es una función anónima cuyo parámetro implícito [it] es el carácter que se examina (las lambdas se tratan en el Capítulo 7). Como su lambda es el último argumento de [count], se escribe después del nombre de la función, sin paréntesis; por último, [lines] divide un texto en líneas, sea cual sea el fin de línea utilizado ([\n], [\r\n] o [\r]), y devuelve la lista de líneas;
- línea 37: todas las funciones anteriores devolvieron nuevas cadenas: [aString] no se modificó (última línea de los resultados);
- líneas 41–42: una función de orden superior, llamada por la función [main] como en el Capítulo 3.
5.2.2. Las funciones split y joinToString
El programa [Strings02.kt] profundiza en la división de una cadena en campos. Los lectores familiarizados con Java encontrarán dos diferencias significativas con el método [split] de Java:
Resultados:
Comentarios:
- Línea 7: los campos están separados por el carácter [:]. Dos [:] consecutivos delimitan un campo vacío (línea 3 de los resultados), y el [:] final de la cadena delimita un quinto campo —también vacío— que se conserva (línea 5 de los resultados). Esta es la primera diferencia con Java, donde el método
*[split]elimina los campos vacíos del final: en Kotlin,*[joinToString]siempre reconstruye la cadena original (línea 6 de los resultados). El comportamiento de Kotlin es más coherente: una cadena que contiene n separadores siempre produce n + 1 campos. Para reproducir el comportamiento de Java, se escribiría [line.split(":").dropLastWhile { it.isEmpty() }]; - línea 8: la función [withIndex] permite recorrer una lista usando tanto el índice como el elemento, que se obtiene mediante la desestructuración (Capítulo 3);
- línea 15: el parámetro opcional [limit] de [split] establece el número máximo de campos: la división se detiene en el primer separador, y el último campo contiene todo el resto de la cadena. Un delimitador se usa, por ejemplo, para separar el nombre de un parámetro de su valor en una línea [name=value] cuando el propio valor puede contener el delimitador. Observe que cuando se muestra una lista mediante una plantilla ([$fields]), sus elementos aparecen entre corchetes, separados por comas: este es el [toString] de las listas;
- línea 19: la segunda diferencia con Java: un separador de tipo [String] se trata literalmente; para describir un separador mediante una expresión regular, debe pasarse un objeto [Regex]. [":+"] denota uno o más caracteres [:] consecutivos. Los dos caracteres [:] consecutivos forman un único separador, y el campo vacío intermedio desaparece; el último campo vacío, en cambio, permanece;
- línea 24: [split] acepta varios separadores ([vararg], Capítulo 3), caracteres o cadenas: en este caso, la coma y el punto y coma. La función [map] aplica entonces la lambda [{ it.trim() }] a cada campo y devuelve la lista de resultados: en una sola instrucción, obtenemos los tres campos “limpios”. Las funciones [map], [filter], y sus numerosas contrapartes se presentan más adelante en este capítulo;
- línea 27: el mismo resultado usando una expresión regular: el patrón [\s*[,;]\s*] coincide con una coma o un punto y coma, precedidos y seguidos de cualquier cantidad de espacios; los espacios que rodean a los separadores se eliminan junto con ellos. Los del principio y del final de la cadena se eliminan antes con [trim]. El patrón se escribe en una cadena sin procesar, sin duplicar el [\]; la línea siguiente también usa una cadena sin procesar para mostrar el patrón tal cual;
- líneas 32–36: para eliminar tanto los espacios alrededor de los campos como los campos vacíos, los campos pueden procesarse uno por uno: el campo formado por dos espacios entre dos comas queda vacío después de [trim] y no se conserva. La lista modificable creada con [mutableListOf] para almacenar los campos conservados se presentará un poco más adelante;
- línea 41: el mismo resultado en una sola instrucción: [map] elimina los espacios de cada campo, y luego [filter] conserva solo los campos no vacíos. Esta es la forma idiomática de escribirlo en Kotlin;
- línea 46: el separador [" | "] contiene el carácter [|], que tiene un significado especial en una expresión regular (“o”). Como el separador se trata literalmente, no se necesitan precauciones especiales, mientras que en Java habría que escribir [split(Pattern.quote(" | "))]. Si necesita construir una expresión regular a partir de un texto arbitrario, la función [Regex.escape] cumple la misma función que [Pattern.quote];
- Líneas 49–51: a diferencia de [String.join] de Java, que acepta solo cadenas, [joinToString] acepta elementos de cualquier tipo; aquí, un arreglo de enteros [IntArray]: cada elemento se convierte mediante su función [toString]. Sus parámetros opcionales [prefix] y [postfix] agregan texto al principio y al final, y su último parámetro, [transform], es una lambda que convierte cada elemento en texto; escrita después de los paréntesis, produce los textos “no.1”, “no.2”, etc. Lo que Java hace con un [StringJoiner] o con la API Stream puede lograrse con una sola llamada.
5.2.3. Búsqueda y comparación de cadenas
La comparación de cadenas es más sutil de lo que parece: ¿deben distinguirse las mayúsculas de las minúsculas? ¿Cómo se debe comparar “éclair” con “essay”? ¿Y qué compara el operador [==]? En este último punto, Kotlin ha corregido una trampa muy conocida de Java. El programa [Strings03.kt] muestra las funciones de búsqueda y comparación:
Resultados:
Comentarios:
- líneas 3–4: las clases del JDK utilizadas por el programa deben importarse;
- líneas 11–14: de forma predeterminada, [contains], [startsWith] y [endsWith] realizan una comparación exacta, carácter por carácter: “LANGUAGE” no se encuentra;
- línea 16: estas funciones tienen un parámetro opcional, [ignoreCase], que indica al programa que ignore la distinción entre mayúsculas y minúsculas. Java no tiene un equivalente: ambas cadenas deben convertirse a minúsculas;
- línea 18: el operador [in] llama a la función [contains] (Capítulo 4): ["Kotlin" in title] se lee naturalmente como “Kotlin está en el título”;
- Líneas 19–21: la función [regionMatches] compara una porción de una cadena con una porción de otra cadena. Sus parámetros son la posición inicial en la cadena, la otra cadena, la posición inicial en la otra cadena y el número de caracteres que se comparan; el último parámetro, que es opcional, indica si se ignora la distinción entre mayúsculas y minúsculas (en Java, este parámetro va primero en una de las sobrecargas);
- líneas 23–29: la parte más importante de este programa. Una variable de tipo [String] contiene una referencia a un objeto cadena (Capítulo 4). La variable [yes] hace referencia a una cadena “yes” construida en tiempo de ejecución: es un objeto distinto de la cadena literal “yes” del programa. En Kotlin, el operador [] compara el contenido: llama a la función [equals], y [yes == "yes"] se evalúa como [true] (línea 8 de los resultados). Para comparar referencias —es decir, para determinar si dos variables hacen referencia al mismo objeto— Kotlin tiene otro operador, [=], y [yes === "yes"] es igual a [false] (línea 9 de los resultados). En Java, es lo contrario: [] compara allí referencias, y el error común de escribir [answer == "yes"] en lugar de [answer.equals("yes")] no existe en Kotlin. La comparación sin distinguir mayúsculas de minúsculas se escribe [equals(..., ignoreCase = true)], que es la forma correcta de validar una respuesta “yes” ingresada con el teclado en mayúsculas o minúsculas. Casi nunca se necesita [=] con cadenas;
- Líneas 32–37: la función [compareTo] devuelve un entero negativo, cero o positivo según si la cadena precede, es igual o sigue a la cadena del parámetro. Compara los códigos de los caracteres: “éclair” va después de “essay” porque el código del carácter “é” (233) es mayor que el del carácter “e” (101); aquí, devuelve la diferencia entre los dos códigos, 132. Dado que [String] implementa [Comparable<String>], los operadores [<], [>], [<=] y [>=] se aplican a las cadenas y llaman a [compareTo]: [a < b] es igual a [false]. Para ordenar palabras según las reglas de un idioma, se utiliza un objeto [java.text.Collator] proveniente del JDK: para el francés, el carácter “é” se ordena junto con la “e”, y “éclair” va antes de “essay” (línea 14 de los resultados). Usaremos el orden especificado por un [Collator] para ordenar palabras destinadas a un usuario, y [compareTo] para comparar identificadores técnicos (nombres de archivo, claves, etc.). La función [compareTo] también tiene un parámetro [ignoreCase];
- líneas 40–48: [isEmpty] verifica si una cadena está vacía, y [isBlank] verifica si una cadena está vacía o contiene solo espacios. Una cadena también puede estar ausente: en ese caso, su variable es de tipo [String?] y tiene el valor [null] (Capítulo 3). Aquí, [System.getenv]—un método de Java que devuelve el valor de una variable de entorno— devuelve [null] porque la variable solicitada no existe. El compilador prohíbe llamar a [absent.isBlank()], lo que podría lanzar una excepción [NullPointerException]. La biblioteca proporciona funciones de extensión para el tipo [String?], que aceptan [null]: [isNullOrBlank] (y [isNullOrEmpty]) verifican lo que en Java se escribe [absent == null || absent.isBlank()], y [orEmpty] devuelve la cadena, o una cadena vacía si es [null]. La llamada segura a [absent?.length] devuelve [null];
- línea 51: [padStart] rellena una cadena por la izquierda hasta una longitud de 8 caracteres con espacios o con el carácter especificado ([padStart(5, '0')]), y [padEnd] la rellena por la derecha; [repeat] repite una cadena. También podrían usarse los formatos ["%8s"] y ["%-8s"], que se muestran más adelante.
5.2.4. Plantillas, formatos y cadenas sin procesar
Desde el Capítulo 3, hemos construido las cadenas que se muestran usando plantillas de cadena: en una cadena, [$name] se reemplaza por el valor de la variable [name], y [${expression}] por el valor de cualquier expresión. Esto es la interpolación de cadenas, una característica de la que Java carece (una propuesta, “String Templates”, se presentó como vista previa en Java 21 y 22, pero se eliminó después) y que C# escribe como [$"{name}"]. El compilador transforma una plantilla en concatenaciones: no hay sobrecarga adicional en tiempo de ejecución.
Para alinear valores en columnas, fijar el número de decimales de un número o mostrar una fecha, también se usan formatos, ya sea con la función [String.format] o con la función de extensión [format] aplicada al propio formato, que hacen lo mismo (y llaman al método Java [String.format]). El formato es una cadena de texto en la que los [%[-][width][.precision]conversion] especificadores indican dónde y cómo insertar los parámetros siguientes. El programa [Strings04.kt] ofrece ejemplos de ellos, junto con las cadenas sin procesar de Kotlin:
Resultados:
Comentarios:
- Línea 17: una plantilla: [$name] y [$age] se reemplazan por los valores de las variables, y [${2026 - age}] por el valor de la expresión. Las llaves son obligatorias siempre que lo que sigue a [$] no sea un simple nombre de variable: [$person.name] insertaría el valor de [person] seguido del texto “.name”, mientras que [${person.name}] inserta la propiedad [name];
- línea 19: un ancho alinea el valor a la derecha dentro de un campo de 10 caracteres; precedido del signo [-], lo alinea a la izquierda;
- líneas 19–21: las conversiones más comunes:
especificador | significado | ejemplo (configuración regional en inglés) |
[%s] | cadena; cualquier objeto se convierte mediante su función [toString] | dupont |
[%d], [%5d] | entero, posiblemente de 5 caracteres de ancho | 45 |
[%05d] | entero con al menos 5 dígitos, rellenado con ceros | 00045 |
[%X] | entero hexadecimal ([%x]: en minúsculas) | 2D |
[%.2f], [%12.2f] | número real con 2 decimales, posiblemente de 12 caracteres de ancho | 2345.68 |
[%,.2f], [%,d] | igual que el anterior, con separador de miles | 2,345.68 |
[%e] | número real en notación científica | 2.345678e+03 |
[%n] | salto de línea del sistema | |
[%%] | el carácter % | % |
- Los números se formatean según el idioma actual, en este caso inglés: punto decimal, coma como separador de miles. En francés ([Locale.FRANCE], líneas 29–32), el separador de miles es un espacio fino de no separación (carácter U+202F), que se ve como un espacio normal pero impide un salto de línea en medio de un número; de igual modo, un espacio de no separación (U+00A0) precede al símbolo € y al símbolo %. Esto debe tenerse en cuenta al comparar estos textos con cadenas escritas con espacios normales. Los tipos de los parámetros se verifican solo en tiempo de ejecución: pasar un [Int] a la conversión [%f] lanza una excepción [IllegalFormatConversionException];
- línea 23: ["...".format(...)] es equivalente a [String.format("...", ...)] (y al método Java [formatted]). Como [if] es una expresión en Kotlin (Capítulo 3), puede proporcionar un parámetro, mientras que Java usa el operador condicional [? :];
- Línea 25: una plantilla no formatea los números; llama a la función [toString] sobre el valor, que muestra un [Double] con un punto decimal y todos sus decimales, sea cual sea el idioma de la máquina. Para una salida destinada a un usuario, se combinan la plantilla y el formato: [${"%.2f".format(salary)}]. Una sobrecarga de [format] toma como primer parámetro el idioma que se utilizará: [Locale.US] devuelve un punto decimal;
- Líneas 29–32: los montos monetarios y los porcentajes se formatean con objetos [java.text.NumberFormat] del JDK, que se obtienen para un idioma y país determinados ([Locale.FRANCE]). El formato de porcentaje multiplica el valor por 100. Observe la línea 31: el método Java [setMinimumFractionDigits(2)] se usa en Kotlin como una asignación de propiedad. Kotlin trata los pares de métodos Java [getXxx()]/[setXxx(...)] como propiedades [xxx];
- líneas 34–37: las fechas de la API [java.time] del JDK se formatean mediante un objeto [DateTimeFormatter] construido a partir de un patrón: [dd] día, [MM] mes, [yyyy] año, [HH] hora, [mm] minutos, [ss] segundos, [EEEE] día de la semana escrito completo, [MMMM] mes escrito completo. Tenga cuidado con las mayúsculas y minúsculas: [MM] es el mes, [mm] son los minutos. Los nombres de los días y los meses son los del lenguaje cotidiano. Las plantillas pueden contener expresiones que a su vez contienen cadenas: ["[${date.format(DateTimeFormatter.ofPattern("dd/MM/yyyy"))}] "];
- líneas 40–43: los anchos permiten mostrar los datos en columnas;
- línea 47: en una cadena normal, el carácter [\] introduce una secuencia de escape ([\n], [\t], [\"], [\$]…); para obtener el propio carácter [\] , debe duplicarse;
- Línea 50: una cadena sin procesar (raw string) está delimitada por tres comillas dobles. Las secuencias de escape no existen en las cadenas sin procesar: el carácter [\] se trata como un carácter normal. Es una forma cómoda de escribir rutas de Windows y expresiones regulares, algo que Java no ofrece (sus bloques de texto conservan las secuencias de escape). Sin embargo, aquí no se puede escribir un salto de línea como [\n]; se necesita un salto de línea real;
- Líneas 54–61: una cadena sin procesar puede abarcar varias líneas y contener comillas dobles sin escapar. Conserva todo lo que está escrito entre las comillas, incluida la sangría del código y las líneas vacías del principio y del final. La función [trimIndent] elimina la primera y la última línea si están en blanco, y luego elimina la sangría común a todas las líneas (la de la línea con menos sangría): el texto JSON se muestra sin el margen del código y sin el salto de línea final, resultante de [println]. Esto equivale a los bloques de texto de Java 15, pero implementado mediante una función de biblioteca. A diferencia de los bloques de texto de Java, las plantillas funcionan en las cadenas sin procesar: ["$name"] y [${prices[0]}] se reemplazan por sus valores, lo que elimina la necesidad de [format]; el [\] en ["C:\data"] no necesita duplicarse;
- Línea 59: como las secuencias de escape no existen en una cadena sin procesar, no se puede escribir
***[\\$]para obtener un*[$]seguido de un nombre sin que se interprete como una plantilla: en su lugar, escribimos [${'$'}], una plantilla cuya expresión es el carácter [$]. A partir de Kotlin 2.2, también podemos prefijar la cadena con varios [$]* ([$$"""..."""]): entonces solo las secuencias de dos [$] introducen una plantilla, lo que resulta cómodo para escribir texto que contiene muchos [$]*; - Líneas 64–68: la función [trimMargin] ofrece otra forma de especificar el margen: cada línea comienza —después de los posibles espacios— con un carácter de margen ([|] de forma predeterminada), y todo lo que precede a ese carácter, incluido el propio carácter, se elimina. Elija la función más legible: [trimIndent] para texto copiado tal cual, y [trimMargin] cuando la primera columna del texto necesita ser claramente visible.
También existe la clase [java.text.MessageFormat], cuyos formatos hacen referencia a los parámetros por sus números: [MessageFormat.format("{0} is {1} years old", name, age)]. Se utiliza para mensajes traducidos a varios idiomas, donde el orden de los parámetros puede variar de un idioma a otro; se usa en Kotlin exactamente igual que en Java.
5.2.5. La clase StringBuilder
Hemos observado que las funciones del tipo [String] que operan sobre una cadena de tipo [s1] devuelven otra cadena de tipo [s2]. La clase [StringBuilder] permite modificar una cadena sin crear una nueva en cada operación. Esto mejora el rendimiento al construir una cadena mediante muchas adiciones sucesivas, al evitar la proliferación de cadenas de vida muy corta. En Kotlin, para la JVM, [kotlin.text.StringBuilder] es un alias de tipo ([typealias]) de la clase [java.lang.StringBuilder] del JDK: es la misma clase, que la biblioteca estándar extiende con algunas funciones de extensión ([appendLine], el operador [[]] …). Puede usarse sin [import].
La clase admite varios constructores:
constructor | función |
[StringBuilder()] | crea un objeto vacío con una capacidad inicial de 16 caracteres |
[StringBuilder(str: String)] | construye e inicializa con [str]; la capacidad inicial es la longitud de [str] más 16 |
[StringBuilder(capacity: Int)] | construye un objeto vacío con una capacidad inicial de [capacity] caracteres |
Un objeto [StringBuilder] almacena sus caracteres en un arreglo cuyo tamaño —su capacidad— se ajusta automáticamente a medida que crece el texto. El programa [Strings05.kt] ilustra este concepto de capacidad:
Resultados:
Comentarios:
- línea 5: creación de un objeto [StringBuilder] que contiene “test”: su capacidad inicial es 4 + 16 = 20 caracteres. Como en cualquier clase de Kotlin, no existe el operador [new];
- línea 6: [length] es el número actual de caracteres. Kotlin lo representa como una propiedad (sin paréntesis), igual que con [String]: el método Java [length()] de la interfaz [CharSequence] se trata en Kotlin como la propiedad [length]. [capacity()], que no forma parte de esta interfaz y no sigue la convención [getXxx()], sigue siendo un método: representa el número de caracteres que el objeto puede contener antes de necesitar expandir su arreglo;
- línea 7: la función [repeat] de la biblioteca estándar ejecuta 10 veces la lambda que le sigue (Capítulo 3);
- línea 8: [append] agrega una cadena al final del texto;
- línea 12: creación de un objeto [StringBuilder] vacío con una capacidad inicial de 10, al que se agrega de inmediato “test”. El método [append] devuelve el propio objeto: puede llamarse directamente sobre el resultado del constructor.
Los resultados, que son idénticos a los del programa Java porque es la misma clase, muestran que cuando la capacidad es insuficiente, se hace un poco más que duplicarla: la nueva capacidad es la anterior multiplicada por 2, más 2 (20, 42, 86 para el primer objeto; 10, 22, 46 para el segundo). Cada expansión asigna un nuevo arreglo y copia en él los caracteres. Si se conoce de antemano el tamaño aproximado del texto, fijarlo en el momento de la construcción evita estas expansiones sucesivas.
Estas son algunas de las funciones de la clase:
función | rol |
[append(str: String?): StringBuilder] | agrega [str] al final del texto. Está sobrecargada para aceptar los tipos [Int], [Double], [Char], [Boolean], [Any?]… |
[appendLine(value)] | Extensión de Kotlin: agrega [value] seguido de un salto de línea [\n]; sin parámetros, agrega solo el salto de línea |
[insert(offset: Int, str: String?)] | Inserta [str] en la posición [offset]; sobrecargada como [append] |
[delete(start: Int, end: Int)] | elimina los caracteres desde la posición [start] (inclusive) hasta [end] (exclusive); [deleteCharAt] elimina un solo carácter |
[replace(start: Int, end: Int, str: String)] | reemplaza los caracteres de las posiciones [start] (inclusive) hasta [end] (exclusive) por [str] |
[reverse()] | invierte el orden de los caracteres |
[sb[index]], [sb[index] = ch] | lee y reemplaza el carácter número [index] (operadores [get] y [set]; [set] es una extensión de Kotlin del método de Java [setCharAt]) |
[indexOf(str: String)] | posición de [str] en el texto, o -1 |
[toString()] | devuelve el texto como una cadena [String] |
El programa [Strings06.kt] usa estas funciones, así como la función [buildString], que es la forma idiomática de construir una cadena en Kotlin:
Resultados:
Comentarios:
- Línea 6: los métodos de modificación devuelven el propio objeto [StringBuilder], lo que permite encadenarlos. Sigamos los pasos: “test” se convierte en “testabCD " ([append]), luego en "texyZTstabCD" ([insert] en la posición 2), luego en "xyZTstabCD " ([delete] para los caracteres 0 y 1) y finalmente en "XYZTstabCD" ([replace] para los caracteres 0 y 1, con "XY"). Observe que, a diferencia de la función [replace] de [String], la función de [StringBuilder] no busca texto: reemplaza un rango de posiciones. [println] muestra el objeto llamando a su función [toString];
- líneas 8–9: el operador [[]] lee y modifica un carácter, como en un arreglo; [str3[0] = 'x'] llama a [str3.setCharAt(0, 'x')]. En la plantilla, [$str3] llama a [toString];
- línea 11: [reverse] invierte el texto. Para una cadena [String], la función [reversed], vista en [Strings01.kt], es más sencilla;
- Líneas 14–16: construcción de un texto de varias líneas mediante adiciones sucesivas; este es el uso típico de [StringBuilder]. Las adiciones se encadenan en una sola línea de código;
- líneas 19–20: la función [joinTo] es la contraparte de [joinToString]: en lugar de crear una nueva cadena, agrega los elementos separados por el delimitador a un [StringBuilder] existente (más precisamente, a cualquier objeto [Appendable]); [appendLine] agrega luego un salto de línea;
- línea 23: se agrega una cadena formateada. La conversión [%f] requiere un número real: pasar el entero [total] lanzaría una excepción [IllegalFormatConversionException] en tiempo de ejecución, de ahí la conversión [total.toDouble()];
- línea 25: el texto final se obtiene como una cadena [String];
- líneas 30–35: la función [buildString] crea un [StringBuilder], ejecuta la lambda que la sigue y luego devuelve el texto construido como un [String]. En la lambda, el [StringBuilder] es el receptor implícito ([this]): escribimos [appendLine(...)] en lugar de [sb.appendLine(...)]. Este tipo de lambda, llamado lambda con receptor, se trata en el Capítulo 7; permite escribir “bloques de construcción” muy legibles. La variable [table] es un [String] inmutable, declarado con [val], y el [StringBuilder] intermedio ni siquiera es visible. Observe también cómo [padStart] alinea a la derecha los números dentro de las columnas;
- línea 40: para una secuencia de elementos separados por un delimitador, con un prefijo y un sufijo, [joinToString] ofrece la funcionalidad de la clase de Java [java.util.StringJoiner], que sigue siendo utilizable pero tiene poco interés en Kotlin.
Para unas pocas concatenaciones, el operador [+] y las plantillas son suficientes: el compilador las optimiza. [StringBuilder] (o [buildString]) es la opción preferida cuando el número de adiciones es grande o desconocido, típicamente dentro de un bucle: la concatenación [s += ...] en un bucle de n iteraciones crea n cadenas y copia toda la cadena construida previamente en cada iteración. En código Java antiguo, es posible encontrar la clase [StringBuffer], que tiene los mismos métodos que [StringBuilder] pero los hace utilizables simultáneamente por varios hilos, a costa de cierta sobrecarga de rendimiento: hoy en día, se prefiere [StringBuilder] en lugar de ella.
5.2.6. Análisis de una cadena sin copiarla
Cada llamada a [substring] o a [split] crea nuevas cadenas en memoria. En código crítico para el rendimiento (como el análisis de archivos grandes o de solicitudes de red), puede ser conveniente evitar la creación de nuevas cadenas. Ni Kotlin ni Java tienen un tipo “subcadena” integrado en el lenguaje, pero varias funciones operan sobre una porción de una cadena sin copiarla. El programa [Strings07.kt] compara varias formas de analizar una línea con el formato “apellido:nombre:edad”:
Resultados:
Comentarios:
- línea 10: el enfoque más legible y más común en Kotlin: [split] devuelve una lista de tres cadenas, que la desestructuración (Capítulo 3) asigna a tres variables; [toInt] convierte luego la edad en un entero. Sin embargo, crea una lista y tres cadenas;
- Líneas 16–17: con [substring], cada llamada crea una nueva cadena, incluso si, como ocurre con la edad, solo se usa por un instante;
- línea 21: la función de Kotlin [toInt] se aplica solo a una cadena; pero el método estático [Integer.parseInt] del JDK tiene una sobrecarga (Java 9) que analiza los caracteres entre dos posiciones de la cadena, en la base especificada (aquí 10), sin crear una subcadena. Un programa de Kotlin puede llamarlo directamente: ese es el sentido de la interoperabilidad con Java;
- Línea 23: [regionMatches], que ya vimos, compara una porción de la cadena con otra cadena sin copiarla;
- línea 27: [CharBuffer.wrap] (paquete [java.nio] del JDK) devuelve una vista de los caracteres 0 a [p1] - 1 de la cadena: un objeto que no contiene una copia de los caracteres, sino que proporciona un medio de acceder a ellos. Implementa la interfaz [CharSequence], al igual que [String] y [StringBuilder]. Observe que la función [subSequence] de [String], miembro de esta interfaz, no es una vista: para una cadena, crea una copia de los caracteres, igual que [substring] (para un
*[CharBuffer]devuelve una vista). Kotlin trata el método de Java***[charAt]de esta interfaz como el operador***[[]], y su método[length()]como la propiedad*[length]; - líneas 30–31: muchas de las funciones de extensión de
*[kotlin.text]no están definidas sobre*[String]*, sino sobre[CharSequence]: [startsWith], [count], [contains], [indexOf], [split], [lines]…, por lo que también se aplican a una vista, o a un [StringBuilder], sin convertirlo primero en [String]. Las expresiones regulares, que veremos al final del capítulo, también aceptan un [CharSequence]*; - línea 34: el segundo parámetro de [indexOf] es la posición inicial de la búsqueda;
- línea 37: solo se crea una cadena si realmente es necesaria.
Estas técnicas son herramientas de optimización: para un programa corriente, [split] y [substring] son perfectamente adecuados. Además, la máquina virtual almacena las cadenas que contienen únicamente caracteres del juego de caracteres Latin-1 (como es el caso del texto en francés) usando un byte por carácter en lugar de dos (“cadenas compactas”, Java 9), lo que reduce a la mitad la memoria que ocupan; las cadenas de Kotlin, que son cadenas de Java, se benefician de esto. Solo intentaremos evitar las copias en el código que se haya medido como crítico para el rendimiento.
5.3. Arreglos
5.3.1. Funciones de extensión de arreglos
Vimos en el Capítulo 3 que Kotlin tiene dos tipos de arreglos: los arreglos de objetos [Array<T>] (creados con [arrayOf]) y los arreglos de tipos primitivos [IntArray], [DoubleArray], [CharArray]… (creados con [intArrayOf], [doubleArrayOf]…), compilados como arreglos de tipos primitivos de Java ([int[]], [double[]]…). En Java, los arreglos no tienen métodos útiles: aparte del campo [length], todas las operaciones son métodos estáticos de la clase utilitaria [java.util.Arrays]. En Kotlin, los arreglos tienen una propiedad [size], operadores [[]] y, sobre todo, decenas de funciones de extensión de la biblioteca estándar (paquete [kotlin.collections]), que se llaman como métodos: [array.sort()] en lugar de [Arrays.sort(array)]. Permiten ordenar un arreglo, buscar un elemento en él, copiarlo, llenarlo… Existen para todos los tipos de arreglos ([IntArray], [DoubleArray]…, [Array<T>]) y, la mayoría de las veces, llaman, a través de la JVM, a los métodos de la clase [Arrays].
función | rol |
[binarySearch(element, fromIndex = 0, toIndex = size)] | Devuelve la posición de [element] en el arreglo, que debe estar ordenado; un número negativo si [element] no está |
[copyOf(newSize: Int)] | devuelve un nuevo arreglo de [newSize] elementos que contiene los primeros elementos del arreglo, rellenado con ceros según sea necesario ([false] para booleanos); para un [Array<T>], el resultado es un [Array<T?>] rellenado con [null]. Sin parámetros, devuelve una copia del mismo tamaño |
[copyOfRange(fromIndex: Int, toIndex: Int)] | devuelve un nuevo arreglo formado por los elementos desde [fromIndex] (inclusive) hasta [toIndex] (exclusive); [sliceArray(range)] hace lo mismo con un intervalo |
[copyInto(destination, destinationOffset = 0, startIndex = 0, endIndex = size)] | copia los elementos del arreglo en otro arreglo existente (equivalente a [System.arraycopy]) |
[contentEquals(other)] | devuelve [true] si ambos arreglos tienen los mismos elementos en el mismo orden |
[fill(element, fromIndex = 0, toIndex = size)] | Asigna [element] a todos los elementos del arreglo o a un rango de índices |
[sort()], [sort(fromIndex, toIndex)] | ordena el arreglo, o un rango de índices, según el orden natural de sus elementos; [sortWith(comparator)] ordena un arreglo de objetos según un [Comparator] (Capítulo 4); [sortDescending()] ordena en orden descendente |
[sorted()], [sortedWith(comparator)] | devuelve una lista ordenada sin modificar el arreglo |
[reverse()], [reversed()] | invierte el arreglo; devuelve una lista invertida |
[contentToString()] | convierte los elementos del arreglo en una cadena [[e1, e2, ...]]; [contentDeepToString] hace lo mismo para un arreglo de arreglos |
[indexOf(element)], [lastIndexOf(element)], [contains(element)] | búsqueda lineal: primera o última posición de [element], o -1; presencia de [element] ([element in array]) |
[asList()] | devuelve una lista que es una vista del arreglo |
[toList()], [toMutableList()] | devuelve una nueva lista, de solo lectura o editable, que contiene los elementos del arreglo |
[plus(element)] | devuelve un nuevo arreglo, un elemento más grande, formado por los elementos del arreglo seguidos de [element]; se escribe como [array + element] |
Además, existen funciones comunes a arreglos y colecciones ([sum], [max], [count], [filter], [map], [joinToString]…), que veremos más adelante.
El programa [Arrays01.kt] ilustra el uso de algunas de estas funciones:
Comentarios:
- línea 4: una enumeración (Capítulo 3), declarada a nivel de archivo;
- Líneas 23–40: la función [input] captura los elementos de un arreglo escritos por teclado. Como el número de elementos no se conoce de antemano, la función comienza con un arreglo vacío (línea 25) y lo amplía en un elemento por cada nueva entrada (línea 38). El tamaño de un arreglo se fija al crearlo: el operador [+] ([plus]) en realidad crea un nuevo arreglo un elemento más grande, copia en él los elementos del arreglo anterior y agrega el nuevo elemento; [elements += element] equivale aquí a [elements = elements + element], de ahí la declaración de [elements] con [var]. Es el equivalente, en una sola instrucción, de las dos instrucciones de Java [elements = Arrays.copyOf(elements, elements.length + 1)] y [elements[elements.length - 1] = element]. Un algoritmo más eficiente asignaría espacio en grupos de N elementos. Un arreglo no está diseñado para cambiar de tamaño: este caso se resuelve mejor con una lista mutable, como veremos en breve;
- líneas 32–35: la conversión de la cadena ingresada a un número de punto flotante mediante [toDoubleOrNull], que devuelve [null] si la cadena no es un número (Capítulo 3). Después de la verificación [element == null] seguida de [continue], el compilador sabe que [element] no es [null]: su tipo pasa a ser [Double] (conversión inteligente de tipos) y puede agregarse al arreglo. [toDoubleOrNull] no depende del idioma de la máquina: siempre espera un punto decimal y rechaza la entrada “3,6” (línea 4 de los resultados);
- líneas 52–69: la función [search] busca en el arreglo los valores ingresados por teclado. La función [when] (línea 64) selecciona el método de búsqueda según el tipo solicitado; como opera sobre una enumeración y procesa todos sus valores, no requiere la rama [else]. Para un arreglo sin ordenar, se realiza una búsqueda lineal, examinando los elementos uno por uno. La biblioteca estándar no tiene una función [indexOf] para arreglos de números reales [DoubleArray]: se eliminó porque comparar números reales por igualdad plantea problemas con los valores especiales [NaN] y [-0.0]; el compilador rechaza [elements.indexOf(element)] ([unresolved reference 'indexOf']). Por lo tanto, usamos [indexOfFirst], que devuelve la posición del primer elemento que satisface la condición expresada por una lambda, o -1; a diferencia de Java, no es necesario escribir la función de búsqueda. Para un arreglo ordenado, realizamos una búsqueda binaria con [binarySearch], que reduce a la mitad el rango de búsqueda en cada paso: encuentra un elemento entre un millón en unas veinte comparaciones;
- línea 15: el arreglo se ordena, aquí según el orden natural de los números. [elements] se declara con [val] en [main]: la variable siempre hace referencia al mismo arreglo, pero su contenido puede modificarse. [val] hace constante la referencia , no el objeto;
- líneas 44–47: visualización de un arreglo. [println] muestra un [Double] con punto decimal, sin importar el idioma de la máquina, y siempre con al menos un decimal: -7 se muestra como -7.0;
- líneas 74–76: [print] muestra el mensaje sin pasar a la línea siguiente, luego [readlnOrNull] lee una línea escrita por teclado; devuelve [null] si la entrada estándar se agotó, por ejemplo cuando proviene de un archivo. La llamada segura [?.trim()] y el operador Elvis [?: ""] devuelven entonces una cadena vacía.
Resultados:
Cuando el elemento buscado no está, [indexOfFirst] devuelve -1 y [binarySearch] devuelve un número negativo (última búsqueda): se trata de [-(p + 1)], donde p es la posición en la que debería insertarse el elemento para mantener el arreglo ordenado. Aquí, -3 = -(2 + 1): el número 0 debería insertarse en la posición 2, entre -1.5 y 3.6. Nota: [binarySearch] sobre un arreglo sin ordenar devuelve un resultado sin sentido.
5.3.2. Otras funciones de arreglos
El programa [Arrays02.kt] presenta funciones de extensión adicionales para arreglos:
Resultados:
Comentarios:
- Línea 9: [contentToString] muestra un arreglo en una sola línea. Mostrar un arreglo directamente con [println(numbers)] o ["$numbers"] produciría un texto como [[I@1b6d3586]]: el tipo ([[I]], un arreglo de enteros de la JVM) y un identificador del objeto, sin sus elementos. Los arreglos de Kotlin son arreglos de Java y tienen el mismo [toString];
- línea 12: solo se ordenan los elementos con índices del 1 al 3, excluyendo el segundo índice: 10, 30, 20 pasan a ser 10, 20, 30;
- Líneas 16–17: [IntArray(5)] crea un arreglo de 5 enteros con valor cero. [copyInto] copia los 3 primeros elementos de [numbers] al principio de [copy], mientras que los demás elementos conservan su valor inicial de 0. Sus parámetros tienen valores predeterminados y aquí se nombran, lo que hace la llamada mucho más legible que la de [System.arraycopy(numbers, 0, copy, 0, 3)] en Java;
- líneas 20–21: [copyOf] y [copyOfRange] crean un nuevo arreglo. Un arreglo más largo que el original se rellena con ceros;
- líneas 24–26: [fill] llena el arreglo y luego restablece a 0 los elementos de los índices 1 y 2 (excluyendo el índice 3). Observe que el orden de los parámetros es distinto del de Java: primero va el valor, seguido del rango de índices;
- líneas 30–31: en los arreglos, a diferencia de las cadenas y las colecciones, el operador [] compara referencias: los arreglos no tienen una función [equals] que compare contenidos. El compilador lo sabe y señala el probable error con una advertencia si se escribe [copy == other]: **[warning: '' on arrays compares only references. Replace '' with 'contentEquals' to compare the arrays' contents or use '=' to remove the warning.] (como nuestros proyectos tratan las advertencias como errores, la compilación falla). Por lo tanto, escribimos [===] para comparar referencias y [contentEquals] para comparar contenidos. [contentEquals] se llama aquí con notación infija* ([copy contentEquals other]*), sin punto ni paréntesis, lo cual permite el modificador [infix] en su declaración (Capítulo 4);
- líneas 34–36: los arreglos de objetos admiten directamente las funciones de búsqueda [indexOf] y [lastIndexOf], así como el operador [in]. En Java, es necesario usar [Arrays.asList] para acceder a ellas;
- Líneas 38–40: [asList] devuelve una [List] (presentada en la sección siguiente), que es una vista del arreglo: no copia el arreglo, sino que da acceso a él mediante funciones de lista. La función [reverse] invierte el propio arreglo; como la lista es una vista del arreglo, sus elementos quedan invertidos (línea 10 de los resultados). A diferencia de Java, [reverse] existe para todos los tipos de arreglos, incluido [IntArray];
- Líneas 42–44: [toList], en cambio, devuelve una copia de los elementos del arreglo en forma de lista. Tras modificar el elemento número 0 del arreglo, la vista refleja el cambio, pero la copia no (línea 11 de los resultados). Este punto es importante: una vista es eficiente pero refleja todos los cambios del objeto original; una copia es independiente de él;
- línea 49: un arreglo de cadenas se ordena según el orden de la función [compareTo] vista antes, es decir, por códigos de caracteres: las letras mayúsculas (códigos 65 a 90) van antes que las minúsculas (97 a 122), que a su vez van antes que las letras acentuadas (é: 233). “Zoé” es la primera palabra y “éclair” la última. [sorted] devuelve una lista ordenada y deja intacto el arreglo;
- línea 51: para ordenar según las reglas del francés, pasamos un objeto
[Collator]*, que es un*[Comparator]de cadenas, a[sortWith]; se ordena el propio arreglo; - líneas 55–56: los arreglos también comparten con las colecciones funciones de cálculo comunes: suma, promedio, máximo, número de elementos que cumplen una condición… Las veremos cuando tratemos las colecciones;
- Líneas 59–62: Kotlin, al igual que Java, no tiene arreglos rectangulares bidimensionales: se crea un arreglo de arreglos con [Array(2) { IntArray(3) }], un arreglo de 2 elementos, cada uno de los cuales es creado por la lambda: un arreglo de 3 enteros. [matrix.size] es el número de filas, [matrix[0].size] es el número de elementos de la fila 0. [contentDeepToString] muestra un arreglo de arreglos;
- línea 64: de manera más general, los constructores [Array], [IntArray]… reciben un tamaño y una lambda que calcula cada elemento a partir de su índice: aquí, los cuadrados de los enteros de 0 a 4.
Tenga presente que, en Kotlin, los arreglos se usan principalmente por razones de rendimiento (arreglos de tipos primitivos), para los argumentos [vararg] y para interactuar con bibliotecas de Java. Para todo lo demás, se prefieren las colecciones, en especial las listas, que se tratan en la sección siguiente.
5.4. Colecciones
Además de los arreglos, Kotlin ofrece diversas colecciones para almacenar conjuntos de elementos. En la JVM, Kotlin no ha reescrito las clases de colecciones: usa las del Java Collections Framework (paquetes [java.util], [ArrayList], [HashMap], [LinkedHashMap], [HashSet]…, disponibles sin [import] mediante alias de tipo del paquete [kotlin.collections]. En cambio, las presenta a través de sus propias interfaces, organizadas en torno a una distinción que Java no hace en sus tipos: las colecciones de solo lectura y las colecciones mutables.
interfaz | rol | implementaciones y funciones constructoras |
[List<E>] [MutableList<E>] | una secuencia ordenada de elementos, accesibles por su posición | [ArrayList]; [listOf], [mutableListOf], [arrayListOf], [buildList], [emptyList] |
[Set<E>] [MutableSet<E>] | un conjunto: sin duplicados | [LinkedHashSet], [HashSet], [java.util.TreeSet]; [setOf], [mutableSetOf], [hashSetOf], [sortedSetOf] |
[Map<K, V>] [MutableMap<K, V>] | un diccionario: pares (clave, valor), donde las claves son únicas | [LinkedHashMap], [HashMap], [java.util.TreeMap]; [mapOf], [mutableMapOf], [hashMapOf], [sortedMapOf] |
[ArrayDeque<E>] | una cola de dos extremos, utilizable como cola o como pila (una clase específica de Kotlin) | [ArrayDeque] |
Las interfaces [List] y [Set] derivan de la interfaz [Collection<E>] ([size], [isEmpty], [contains]…), que a su vez deriva de [Iterable<E>], la interfaz de los objetos que pueden recorrerse mediante un bucle [for]. Estas interfaces solo tienen funciones de lectura: una [List<String>] no tiene ni la función [add] ni la función [remove]. Las funciones de modificación ([add], [remove], [clear], [[i] = value]…) las declaran las interfaces derivadas [MutableIterable], [MutableCollection], [MutableList], [MutableSet], y [MutableMap]. Una [ArrayList] implementa [MutableList] y, por lo tanto, también [List]. La regla de [val] y [var] se aplica así a las colecciones: se elige el tipo de solo lectura siempre que la colección no necesite modificarse (por ejemplo, en los parámetros de funciones), y el compilador prohíbe cualquier modificación a través de ese tipo.
En el caso de la JVM, estas interfaces existen solo en tiempo de compilación: [List] y [MutableList] se compilan ambas en la interfaz [java.util.List]. Esto es lo que permite pasar una lista de Kotlin a un método de Java, y viceversa, sin conversión. Una colección recibida de un método de Java tiene en Kotlin un tipo de plataforma, denotado [(Mutable)List<String!>] en los mensajes del compilador: Kotlin no sabe si es mutable ni si sus elementos pueden ser de tipo [null], y deja la decisión al programador.
Al igual que en Java, la mejor práctica es declarar las variables y los parámetros con el tipo de una interfaz y elegir la implementación en el momento de la creación, la mayoría de las veces mediante un constructor: [val cities: MutableList<String> = mutableListOf()]. Observe que las funciones constructoras de Kotlin eligen para los conjuntos y los diccionarios implementaciones que conservan el orden en que se agregan los elementos ([LinkedHashSet], [LinkedHashMap]): un punto que a menudo distingue un programa de Kotlin de su equivalente en Java, que en cambio usa [HashSet] y [HashMap].
Una colección contiene únicamente objetos. Kotlin no tiene tipos primitivos visibles en el lenguaje, y escribimos [List<Int>]; pero en la JVM, los elementos de una lista así son objetos [java.lang.Integer], y el compilador convierte automáticamente un [Int] en un [Integer] al agregar un elemento y viceversa al leerlo (“boxing” y “unboxing”). Esta conversión, transparente en Kotlin, tiene la misma sobrecarga que en Java: una lista de un millón de enteros contiene un millón de objetos [Integer]. Para grandes volúmenes de números, es preferible un arreglo [IntArray].
El paquete [java.util] también contiene las colecciones de Java 1.0: [Vector] (una lista), [Hashtable] (un diccionario) y [Stack] (una pila). Están obsoletas: como se sincronizan en cada operación, son más lentas que sus reemplazos y ya no deben usarse. En cuanto a los tipos sin procesar de Java (una colección genérica sin parámetro de tipo, [List] en lugar de [List<String>]), no existen en Kotlin: el parámetro de tipo es obligatorio o el compilador lo infiere.
5.4.1. Listas y la clase ArrayList
La clase [ArrayList<E>] implementa una lista modificable de objetos de tipo [E], cuyo tamaño varía durante la ejecución del programa. Almacena sus elementos en un arreglo interno que amplía automáticamente, de forma similar a [StringBuilder]. Esta es la implementación que crean [mutableListOf] y [arrayListOf]. Las listas de solo lectura creadas por [listOf] son, en la JVM, listas de tamaño fijo de la biblioteca de Java ([Arrays.asList] sobre el arreglo de argumentos, o una lista especializada para un solo elemento, o una lista vacía). El elemento i de una lista [l] se obtiene con [l[i]] y se modifica (si la lista es modificable) con [l[i] = value]: los operadores [get] y [set] (Capítulo 4) reemplazan a los métodos de Java [get(i)] y [set(i, value)].
Estas son algunas de las funciones de las interfaces [List<E>] y [MutableList<E>]:
Función | rol |
[size: Int] | propiedad: número de elementos de la lista; [indices] es el rango de índices, [lastIndex] es el último índice |
[l[index]], [getOrNull(index)], [getOrElse(index) { ... }] | lee el elemento número [index]; se lanza una excepción [IndexOutOfBoundsException] si el índice no es válido, excepto con [getOrNull] (que devuelve [null]) y [getOrElse] (que devuelve el valor calculado por la lambda) |
[first()], [last()], [firstOrNull()], [lastOrNull()] | el primer y el último elemento, respectivamente; se lanza una excepción si la lista está vacía, excepto con las variantes [OrNull] |
[contains(element)] | devuelve [true] si [element] está en la lista; se escribe como [element in list] |
[indexOf(element)], [lastIndexOf(element)] | devuelve la primera o la última posición de [element] en la lista, o -1 |
[subList(fromIndex, toIndex)] | devuelve una vista de los elementos desde [fromIndex] (inclusive) hasta [toIndex] (exclusive); [slice(range)] devuelve una copia |
[sorted()], [sortedDescending()], [sortedWith(comparator)], [reversed()] | devuelve una nueva lista ordenada, ordenada en orden descendente, ordenada según un [Comparator], invertida |
[binarySearch(element)] | búsqueda binaria en una lista ordenada |
[toTypedArray()], [toMutableList()] | devuelve los elementos de la lista como un arreglo, una nueva lista editable |
[add(element)], [add(index, element)] | ([MutableList]) agrega [element] al final de la lista, en la posición [index]; el operador [+=] agrega un elemento o una colección |
[addAll(elements)] | ([MutableList]) agrega los elementos de una colección al final de la lista |
[l[index] = element] | ([MutableList]) reemplaza el elemento número [index] |
[remove(element)], [removeAt(index)] | ([MutableList]) elimina la primera aparición de [element] (da como resultado [true] si la operación tiene éxito), el elemento número [index] (devuelve el elemento eliminado) |
[removeFirst()], [removeLast()], [removeIf { ... }] | ([MutableList]) elimina el primer elemento, el último elemento y los elementos que cumplen una condición |
[clear()] | ([MutableList]) elimina todos los elementos de la lista |
[sort()], [sortDescending()], [sortWith(comparator)], [reverse()], [shuffle()] | ([MutableList]) ordena, invierte y mezcla la propia lista |
Observe la convención de nombres de la biblioteca, que ya vimos con los arreglos: un verbo ([sort], [reverse], [shuffle]) modifica la propia colección y existe solo para colecciones modificables; un participio pasado ([sorted], [reversed], [shuffled]) devuelve una nueva colección y deja intacta la original. Las funciones de la clase utilitaria de Java [java.util.Collections] ([Collections.sort(list)]…) siguen siendo utilizables, pero estas funciones de extensión las hacen innecesarias.
Retomemos el ejemplo que vimos antes con un arreglo y procesémoslo ahora con una lista mutable de números reales, [MutableList<Double>]. Como una lista es similar a un arreglo, el código cambia muy poco. Este es el programa [Collections01.kt]:
Comentarios:
- Línea 27: la lista se crea vacía con la función [mutableListOf], que crea una [ArrayList]. El tipo de los elementos, [Double], se especifica como parámetro de tipo de la función, ya que no puede inferirse de una lista vacía; también podríamos haber escrito [val elements: MutableList<Double> = mutableListOf()] o [val elements = ArrayList<Double>()];
- Línea 40: ya no hay que gestionar ninguna ampliación; la lista se amplía automáticamente. Podríamos haber escrito [elements += element]: para una lista mutable declarada con [val], el operador [+=] agrega el elemento a la lista ([plusAssign]), mientras que para el arreglo declarado con [var] de [Arrays01.kt], creaba un nuevo arreglo. La variable [elements] es aquí un [val]: siempre hace referencia a la misma lista, cuyo contenido cambia;
- línea 25: la función [input] devuelve una lista modificable, porque el programa principal debe poder ordenarla;
- Línea 11: el número de elementos de la lista es la propiedad [size], igual que con los arreglos. A diferencia de [StringBuilder], [ArrayList] no permite determinar su capacidad; el método [ensureCapacity] solo permite fijarla de antemano;
- Líneas 17, 67, 68: la ordenación y la búsqueda binaria las realizan las funciones de extensión de la lista [sort] y [binarySearch], mientras que la búsqueda lineal la realiza su función [indexOf]. Para una lista de tipo [Double], [indexOf] existe, a diferencia del arreglo [DoubleArray]: compara los elementos mediante su función [equals], como en Java;
- Línea 54: la función [search] no modifica la lista: su parámetro se declara con el tipo [List<Double>], que es de solo lectura. Se le puede pasar una [MutableList<Double>], que es una [List<Double>]. Si intentara modificar la lista (por ejemplo, con [elements.add(element)]), el compilador lo rechazaría: [unresolved reference 'add' on receiver of type 'List<Double>']. El tipo del parámetro documenta y garantiza así que la función no altera la lista;
- líneas 46–49: la función genérica [display] recibe dos parámetros:
- el primero es un texto que se escribirá;
- el segundo es un objeto que implementa la interfaz genérica [Iterable<T>], cuya única función es [operator fun iterator(): Iterator<T>].
El bucle [for (element in elements)] es válido para cualquier objeto que tenga una función [operator fun iterator()], ya sea miembro o de extensión: es el caso de todas las colecciones, que implementan [Iterable], así como de los arreglos, las cadenas, los intervalos, etcétera. Los arreglos no implementan [Iterable]: la función [display] no es adecuada para un arreglo a menos que se le pase [array.asList()]. Volveremos a esta interfaz cuando tratemos las secuencias.
Resultados (en la línea de comandos; la entrada por teclado aparece después de los mensajes):
Los resultados son los mismos que con el arreglo.
5.4.2. Funciones de lista
El programa [Collections02.kt] usa las demás funciones de lista:
Resultados:
Comentarios:
- línea 6: [mutableListOf] crea una lista mutable que contiene los elementos indicados; el tipo de los elementos, [String], se infiere de los argumentos. Equivale al código de Java [new ArrayList<>(List.of("Paris", "Lyon", "Angers"))];
- líneas 10–12: tres formas de agregar elementos;
- líneas 14–15: en una lista mutable, los operadores [+=] y [-=] agregan y eliminan un elemento (o todos los elementos de una colección);
- línea 19: el elemento número 0 se reemplaza con el operador [[]], que llama a la función [set];
- líneas 20–21: el operador [[]] lee un elemento; [first] y [last] devuelven el primer y el último elemento, respectivamente, y la propiedad [lastIndex] equivale a [size - 1];
- Línea 23: un índice no válido lanza una excepción [IndexOutOfBoundsException], igual que en Java. Las funciones [getOrNull] y [getOrElse] permiten evitarla: la primera devuelve [null], y la segunda devuelve el valor calculado por una lambda que recibe el índice como argumento. En la plantilla, el texto
***[{ \\"?\\" }]es simplemente texto mostrado, mientras que la expresión***[cities.getOrElse(10) { "?" }]llama a la función; - líneas 26–27: búsqueda de un elemento con el operador [in] ([contains]) o con [indexOf];
- línea 30: [remove] devuelve [true] si el elemento se encontró y se eliminó;
- línea 31: [removeAt] elimina el elemento de una posición dada y lo devuelve;
- líneas 35–38: [sort] ordena la propia lista según el orden natural de sus elementos, definido por [compareTo], y [reverse] realiza la ordenación inversa;
- línea 39: [subList] devuelve una vista de los elementos 1 y 2 (excluyendo el 3), no una copia: modificar la vista modificaría la lista;
- líneas 42–44: [sorted] devuelve una nueva lista ordenada, y [sortedBy] devuelve una nueva lista ordenada por una clave calculada por una expresión lambda, en este caso, la longitud de los nombres. La ordenación es estable: las ciudades de la misma longitud (Tours, Lille, Brest) conservan su orden original. La lista [cities] no ha cambiado. [sortedBy] evita tener que escribir un [Comparator]; también podríamos escribir [cities.sortedWith(compareBy({ it.length }, { it }))] para ordenar por longitud y luego alfabéticamente (Capítulo 4);
- Líneas 47–48: conversión de una lista a un arreglo y de un arreglo a una lista. Gracias a los genéricos [reified] (Capítulo 4), [toTypedArray] puede crear un arreglo de cadenas del tamaño correcto sin necesitar la ayuda que requiere el método [toArray(String[]::new)] de Java;
- líneas 52–54: una trampa de Java que se evita. En Java, la interfaz [List] tiene dos métodos [remove], uno por posición y otro por valor, y [numbers.remove(1)], aplicado a una [List<Integer>], elimina el elemento número 1. Kotlin da nombres distintos a las dos operaciones: [removeAt] elimina por posición, y [remove] elimina por valor. [numbers.remove(1)] elimina, por lo tanto, efectivamente el valor 1;
- líneas 58–60: [listOf] crea una lista de solo lectura; [days.add("thursday")] sería rechazado en tiempo de compilación. En cambio, el operador [+], sí está disponible: crea una nueva lista formada por los elementos de [days] seguidos de “thursday”, y [days] permanece sin cambios;
- líneas 64–65: [clear] vacía la lista; [isEmpty] comprueba si está vacía;
- línea 68: la función [display] acepta cualquier objeto ([Any], Capítulo 4): una lista de cadenas, una lista de enteros o una cadena de texto. Una colección se muestra directamente: su función [toString] devuelve sus elementos entre corchetes.
5.4.3. Diccionarios: Map y MutableMap
Un diccionario es un conjunto de pares (clave, valor). Puede verse como una tabla de dos columnas:
clave | valor |
key1 | value1 |
key2 | value2 |
... | ... |
En la interfaz [Map<K, V>], las claves son de tipo [K] y los valores son de tipo [V]. Las claves son únicas: no puede haber dos claves idénticas (según la función [equals]). Un diccionario así podría verse de esta forma si los tipos [K] y [V] representaran clases:

Al igual que con las listas, Kotlin distingue entre la interfaz de solo lectura *[Map<K, V>] y la interfaz mutable *[MutableMap<K, V>]. Las implementaciones son las de Java:
- un [HashMap] almacena sus pares clave-valor en una tabla hash: la posición de un par en la tabla se calcula a partir del código hash de su clave (función [hashCode], Capítulo 4). Recuperar el valor asociado a una clave es, por lo tanto, muy rápido, sin importar el tamaño del diccionario. En cambio, el orden de las tuplas en la tabla no guarda relación con el orden en que se agregaron;
- un [LinkedHashMap] es un [HashMap] que, además, encadena sus tuplas en el orden en que se agregaron: es igual de rápido, usa un poco más de memoria y enumera sus tuplas en el orden en que se agregaron. Esta es la implementación elegida por las funciones de creación
***[mutableMapOf]y*[mapOf]*: por lo tanto, de forma predeterminada, un diccionario de Kotlin conserva el orden en que se agregaron sus claves. Para obtener un [HashMap], use [hashMapOf]* o su constructor.
Los pares de un diccionario creado con [mapOf] se escriben como [key to value]: [to] es una función infija de la biblioteca estándar que crea un par [Pair(key, value)] (Capítulo 3). Las principales funciones de los diccionarios son las siguientes:
función | rol |
[size] | propiedad: número de pares (clave, valor) del diccionario |
[dict[key]] | devuelve el valor asociado a [key], o [null] si la clave no existe (función [get]); por lo tanto, el tipo del resultado es [V?] |
[getValue(key)] | devuelve el valor asociado a [key], de tipo [V]; lanza una excepción [NoSuchElementException] si la clave no existe |
[getOrDefault(key, defaultValue)], [getOrElse(key) { ... }] | devuelve el valor asociado a [key], o [defaultValue], o el valor calculado por la lambda si la clave no existe |
[containsKey(key)], [containsValue(value)] | devuelve [true] si [key] es una clave del diccionario ([key in dict]) y [value] es uno de sus valores |
[keys], [values], [entries] | propiedades: el conjunto de claves, la colección de valores, el conjunto de tuplas del diccionario; un par [Map.Entry] tiene las propiedades [key] y [value] y puede desempaquetarse: [for ((key, value) in dict)] |
[dict[key] = value] | ([MutableMap]) asocia [value] a [key]: agrega el par si la clave no existe; en caso contrario, reemplaza el valor (función [set]); [dict += key to value] hace lo mismo |
[put(key, value)] | ([MutableMap]) hace lo mismo, pero devuelve el valor anterior, o [null] |
[putIfAbsent(key, value)] | ([MutableMap]) agrega el par solo si la clave no existe; devuelve el valor existente, o [null] |
[getOrPut(key) { ... }] | ([MutableMap]) devuelve el valor asociado a [key]; si la clave no existe, calcula el valor mediante la lambda, agrega el par y devuelve el valor |
[remove(key)] | ([MutableMap]) elimina el par clave-valor [key] y devuelve su valor, o [null]; [dict -= key] hace lo mismo |
[clear()] | ([MutableMap]) elimina todas las entradas del diccionario |
Consideremos el programa de ejemplo [Collections03.kt]:
Comentarios:
- línea 6: un arreglo de cadenas que se usará para inicializar el diccionario [<String, Int>];
- línea 7: el diccionario vacío creado por [mutableMapOf]: es un [LinkedHashMap];
- línea 9: el mismo diccionario, esta vez implementado por un [HashMap], creado mediante su constructor;
- líneas 10–13: inicialización de los dos diccionarios a partir del arreglo de cadenas. Cada elemento se divide con [split], y la desestructuración de la lista resultante asigna sus dos campos a las variables [name] y [age]. Agregar un par se escribe [dict[name] = value], igual que asignar un elemento de un arreglo;
- línea 16: un diccionario se muestra directamente, con sus pares entre llaves. Las tuplas de
[dict]aparecen en el orden en que se agregaron; las de[dictHash]aparecen en el orden de la tabla hash, que depende de los códigos hash de las claves (línea 1 de los resultados): un*[HashMap]no garantiza ningún orden específico. El programa de Java de este capítulo, que usa un [HashMap]*, mostraba sus claves en este segundo orden; - línea 18: el número de pares del diccionario;
- líneas 20–22: las claves y los valores del diccionario. Las propiedades [dict.keys] y [dict.values] son colecciones y, por lo tanto, [Iterable]: la función [display] que ya encontramos es adecuada;
- líneas 25–26: recorrido de las claves y obtención del valor de cada clave con el operador [[]];
- línea 30: eliminación de un par del diccionario;
- Líneas 33–34: un diccionario no es en sí mismo una colección, pero el bucle [for] sabe recorrerlo: la biblioteca le proporciona una función de extensión [iterator] que enumera sus tuplas ([entries]). Cada par, de tipo [Map.Entry<String, Int>], se desempaqueta en [(key, value)], mediante las funciones de extensión [component1] y [component2] de [Map.Entry]. Este enfoque es más eficiente que el anterior, que busca el valor de cada clave, y más legible que su equivalente en Java ([for (Map.Entry<String, Integer> entry : dict.entrySet())], then [entry.getKey()] and [entry.getValue()]);
- línea 37: [put] agrega un par clave-valor o reemplaza el valor de una clave existente, sin lanzar una excepción ni emitir una advertencia; el valor devuelto, ya sea el valor anterior o [null], indica lo que ocurrió. Cuando no se necesita este valor, use [dict[key] = value];
- línea 39: [putIfAbsent] no reemplaza el valor de una clave existente;
- líneas 41–42: leer una clave inexistente no produce un error: el operador [[]] devuelve [null]. Su resultado es de tipo [Int?], y el compilador exige que el caso [null] se maneje antes de usar el valor. [getOrDefault] y [getOrElse] permiten elegir el valor devuelto en este caso, y el operador [in] ([containsKey]) permite comprobar la existencia de una clave;
- Líneas 44–47: la forma estándar de contar ocurrencias: sumamos 1 al valor de la clave, o 0 + 1 si no existe, usando el operador Elvis [?:]. La clave “zoé” pasa de 12 a 13; la clave “léa” se crea con el valor 1. También puede usarse el método de Java [merge] : [dict.merge(name, 1, Int::plus)];
- líneas 49–50: [getOrPut] devuelve el valor asociado a una clave; si la clave no existe, calcula un valor mediante la lambda, agrega el par al diccionario y devuelve el valor. La clave “max” se crea con el valor 30; la clave “jean” ya existe y se devuelve su valor 21 sin que se ejecute la lambda. Es la función ideal para una caché o para agrupar elementos en listas: [groups.getOrPut(key) { mutableListOf() }.add(element)];
- líneas 52–53: un diccionario de solo lectura, creado por [mapOf] a partir de los pares clave-valor de la forma [key to value]. [capitals["Spain"] = "Madrid"] sería rechazado en tiempo de compilación;
- líneas 55–65: búsqueda de una clave en el diccionario. [dict[searchedName]] devuelve un [Int?]: el caso [null] se verifica antes de usar el valor; en la rama [age != null], el compilador sabe que [age] es un [Int] (conversión inteligente de tipos). En Java, [int age = dict.get(searchedName);] compila pero lanza una excepción [NullPointerException] si la clave no existe; en Kotlin, [val age: Int = dict[searchedName]] se rechaza en tiempo de compilación.
Resultados:
A diferencia del programa de Java, donde [HashMap] enumeraba las claves en un orden impredecible, las claves del diccionario se enumeran en el orden en que se agregaron: “zoé” y “léa” aparecen al final. Si necesita que las claves permanezcan ordenadas, use un [TreeMap], que se muestra más adelante.
5.4.4. Otras colecciones
La biblioteca estándar de Kotlin y el paquete [java.util] contienen otras colecciones, cada una adecuada para un propósito específico:
clase (constructor) | rol |
[LinkedHashSet<E>] ([setOf], [mutableSetOf]) | un conjunto: sin duplicados, con comprobación de pertenencia muy rápida; conserva el orden en que se agregaron sus elementos. Es el conjunto predeterminado de Kotlin |
[HashSet<E>] ([hashSetOf]) | un conjunto sin orden, algo más eficiente en memoria |
[java.util.TreeSet<E>] ([sortedSetOf], [toSortedSet]) | un conjunto cuyos elementos se mantienen ordenados |
[ArrayDeque<E>] | Una clase específica de Kotlin ([kotlin.collections.ArrayDeque], que no debe confundirse con [java.util.ArrayDeque]): una cola de dos extremos que también implementa [MutableList]. Cuando se usa como cola, los elementos se eliminan en el orden en que se agregaron (FIFO, primero en entrar, primero en salir); cuando se usa como pila, el último elemento agregado es el primero en eliminarse (LIFO, último en entrar, primero en salir) |
[LinkedHashMap<K, V>] ([mapOf], [mutableMapOf]) | Un diccionario que conserva el orden en que se agregan sus claves. Es el diccionario predeterminado de Kotlin |
[java.util.TreeMap<K, V>] ([sortedMapOf], [toSortedMap]) | un diccionario cuyas claves se mantienen ordenadas |
[java.util.PriorityQueue<E>] | una cola de prioridad: el elemento que se extrae es el menor según el orden de la cola |
[java.util.LinkedList<E>] | una lista doblemente enlazada: inserciones y eliminaciones rápidas en los extremos y durante el recorrido |
En los conjuntos, la distinción entre solo lectura y modificable es la misma que en las listas: [Set<E>] tiene solo funciones de lectura, mientras que [MutableSet<E>] agrega [add], [remove]…
El programa [Collections04.kt] ofrece una visión rápida de estas colecciones:
Resultados:
Comentarios:
- Líneas 3–4: las clases [PriorityQueue] y [TreeMap] del JDK no tienen alias en la biblioteca de Kotlin y deben importarse. [ArrayDeque] no es un alias: es la clase de Kotlin la que se usa;
- línea 7: un paciente se representa con una clase de datos (Capítulo 4), el equivalente del [record] de Java;
- línea 12: un conjunto mutable, inicializado con tres elementos;
- línea 14: [add] devuelve [false] si el elemento ya está en el conjunto, que permanece sin cambios;
- líneas 18–21: [setOf] crea un conjunto de solo lectura. Las funciones infijas [intersect] (intersección), [union] (unión) y [subtract] (diferencia) devuelven un conjunto nuevo y no modifican [languages]: a diferencia de Java con [retainAll], [addAll] y [removeAll], no es necesario trabajar sobre una copia. El conjunto creado conserva el orden de los elementos: primero los de [languages], seguidos de los de [web] que no estaban originalmente en él;
- líneas 23–24: un [HashSet] presenta sus elementos en un orden sin significado, el de su tabla hash; un [TreeSet] los presenta ordenados;
- línea 26: [toSet] devuelve un conjunto formado por los elementos de una lista: es la forma más sencilla de eliminar duplicados, conservando el orden de su primera aparición ([distinct] devolvería una lista);
- Líneas 29–34: [ArrayDeque] se usa como cola: [addLast] inserta un elemento al final de la cola, [removeFirst] elimina el elemento más antiguo y [first] obtiene un elemento sin eliminarlo. Las expresiones de una plantilla se evalúan de izquierda a derecha: [first], luego los dos [removeFirst], luego [size];
- líneas 37–42: [ArrayDeque] se usa como pila: [addLast] apila un elemento, [removeLast] desapila el elemento más reciente y [last] obtiene la cima de la pila. Las clases de Java 1.0 [Stack], e incluso [java.util.ArrayDeque] y sus métodos [push]/[pop]/[offer]/[poll], no vienen al caso en Kotlin: los nombres [addFirst], [addLast], [removeFirst], [removeLast], [first] y [last] son los mismos para [ArrayDeque] y para todas las listas mutables;
- Líneas 44–49: en una pila vacía, [removeLast] lanza una excepción [NoSuchElementException], mientras que [removeLastOrNull] devuelve [null]. Esto sigue la convención de nombres de la biblioteca: una función [xxx] lanza una excepción cuando no puede devolver un resultado, mientras que su variante [xxxOrNull] devuelve [null] ([first]/[firstOrNull], [removeFirst]/[removeFirstOrNull], [toInt]/[toIntOrNull]…). [e::class.simpleName] es el nombre simple de la clase de la excepción (Capítulo 4);
- líneas 53–58: las tuplas de un [TreeMap] se enumeran en el orden de las claves. Se rellena con el operador [[]], igual que cualquier diccionario mutable. Ordenar las claves habilita operaciones que una tabla hash no puede ofrecer: [firstKey] devuelve la clave menor y [headMap] devuelve la parte del diccionario cuyas claves preceden a un valor dado;
- líneas 60–61: [sortedMapOf] crea un [TreeMap] a partir de pares ordenados por clave; [mutableMapOf] conserva el orden en que se agregaron los elementos;
- líneas 64–75: un [PriorityQueue] necesita poder comparar sus elementos. Aquí se le pasa un [Comparator] que compara prioridades: [compareBy<Emergency> { it.priority }] (Capítulo 4) se lee “comparar las emergencias según su propiedad [priority]”. Los pacientes se atienden en orden de prioridad creciente, sin importar su orden de llegada. El método [poll] devuelve el elemento de menor prioridad, o [null] si la cola está vacía: el operador Elvis [?: break] hace entonces que se salga del bucle. Esta es la sintaxis idiomática, ya que [break] es una expresión en Kotlin. En Java, se escribiría [while ((emergency = emergencies.poll()) != null)]; Kotlin no permite asignaciones dentro de una expresión.
5.4.5. Vistas de solo lectura, inmutables y copias
Una clase que administra una colección suele necesitar exponerla hacia el exterior sin permitir que se modifique. Java no tiene una interfaz de “solo lectura” distinta de [List]: usa colecciones inmutables, que implementan la interfaz [List] completa pero cuyos métodos de modificación lanzan una excepción [UnsupportedOperationException] en tiempo de ejecución. Kotlin aborda esta necesidad principalmente mediante sus tipos: basta con declarar la colección con el tipo [List] y el compilador impedirá cualquier modificación. Sin embargo, es importante entender qué garantiza este tipo y qué no. El programa [Collections05.kt] muestra las tres formas de representar una colección: un tipo de solo lectura, una vista no modificable y una copia:
Resultados:
Comentarios:
- líneas 6–23: la clase [Classroom] administra una lista de estudiantes. La propia lista mutable es privada; solo la función [enroll] permite modificarla;
- líneas 11–12: la propiedad [students] expone la lista privada, pero con el tipo [List<String>] es de solo lectura. Esta es la práctica estándar en Kotlin: una lista mutable privada y una propiedad pública de solo lectura. El código externo puede leer la lista, pero [students.add("intruder")] se rechaza en tiempo de compilación ([unresolved reference 'add' on receiver of type 'List<String>']), mientras que Java solo lo rechaza en tiempo de ejecución;
- línea 36: la propiedad [students] no crea ningún objeto; hace visible la propia lista privada, una [java.util.ArrayList]. Por lo tanto, ve los cambios realizados por la clase propietaria (línea 3 de los resultados);
- líneas 41–43: solo lectura no significa inmutable. El tipo
*[List]prohíbe la modificación a través de esta referencia, pero el objeto es una*[ArrayList]totalmente modificable: convertirlo a [MutableList] (o pasar la lista a un método de Java, para el cual es una [java.util.List] común) permite modificarlo, y el estudiante “intruder” se agrega a la lista de la clase (línea 4 de los resultados). El tipo de solo lectura protege contra errores, no contra la mala intención; - líneas 15–16 y 44–48: para una protección completa, devolvemos una vista de solo lectura creada por el método [Collections.unmodifiableList] del JDK: incluso después de una conversión de tipo, cualquier intento de modificarla lanza una excepción [UnsupportedOperationException]. Al igual que la anterior, esta vista no copia la lista y refleja los cambios realizados por la clase propietaria;
- líneas 19–20 y 52–54: [toList], en cambio, devuelve una copia de la lista: la lista [copy] no ve la incorporación de “petit”. Una copia es independiente del original, pero tiene un costo: el getter crea una nueva lista cada vez que se lee la propiedad;
- líneas 57–58: [mapOf], al igual que [listOf] y [setOf], crea una colección inicializada en una sola instrucción, con un tipo de solo lectura: [grades["durand"] = 9] no compila ([no 'set' operator method providing array access]). Estas colecciones equivalen a [List.of], [Set.of] y [Map.of] de Java, con la misma salvedad de antes: son de solo lectura por tipo, pero [mapOf] crea un [LinkedHashMap] común;
- líneas 61–62: las colecciones creadas por
***[List.of]en Java rechazan el valor*[null]en tiempo de ejecución. En Kotlin, lo determina el tipo: una***[List<String>]no puede contener un[null](el compilador lo rechaza), mientras que una***[List<String?>]***sí puede. [filterNotNull] devuelve una lista de elementos distintos de [null], de tipo [List<String>]*; - Líneas 64–67 y 71–74: una copia defensiva. La clase [Group] recibe una lista en su constructor; si la conservara tal cual, quien se la pasó podría modificarla después, en este caso, agregando “intruder” a la lista [members]. Por lo tanto, el parámetro del constructor [students] no es una propiedad (no va precedido de [val]): sirve para inicializar la propiedad [students] con una copia. El grupo no se ve afectado por la adición (última línea de los resultados). Este enfoque no puede usarse con las propiedades del constructor principal de una clase de datos; si una clase de datos recibe una colección, quien la llama le pasará una colección que ya no modifica, por ejemplo, una creada con [listOf] o [toList].
Por lo tanto, el tipo [List<String>] especifica lo que el código que la recibe puede hacer con ella, no lo que la lista es realmente. Para colecciones verdaderamente inmutables, existe la biblioteca [kotlinx.collections.immutable] de JetBrains ([persistentListOf], [persistentMapOf]…), y también pueden usarse las colecciones inmutables de Java ([java.util.List.copyOf(list)]). Una buena práctica habitual, tanto en Kotlin como en Java, es hacer que las colecciones sean de solo lectura y crear una nueva colección cada vez que se quiera modificar una ([list + element], [list - element], [list.filter { ... }]…): los operadores y las funciones de la biblioteca estándar hacen que esta práctica resulte natural.
5.4.6. Ordenación, primeros y últimos elementos, iteración
El programa [Collections06.kt] muestra tres aspectos útiles del trabajo con colecciones: la ordenación por criterios, el acceso a los extremos de una colección (lo que Java 21 denominó colecciones secuenciadas) y la eliminación de elementos durante una iteración:
Resultados:
Comentarios:
- línea 8: un estudiante se representa mediante una data class;
- línea 11: la función [names] devuelve una lista de nombres de estudiantes. La función [map], que ya hemos usado sin presentarla, aplica una lambda a cada elemento de una colección y devuelve una lista de resultados; en Java, esto requiere un bucle o la API Stream. La función se escribe como una función con cuerpo de expresión ([= expression], Capítulo 3);
- línea 21: [sortBy] ordena la propia lista según una clave extraída de cada elemento mediante una lambda; en este caso, el nombre. Los nombres se comparan según el orden natural de las cadenas: “Durand”, que comienza con mayúscula, va primero, y “élise” va al final;
- línea 23: [sortWith] ordena según un [Comparator]. La función [compareBy] (Capítulo 4) construye un comparador a partir de la función que extrae la clave; una sobrecarga toma como primer parámetro el comparador que se usará para comparar las claves, en este caso un
*[Collator]: el orden sigue el de un diccionario francés. Esto equivale a***[Comparator.comparing(Student::name, collator)]** en Java; - Línea 25: los comparadores se definen de la siguiente manera: [compareByDescending] compara las notas en orden descendente, y [thenBy] agrega un criterio secundario que se usa para ordenar a los estudiantes con la misma nota: sus nombres, sin distinguir mayúsculas de minúsculas ([String.CASE_INSENSITIVE_ORDER]). Durand y Martin, que tienen ambos una nota de 15, se ordenan por nombre. El parámetro de tipo [<Student>] de [compareByDescending] es obligatorio aquí, porque el compilador no puede inferir el tipo de los elementos en una expresión que continúa con [thenBy];
- Líneas 29–32: las funciones [first] y [last] devuelven el primer y el último elemento, respectivamente, y [asReversed] devuelve una vista de la lista en orden inverso sin copiarla ([reversed] devolvería una copia invertida). [first] y [lastOrNull] también aceptan una condición: devuelven el primer (o el último) elemento que la cumple; [first] lanza una excepción [NoSuchElementException] si no hay ninguno; [lastOrNull] devuelve [null]. Kotlin ofrece estas funciones en todas las colecciones desde su primera versión: los métodos [getFirst], [getLast] y [reversed], que Java 21 agregó a sus colecciones secuenciadas ([SequencedCollection], [SequencedSet], [SequencedMap]) no aportan mucho;
- líneas 33–36: [linkedSetOf] crea un [LinkedHashSet], declarado aquí con el tipo de su clase. Entonces podemos usar los métodos que Java 21 agregó a esta clase: [addFirst] agrega “Lyon” al comienzo del conjunto. Observe un punto sutil: cuando una clase de Java tiene un método con el mismo nombre que una función de extensión, el método miembro siempre tiene prioridad (Capítulo 4). Aquí,
[cities.reversed()]llama al método de Java 21[reversed]*, que devuelve una vista invertida del conjunto, en lugar de la función de extensión de Kotlin[reversed], que devolvería una lista. En cambio, [cities.last()] llama a la extensión de Kotlin, que recorre el conjunto hasta su último elemento, porque el método de Java se llama [getLast]; Kotlin lo expone como una propiedad, [cities.last]*, que devuelve el último elemento sin recorrer el conjunto. Los resultados son los mismos; solo cambia el costo; - líneas 37–39: un
*[TreeMap]*inicializado con los pares clave-valor de un diccionario, y sus métodos[firstEntry],[lastEntry], y *[descendingMap]*(que muestra los pares en orden descendente de claves); - Líneas 42–50: no se debe modificar una colección mientras se la recorre con un bucle [for]: el iterador que usa el bucle detecta la modificación y lanza una excepción [ConcurrentModificationException] en el siguiente elemento. La prueba se realiza sobre una copia de la lista. El comportamiento es el mismo que en Java, ya que la lista es un [ArrayList];
- líneas 53–60: un enfoque correcto consiste en escribir explícitamente el bucle usando un iterador y eliminar el elemento actual mediante el método [remove] del iterador. Para una lista mutable, [iterator] devuelve un [MutableIterator], que tiene esta función; un [Iterator] ordinario (el de una [List]) no la tiene. Como Kotlin no tiene un bucle [for] de tres cláusulas, el bucle se escribe usando [while];
- línea 62: de forma más simple, la función [removeAll] elimina los elementos que cumplen una condición, expresada mediante una lambda [{ it.grade < 15 }], que se lee “la función que, dado un estudiante [it], asocia el booleano [it.grade < 15]”. También se puede usar el método de Java [removeIf], mientras que [retainAll], por el contrario, conserva los elementos que cumplen la condición. Las lambdas se tratarán en detalle en el Capítulo 7; por ahora, basta con saber leerlas. Las encontraremos en cada línea de la sección siguiente;
- Línea 65: la función [forEach] ejecuta una lambda para cada elemento; un bucle que use [for] funcionaría igual de bien. Al mostrar una data class mediante su función [toString] se obtiene el nombre de la clase y los valores de sus propiedades: [Student(name=Durand, grade=15)].
5.5. Operaciones sobre colecciones y secuencias
El curso de Java presentó aquí la API Stream (paquete [java.util.stream]), que permite procesar los elementos de una colección como si se consultara una base de datos: filtrar, ordenar, agrupar, calcular totales… Kotlin no lo necesita: en su biblioteca estándar, estas operaciones son funciones de extensión de las propias colecciones ([Iterable<T>], [List<T>], [Map<K, V>]…). Se escribe [persons.filter { it.age >= 18 }] donde Java escribe [persons.stream().filter(p -> p.age() >= 18).toList()]: no hace falta pasar por un stream ni usar un collector final; el resultado es directamente una lista.
Estas operaciones sobre colecciones son inmediatas: cada una recorre toda la colección y construye una nueva colección. Para lograr la evaluación perezosa de los streams de Java (donde los elementos se calculan uno por uno, bajo demanda, sin colecciones intermedias), Kotlin ofrece las secuencias ([Sequence<T>]), que admiten las mismas operaciones. Por último, los streams de Java todavía se pueden usar desde Kotlin, como cualquier clase del paquete del JDK: lo veremos brevemente al final de la sección.
Los programas de esta sección conservan los nombres de sus equivalentes en Java: [Streams01.kt] a [Streams05.kt].
5.5.1. Las interfaces Iterable e Iterator
Retomemos primero la interfaz [Iterable<T>], que define los objetos que se pueden recorrer con un bucle [for]. Como en Java, contiene un solo método abstracto, [iterator], que devuelve un iterador [Iterator<T>]: un objeto que indica si quedan elementos ([hasNext]) y devuelve el siguiente elemento ([next]).
Un objeto [Iterable] no necesita contener sus elementos: su iterador puede producirlos uno por uno, bajo demanda. El programa [Streams01.kt] ofrece un ejemplo de ello, e introduce los generadores de Kotlin, que Java no tiene, y una secuencia infinita:
Resultados:
Comentarios:
- A partir de la línea 37: la clase
[Evens]implementa la interfaz*[Iterable<Int>]: su método [iterator], que se sobrescribe ([override]), devuelve un iterador que genera los números pares de 0 a [max]*. No construye ninguna lista: el iterador solo almacena el siguiente número que se debe generar (línea 44); - línea 42: el iterador es un objeto anónimo: una expresión de objeto [object : Iterator<Int> { ... }], que declara e instancia una clase sin nombre que implementa la interfaz en una sola expresión. Equivale a la clase anónima de Java [new Iterator<>() { ... }]. Tiene acceso a la propiedad [max] del objeto [Evens];
- líneas 46–51: [hasNext] indica si todavía queda un elemento por producir;
- líneas 54–61: [next] produce el siguiente elemento. Si se llama cuando ya no quedan elementos, debe lanzar una excepción [NoSuchElementException] (en Kotlin, [NoSuchElementException] es un alias de la clase de Java [java.util.NoSuchElementException], disponible sin [import]);
- líneas 7–8: los resultados (líneas 2–11) muestran que la producción de un elemento por parte del iterador y el consumo de ese elemento por parte del bucle [for] se alternan;
- Líneas 13–15: lo que hace realmente el bucle [for]: solicita un iterador al objeto, llama a [hasNext] mientras ese método devuelva [true], y obtiene cada elemento mediante [next];
- líneas 68–77: los mismos números pares, generados por un generador. La función [sequence] de la biblioteca estándar toma un bloque de código (una lambda) y devuelve una secuencia [Sequence<Int>]. Cada llamada a [yield(n)] (línea 74) pasa un elemento al consumidor y suspende el bloque, que se reanudará inmediatamente después de [yield] cuando se solicite el siguiente elemento. Esto permite escribir un iterador como un simple bucle, sin tener que administrar uno mismo el estado entre las llamadas a
*[next]. Es el equivalente de [yield return] de C#, que Java no tiene: el curso de Java exigía a los estudiantes escribir la clase del iterador o usar [Stream.iterate]*. Este mecanismo de suspensión es el de las corrutinas, que estudiaremos en el Capítulo 9; - los resultados (líneas 22–29) muestran que el generador y el bucle [for] se alternan exactamente como lo hace el iterador escrito a mano: no se genera nada por adelantado;
- Líneas 26–27: una secuencia infinita, la sucesión de Fibonacci. [generateSequence(seed) { function }] produce la semilla, luego el resultado de la función aplicada a la semilla, luego el resultado de la función aplicada a ese resultado, y así sucesivamente. Cada elemento aquí es un par ([Pair<Long, Long>], creado mediante [to]) de dos números consecutivos de la sucesión; la expresión lambda desempaqueta el par recibido [(a, b)] y devuelve el siguiente par. [map] conserva solo el primer número, [takeWhile] detiene la secuencia en el primer número mayor que 100, y [joinToString] concatena los números restantes con un separador. La secuencia nunca se calcula por completo: solo se calculan los elementos solicitados;
- línea 31: a diferencia de Java, una cadena se recorre directamente con [for], carácter por carácter: la biblioteca estándar de Kotlin define una función [operator fun CharSequence.iterator()];
- Líneas 81–82: esta es la regla general: el bucle [for] de Kotlin acepta cualquier objeto que tenga una función [operator fun iterator()] (miembro o de extensión) que devuelva un objeto que tenga las funciones [operator fun hasNext()] y [operator fun next()]. La clase [Counter] no implementa [Iterable]; basta con su función [iterator], marcada como [operator] ([(1..n).iterator()] es el iterador del intervalo [1..n]). Es una convención, similar a las de la sobrecarga de operadores que se vieron en el Capítulo 4.
En resumen: un [Iterable] se recorre con [for], y se puede obtener muy fácilmente un objeto que produzca sus elementos bajo demanda mediante [sequence { ... yield(x) ... }] o [generateSequence]. Todas las secuencias utilizan este mecanismo de generación bajo demanda.
5.5.2. Filtrar, proyectar, ordenar
Los siguientes ejemplos trabajan con una pequeña lista de personas. Una persona se representa mediante una data class ([data class]), presentada en el Capítulo 4, que es el equivalente en Kotlin de la clase [record] de Java: en una sola línea se obtiene una clase con un constructor y propiedades de solo lectura ([p.lastName], [p.age]…), un método [toString] que muestra las propiedades, un operador de igualdad que compara sus valores y una función [copy].
El programa [Streams02.kt] muestra las operaciones básicas sobre colecciones:
Resultados:
Comentarios:
- líneas 6–13: la lista de solo lectura de personas creada mediante [listOf]. La coma después del último elemento (“coma final”) está permitida en Kotlin: facilita agregar un elemento;
- línea 64: la data class [Person], declarada a nivel de archivo, junto a las funciones;
- línea 17: la función [filter] filtra la lista: conserva solo los elementos que cumplen una condición. Esta condición se le pasa en forma de una lambda [{ p -> p.age >= 18 }], “la función que, dada una persona p, devuelve el booleano [p.age >= 18]”. [filter] llama a esta función para cada persona. Cuando el último parámetro de una función es una función, la lambda se escribe después de los paréntesis, que se omiten si están vacíos: [persons.filter { ... }], y no [persons.filter({ ... })];
- el resultado de
*[filter]es una nueva lista,[List<Person>]: la lista[persons]* permanece sin cambios. Esto es válido para todas las operaciones presentadas en esta sección, que se aplican tanto a listas de solo lectura como a listas mutables; - Líneas 58–60: la función genérica [display] recorre una colección usando [forEach] y muestra cada elemento; una persona se muestra mediante el método [toString] de la data class: [Person(lastName=dupont, ...)] (paréntesis donde Java usaba corchetes);
- línea 21: la función [map] proyecta cada elemento en un nuevo valor, en este caso una cadena. El resultado es una lista [List<String>]. Una lambda con un solo parámetro puede omitir el nombre del parámetro; en ese caso, se llama [it];
- líneas 25–28: las operaciones devuelven colecciones, a las que se pueden aplicar otras operaciones. Las operaciones suelen escribirse una por línea: esta cadena de llamadas se lee de arriba hacia abajo como una receta. [Person::lastName] es una referencia a propiedad, una notación abreviada de la lambda [{ it.lastName }];
- línea 28: [sorted] ordena según el orden natural de los elementos, en este caso cadenas ([sortedDescending] ordena en orden inverso);
- línea 32: [sortedBy] ordena por una clave calculada mediante una lambda ([sortedByDescending] en orden descendente); [take(3)] conserva los tres primeros elementos;
- línea 35: para ordenar según varios criterios, [sortedWith] acepta un [Comparator], construido con las funciones de Kotlin que se vieron en el Capítulo 4: [compareByDescending<Person> { it.age }] (edad en orden descendente), seguida de [thenBy { it.lastName }] para distinguir entre personas de la misma edad. Durand y Laurent, que tienen ambos 32 años, se ordenan por apellido. Se debe especificar el tipo [Person] en [compareByDescending], porque el compilador no puede inferirlo solo a partir de la lambda;
- Línea 39: para numerar, [mapIndexed] pasa a la lambda el índice del elemento además del propio elemento; de manera similar, existen [filterIndexed], [forEachIndexed]… Java tendría que recorrer los índices mediante [IntStream.range];
- líneas 40–41: [withIndex] convierte cada elemento en un objeto [IndexedValue] (propiedades [index] y [value]), que se puede filtrar y luego desempaquetar en [(i, p)] dentro del bucle;
- líneas 45–46: una lista, como cualquier colección, se puede recorrer tantas veces como se desee: el resultado de [filter] es una lista real, no un cálculo pendiente;
- Líneas 48–53: un stream de Java ([java.util.stream.Stream]), obtenido mediante el método [stream] de la lista (una lista de Kotlin es, en tiempo de ejecución, una [java.util.List]), se puede usar desde Kotlin; las lambdas de Kotlin se convierten automáticamente en interfaces funcionales de Java. Sin embargo, sigue siendo de un solo uso: una vez recorrido por una operación terminal (aquí, [count]), lanza una excepción [IllegalStateException]. [e.javaClass.simpleName] es la notación de Kotlin para [e.getClass().getSimpleName()].
Por lo tanto, las operaciones sobre colecciones de Kotlin no distinguen entre operaciones intermedias y terminales: cada una produce un resultado completo. Esta simplicidad tiene un costo: una cadena de n operaciones crea n colecciones intermedias. Esto no es un problema para colecciones pequeñas, que son, con mucho, las más comunes; para colecciones grandes, o para operaciones que pueden terminar antes de tiempo, se usan las secuencias (programa [Streams05.kt]). Al igual que Java, y a diferencia de C# (LINQ), Kotlin no tiene una sintaxis de consulta similar a SQL: los procesamientos se escriben como cadenas de llamadas a funciones.
5.5.3. Cuantificadores, agregados, selección de elementos
El programa [Streams03.kt] incluye operaciones que devuelven un único valor y operaciones que seleccionan un subconjunto de una colección:
Resultados:
Comentarios:
- Líneas 15–17: [any] devuelve [true] si al menos un elemento cumple la condición, [all] si todos la cumplen, y [none] si ninguno la cumple (equivalentes de [anyMatch], [allMatch] y [noneMatch] de los streams de Java). Sin parámetros, [any()] indica si la colección tiene al menos un elemento. En una plantilla de cadena, [${ ... }] puede contener cualquier expresión, incluida una llamada a una función con una lambda;
- línea 20: [count] cuenta los elementos; con una condición, cuenta los que la cumplen, sin necesidad de filtrar primero. Para una colección, la propiedad [size] es obviamente preferible a [count()];
- Líneas 21–23: [sumOf { it.age }] suma un valor calculado para cada elemento. En una colección de números ([List<Int>]), las funciones [sum] y [average] se aplican directamente: no hace falta, como en Java, pasar por un stream especializado ([mapToInt(...)] seguido de [IntStream]). [average] devuelve un [Double], que es [NaN] (“not a number”) para una colección vacía. ["%.2f".format(x)] formatea el número según el idioma del sistema: de ahí el punto decimal;
- línea 24: [min] y [max] devuelven los elementos más pequeño y más grande de una colección de elementos comparables; [minOf { it.age }] devuelve el menor de los valores calculados. Estas funciones lanzan [NoSuchElementException] si la colección está vacía; sus variantes [minOrNull], [maxOrNull], [minOfOrNull]… devuelven entonces [null];
- Línea 26: [minBy] y [maxBy] devuelven el elemento (en este caso, la persona) con la clave mínima o máxima, y no el valor de la clave en sí. Mientras que Java devuelve un [Optional<Person>] que debe abrirse con [get], Kotlin devuelve directamente la persona (y lanza una excepción si la colección está vacía; [minByOrNull] devuelve entonces [null]);
- Líneas 28–30: [fold] calcula un agregado arbitrario: parte de un valor inicial (aquí, 0), luego llama a la lambda para cada elemento con el resultado anterior ([total]) y el elemento ([p]), y devuelve el resultado final. [reduce] hace lo mismo, usando el primer elemento como valor inicial: aquí, en cada paso, se conserva el más largo de los dos nombres. [sum], [count], [max]… son simplemente casos particulares de estas dos funciones;
- líneas 32–35: [first] devuelve el primer elemento; con una condición, el primer elemento que la cumple. [last] devuelve el último;
- líneas 37–38: no hay nadie en Brest. [firstOrNull] devuelve entonces [null]: su tipo de retorno es [Person?]. Donde Java usa un [Optional], Kotlin usa un tipo que admite nulos y sus operadores: [brestResident?.lastName ?: "nobody"] devuelve el apellido si hay una persona, y “nobody” en caso contrario. Es el equivalente exacto de [map(Person::lastName).orElse("nobody")] en Java;
- líneas 39–43: [first] exige que exista un elemento; de lo contrario, lanza una excepción [NoSuchElementException]. Se usa cuando la ausencia de un valor es un error; cuando es normal, se usa [firstOrNull]. La misma convención de nombres se aplica en toda la biblioteca: [last]/[lastOrNull], [single]/[singleOrNull], [elementAt]/[elementAtOrNull], [getOrNull] (para un índice)…;
- líneas 45–47: [single] exige que haya exactamente un elemento (que cumpla la condición); de lo contrario, lanza una excepción. [singleOrNull] devuelve [null] si no hay ninguno, o si hay varios, como ocurre aquí con París. Los streams de Java no tienen un equivalente;
- línea 50: [distinct] elimina los duplicados (según los define el método [equals]);
- línea 51: [distinctBy] elimina los elementos cuya clave ya se ha visto: de esta manera, conservamos la primera instancia de cada ciudad. El curso de Java debía implementar esta operación por cuenta propia, usando un conjunto de las ciudades que ya se habían visto;
- líneas 54–58: [take(n)] conserva los primeros n elementos, mientras que [drop(n)] los omite ([limit] y [skip] en Java); [takeLast] y [dropLast] hacen lo mismo a partir del final. Combinadas, [drop] y [take] extraen una “página” de resultados; para una lista, [slice(2..3)] extrae directamente los elementos de un rango de índices. [takeWhile] conserva los elementos mientras una condición sea verdadera y se detiene en el primer elemento que no la cumple; [dropWhile] hace lo contrario: omite esos elementos y conserva todos los siguientes;
- línea 61: [chunked(3)] divide la colección en listas de 3 elementos, y la última lista puede ser más corta: esto es paginación. Java 24 tuvo que introducir los “gatherers” ([gather(Gatherers.windowFixed(3))]) con este fin; Kotlin tiene [chunked] desde la versión 1.2;
- Líneas 62–63: [windowed(3)] genera ventanas deslizantes de 3 elementos consecutivos: los elementos 0–2, luego 1–3, luego 2–4… (el [windowSliding(3)] de Java 24). Al igual que [chunked], [windowed] acepta una expresión lambda que transforma cada ventana: aquí, calculamos el promedio móvil de las edades de tres personas.
5.5.4. Data classes locales, agrupaciones, uniones
El programa [Streams04.kt] presenta operaciones más complejas. Mientras que Java realiza la mayoría de ellas mediante la operación terminal [collect] y los collectors de la clase [Collectors], Kotlin tiene una función distinta para cada uno:
Resultados:
Comentarios:
- línea 22: una data class local, declarada dentro de la función donde se usa (el equivalente del record local de Java 16). Permite asignar un nombre y un tipo a los resultados intermedios de un procesamiento sin tener que declarar una clase a nivel de archivo: línea 26: cada persona mayor de 40 años se convierte en un [Summary] que conserva solo los datos relevantes;
- línea 27: la expresión lambda desempaqueta el [Summary] recibido: [(name, decade)] entre paréntesis declara dos parámetros que reciben las dos propiedades del objeto, en el orden especificado por el constructor. Esto es posible con cualquier data class (Capítulo 3), así como con tuplas y entradas de diccionario;
- Línea 31: [groupBy] agrupa los elementos con la misma clave, en este caso la ciudad. El resultado es un diccionario [Map<String, List<Person>>]: cada ciudad se asocia con una lista de sus residentes. Los diccionarios creados por la biblioteca estándar de Kotlin ([groupBy], [associate], [mapOf]…) son [LinkedHashMap]: conservan las claves en el orden de su primera aparición. Java, que por defecto crea un [HashMap] con un orden impredecible, tenía que solicitarlo explícitamente ([LinkedHashMap::new]);
- líneas 32–34: un bucle [for] recorre las entradas del diccionario, que se desempaquetan en [(city, group)]. Para cada grupo, se muestran su tamaño, su edad promedio y sus nombres; [joinToString(", ") { it.lastName }] concatena los apellidos con un separador: su función lambda convierte cada elemento en una cadena, lo que evita la necesidad de un [map] previo;
- línea 37: una segunda lambda, opcional, transforma los elementos clasificados en cada grupo: aquí, solo se conservan los apellidos (este es el collector [mapping] de Java);
- líneas 42–45: una unión. Al igual que los streams de Java, las colecciones de Kotlin no tienen una operación de unión; la logramos con [flatMap], cuya lambda devuelve una lista para cada elemento: [flatMap] concatena todas esas listas. Aquí, cada persona se reemplaza por la lista de ciudades con el mismo nombre (una o ninguna), convertidas en cadenas. Como en una unión interna de SQL, solo se conservan los pares que coinciden: Laurent, que vive en Lyon (ausente de la lista de ciudades), no aparece, ni tampoco Brest, que no tiene residentes. Este código recorre la lista completa de ciudades para cada persona;
- líneas 47–51: la misma unión, pero más eficiente. [associateBy { it.name }] construye un diccionario de ciudades, donde la clave es el nombre de la ciudad y el valor es la propia ciudad (el collector de Java [toMap(City::name, v -> v)]); luego buscamos en este diccionario la ciudad de cada adulto. [citiesByName[p.city]] devuelve un [City?] o [null] si no se encuentra la ciudad; [?.let { ... }] construye la cadena solo si se encontró la ciudad, y [mapNotNull] es un [map] que elimina los resultados [null]: el filtrado y la proyección se realizan en una sola operación. A diferencia de [toMap] en Java, [associateBy] no señala las claves duplicadas: prevalece el último valor;
- líneas 55–57: [associate] construye un diccionario a partir de una lambda que devuelve, para cada elemento, un par clave-valor, escrito como [it.lastName to it.age]. [associateWith] toma los elementos como claves y calcula los valores: en este caso, la longitud de cada palabra;
- Líneas 58–59: [partition] divide los elementos en dos listas según una condición: los que la cumplen y los demás. El resultado es un par de listas, que se desempaquetan de inmediato en [(adults, minors)]; Java devolvía un diccionario con las claves [true] y [false] ([partitioningBy]);
- líneas 60–61: [zip] empareja los elementos del mismo rango de las dos colecciones y se detiene al final de la más corta. Sin lambda, devuelve una lista de pares ([(1, a)]…); con una lambda, combina cada par de elementos, en este caso, en un nombre seguido de un apellido. Los streams de Java no tienen un equivalente;
- línea 64: contar los elementos de cada grupo. [groupingBy { it.city }] no construye los grupos: devuelve un objeto [Grouping] que puede calcular la clave de cada elemento; [eachCount] recorre entonces la colección una sola vez, contando los elementos de cada clave (el collector de Java [counting]). [toSortedMap] copia el diccionario en un diccionario ordenado por claves (un [TreeMap]) para mostrarlo;
- líneas 65–66: sumar un valor por grupo: los grupos se construyen mediante [groupBy], y luego [mapValues] transforma cada valor del diccionario (aquí, una lista de personas) en otro valor (aquí, la suma de sus edades), conservando las claves. La función lambda recibe una entrada del diccionario, desempaquetada mediante [(_, group)]: el guion bajo [_] indica que no nos interesa la clave;
- líneas 67–68: un [Grouping] también tiene [fold], [reduce] y [aggregate], que calculan un agregado por grupo en una sola pasada, sin construir las listas de los grupos: aquí, la edad máxima de cada ciudad;
- líneas 71–72: [flatMap] otra vez, que transforma cada ciudad en una lista de dos cadenas concatenadas; [flatten] “aplana” una lista de listas;
- línea 76: la posición de cada elemento en una lista filtrada: [forEachIndexed] pasa el índice a la lambda. Java habría tenido que almacenar el stream en una lista y luego recorrer sus índices.
La siguiente tabla resume las correspondencias entre los collectors de Java y las funciones de Kotlin que se encontraron en este programa:
Java (streams y collectors) | Kotlin (colecciones) |
[collect(toList())], [toList()] | Innecesario: el resultado ya es una lista; [toList()], [toMutableList()] para copiar |
[groupingBy(f)] | [groupBy(f)]; [groupBy(f, g)] para [groupingBy(f, mapping(g, toList()))] |
[groupingBy(f, counting())] | [groupingBy(f).eachCount()] |
[groupingBy(f, summingInt(g))] | [groupBy(f).mapValues { (_, l) -> l.sumOf(g) }] |
[toMap(f, v -> v)] | [associateBy(f)] |
[toMap(f, g)] | [associate { f(it) to g(it) }], [associateBy(f, g)] |
[partitioningBy(p)] | [partition(p)] (un par de listas) |
[joining(", ")] | [joinToString(", ")] |
[flatMap(e -> stream)] | [flatMap { list }], [flatten()] |
5.5.5. Evaluación perezosa: las secuencias
Las operaciones sobre colecciones se ejecutan de inmediato, cada una en su totalidad. Las operaciones sobre secuencias ([Sequence<T>]) no se ejecutan cuando se escriben, sino cuando una operación terminal recorre la secuencia: esta es la evaluación perezosa, tal como se vio en los streams de Java. El programa [Streams05.kt] compara ambas, mediante lambdas que muestran lo que hacen:
Resultados:
Comentarios:
- Líneas 13–16: la cadena [filter] + [map] aplicada a una lista. Las lambdas muestran un mensaje antes de devolver su valor: el cuerpo de una lambda puede contener varias instrucciones (separadas aquí por un punto y coma, ya que están en la misma línea), y lo que se devuelve es el valor de la última expresión: no hay [return];
- líneas 2–10 de los resultados: [filter] examina los seis números y construye una lista intermedia [[2, 4, 6]]; solo entonces [map] calcula los tres cuadrados y construye la lista de resultados. Cada paso se ejecuta por completo antes del siguiente;
- líneas 20–29: el mismo procesamiento sobre una secuencia, obtenida mediante [numbers.asSequence()]. Aquí las expresiones lambda se escriben en varias líneas;
- línea 13 de los resultados: una vez definida la secuencia, todavía no se ha mostrado nada: ni [filter] ni [map] han examinado aún un solo elemento. [evenSquares] no contiene resultados, sino la descripción de un cálculo;
- Líneas 15–26 de los resultados: el cálculo se ejecuta durante la operación terminal [forEach] (línea 33), elemento por elemento: cada número pasa por [filter], luego por [map] si es par, y después entra en [forEach] antes de que se examine el siguiente número. No se construye ninguna lista intermedia;
- líneas 36–39: a diferencia de un stream de Java, una secuencia obtenida de una colección se puede recorrer varias veces: cada operación terminal ([toList] en este caso) reinicia el cálculo desde el principio, a partir del estado actual de la colección. Por lo tanto, la secuencia creada antes de agregar 10 lo tiene en cuenta. Java habría tenido que almacenar una lambda que vuelva a crear el stream ([Supplier<Stream<Integer>>]); una secuencia así ya es un patrón reutilizable. Sin embargo, algunas secuencias se recorren una sola vez: las construidas sobre un iterador o un flujo de entrada, por ejemplo; [constrainOnce()] devuelve una secuencia que lanza una [IllegalStateException] en la segunda pasada;
- líneas 42–44: [toList] realiza el procesamiento y almacena sus resultados: [snapshot] es una lista que no ve la adición de 20;
- líneas 48–50: [first] detiene la iteración en cuanto obtiene un elemento: los números posteriores a 3 nunca se examinan. [any], [take], [takeWhile], [firstOrNull]… también detienen la iteración lo antes posible; esto es lo que permite procesar secuencias infinitas. En una lista, [filter { ... }.first()] habría examinado los ocho números antes de devolver el primero; por eso escribimos en su lugar [first { ... }], que se detiene en el primer elemento encontrado;
- líneas 55–58: algunas operaciones intermedias no pueden procesar los elementos uno por uno: [sorted] debe conocer todos los elementos para devolver el menor. [sequenceOf(3, 1, 2)] crea una secuencia a partir de valores; la operación [onEach], que ejecuta una lambda sobre cada elemento a medida que pasa sin modificarlo (el equivalente en Java de [peek]), muestra que [sorted] recibe los tres elementos antes de transmitir uno solo;
- líneas 61–64: secuencias infinitas creadas mediante [generateSequence], que ya vimos en [Streams01.kt]: las potencias de 2, de las cuales se conservan las diez primeras mediante [take(10)], y los números impares, entre los que se busca el primero cuyo cuadrado supere 200. Una operación que deba recorrer toda la secuencia ([toList], [count], [sorted]…) nunca terminaría en una secuencia infinita: primero hay que limitarla;
- Línea 67: los streams de Java siguen siendo utilizables desde Kotlin, incluidos los streams de tipos primitivos ([IntStream], [LongStream], [DoubleStream]); [IntStream.rangeClosed(1, 10)] genera los enteros del 1 al 10. La línea 68 muestra el mismo cálculo en Kotlin, sobre el intervalo [1..10]. En Kotlin no hay colecciones ni secuencias especializadas para tipos primitivos: una [List<Int>] contiene objetos [Integer]. Para volúmenes muy grandes de números, se usa un arreglo [IntArray] (que a su vez contiene [filter], [map], [sum]…);
- Líneas 71–72: las funciones de extensión [asSequence] y [asStream] del paquete [kotlin.streams] (importado en la línea 4) convierten un stream de Java en una secuencia, y viceversa. Se usan en la interfaz con una biblioteca de Java que produce o espera streams. [boxed] transforma un [IntStream] en un [Stream<Integer>].
¿Cuándo se debe usar una secuencia en lugar de una colección?
- Las operaciones sobre colecciones son la opción predeterminada: son simples y rápidas para colecciones pequeñas y medianas, donde el costo de las colecciones intermedias es insignificante;
- Se pasa a las secuencias ([asSequence()]) cuando la cadena de operaciones es larga y la colección es grande (sin colecciones intermedias), cuando el procesamiento puede detenerse antes de tiempo ([first], [take], [any]…), o cuando los elementos se generan bajo demanda (secuencias infinitas, generadores, líneas de un archivo grande: lo veremos con [useLines]);
- Los streams de Java ([stream()]) son de poca utilidad en un programa Kotlin, excepto para interactuar con una biblioteca de Java y por su versión paralela: el método [parallelStream] de una colección devuelve un stream cuyos elementos son procesados simultáneamente por varios hilos (Capítulo 8), algo que las secuencias no pueden hacer. Solo acelera las operaciones costosas sobre grandes volúmenes de datos y requiere lambdas sin efectos secundarios: solo debe usarse después de evaluar sus beneficios.
La siguiente tabla compara las tres herramientas:
Colecciones de Kotlin | Secuencias de Kotlin | Streams de Java | |
Evaluación | inmediata, operación por operación | perezosa, elemento por elemento | perezosa, elemento por elemento |
colecciones intermedias | una por operación | ninguna | ninguna |
varias pasadas | sí | Sí (excepto las secuencias de un solo uso) | no: un stream por recorrido |
elementos infinitos | no | sí ([generateSequence], [sequence]) | Sí ([Stream.iterate], [Stream.generate]) |
procesamiento paralelo | no | no | Sí ([parallelStream]) |
tipos primitivos | no (excepto los arreglos [IntArray]…) | no | sí ([IntStream]…) |
Encontraremos estas operaciones a lo largo del curso, y en el Capítulo 7 veremos cómo se construyen los tipos funcionales y las funciones de orden superior que los utilizan.
5.6. Archivos de texto
Kotlin no tiene una API propia para archivos: utiliza las del JDK y las complementa con funciones de extensión que simplifican su uso. Como recordatorio, Java tiene dos API para archivos: el paquete [java.io], disponible desde Java 1.0 ([File], [FileReader], [FileInputStream]…), y el paquete [java.nio.file], introducido con Java 7 ([Path], [Files]…), que es más completo y proporciona mejores informes de errores. La biblioteca estándar de Kotlin ofrece extensiones para ambos:
- el paquete [kotlin.io] (importado automáticamente) extiende la clase [java.io.File]: [File("infos.txt").readText()], [readLines()], [forEachLine { }], [useLines { }], [writeText(text)], [appendText(text)], [bufferedReader()], [printWriter()]…;
- el paquete [kotlin.io.path] (que debe importarse) extiende la interfaz [java.nio.file.Path] con funciones del mismo nombre, y agrega una función de creación [Path("infos.txt")], el operador [/] para construir rutas, propiedades ([name], [extension]…) y funciones que replican las de la clase [Files] ([exists], [createDirectories], [listDirectoryEntries], [walk]…).
Como en Java, [Path] es hoy la opción preferida: usaremos [kotlin.io.path]. Una ruta relativa, como [Path("infos.txt")], se complementa con el directorio actual del programa, es decir, aquel desde el que se lo inició.
Todas estas funciones utilizan por defecto la codificación UTF-8, independientemente del sistema operativo, y lo hacen desde la primera versión de Kotlin; un parámetro opcional permite especificar otra. Del lado de Java, la codificación predeterminada de clases como [java.io] ([FileReader], [PrintWriter]…) es UTF-8 desde Java 18 (JEP 400); anteriormente, dependía del sistema (a menudo Windows-1252 en Windows en francés). Con Kotlin y JDK 25, esto ya no es un problema.
Por último, hay que tener presente que Kotlin no tiene excepciones verificadas (Capítulo 3): los errores de E/S se señalan mediante excepciones derivadas de [java.io.IOException], que el compilador no exige capturar ni declarar. Corresponde al programador decidir dónde tratarlas.
5.6.1. Lectura de un archivo de texto
La clase [java.io.BufferedReader] permite leer el contenido de un archivo de texto, línea por línea. En realidad, es capaz de procesar flujos que no son archivos (una conexión de red, por ejemplo). Lee el archivo por bloques, que almacena en un búfer: la mayoría de las lecturas se realizan en memoria, sin acceder al disco. Kotlin agrega funciones a [Path] (y a [File]) que crean este lector o lo utilizan por nosotros:
función | rol |
[path.bufferedReader(charset = Charsets.UTF_8)] | abre el archivo [path] para lectura y devuelve un [BufferedReader]; el parámetro opcional especifica la codificación: [path.bufferedReader(Charsets.ISO_8859_1)] |
[reader.readLine(): String?] | devuelve la siguiente línea, sin el carácter de fin de línea, o [null] si se llegó al final del flujo (método de Java) |
[reader.lineSequence()], [reader.readLines()], [reader.readText()] | las líneas restantes en forma de secuencia (leída bajo demanda, que se puede recorrer una sola vez) o de lista; todo el texto restante (extensiones de Kotlin) |
[reader.close()] | cierra el flujo y libera los recursos asignados para su gestión. Esto debe hacerse una vez procesado el flujo, de lo cual se encarga la función [use] |
[path.readText()], [path.readLines()] | abre el archivo, devuelve todo su contenido (una cadena, una lista de líneas) y lo cierra |
[path.forEachLine { line -> ... }] | abre el archivo, llama a la lambda para cada línea y lo cierra |
[path.useLines { lines -> ... }] | abre el archivo, pasa a la lambda la secuencia [Sequence<String>] de sus líneas (leídas bajo demanda), cierra el archivo y devuelve el resultado de la lambda |
El programa [Files01.kt] es el siguiente:
Comentarios:
- líneas 5–11: las funciones de extensión de [kotlin.io.path] deben importarse una por una (o todas juntas mediante [import kotlin.io.path.*], como haremos más adelante); IntelliJ e IDEA agregan estas líneas automáticamente;
- Línea 14: la función [main] recibe aquí los argumentos de la línea de comandos, en el arreglo [args];
- línea 16: muestra el nombre de la carpeta actual, aquella desde la que se inició el programa. [Path("")] designa la carpeta actual; [absolute()] la convierte en una ruta completa, de la cual la propiedad [name] conserva solo el último elemento, para no saturar los resultados con una ruta completa;
- línea 18: el archivo que se lee es el que se pasa como argumento, o [infos.txt]. [args.firstOrNull()] devuelve el primer argumento, o [null] si no hay ninguno; el operador Elvis [?:] proporciona entonces el valor predeterminado. Como es una ruta relativa, el archivo se busca en el directorio actual;
- línea 22: [bufferedReader()] abre el archivo y devuelve un [BufferedReader]. La función de extensión [use] (Capítulo 3) ejecuta la lambda que se le pasa, entregándole el objeto ([reader]), y luego cierra ese objeto al salir de la lambda, incluso si se produjo una excepción dentro de ella. Es el equivalente en Kotlin de la instrucción [try] con recursos de Java; se aplica a cualquier objeto que implemente la interfaz [AutoCloseable] (o [Closeable]), es decir, que tenga un método [close] que libere recursos (archivo, conexión de red, conexión a una base de datos, etc.);
- líneas 23–26: el archivo se lee línea por línea. En Java, se escribe [while ((line = reader.readLine()) != null)], pero en Kotlin una asignación no es una expresión: no se puede evaluar. Por lo tanto, se escribe un bucle infinito y [val line = reader.readLine() ?: break]: [readLine] devuelve un [String?]; si devuelve [null] (fin del archivo), el operador Elvis ejecuta [break], que sale del bucle; de lo contrario, [line] es un [String] que no admite nulos. Otra notación, más funcional, es [reader.lineSequence().forEach { println(it) }];
- línea 32: [readText] lee todo el archivo de una vez y lo cierra. Línea 36: [forEachLine] abre el archivo, llama a la lambda para cada línea y lo cierra: es el equivalente en una línea de la lectura 1;
- Línea 40: [useLines] abre el archivo y pasa a la función lambda la secuencia de sus líneas, que las lee bajo demanda a medida que procesa el archivo; el archivo se cierra al final de la función lambda, y [useLines] devuelve el resultado (en este caso, el número de líneas no vacías). Esto permite procesar un archivo de varios gigabytes, realizando todas las operaciones sobre la secuencia, sin cargarlo en memoria. La secuencia no debe salir de la lambda: una vez cerrado el archivo, ya no se puede recorrer;
- Líneas 42–47: los errores de entrada/salida se señalan mediante excepciones derivadas de [java.io.IOException]. Un archivo inexistente provoca una [NoSuchFileException] (derivada de [java.nio.file]), que a su vez provoca esta excepción; por lo tanto, debe capturarse primero. Su propiedad [file] (el método de Java [getFile]) devuelve la ruta del archivo que se busca. Las funciones que extienden [java.io.File] señalan el mismo error mediante una [FileNotFoundException]. El compilador no exige estas cláusulas [catch]: sin ellas, un error terminaría el programa y mostraría la excepción.
El archivo [infos.txt] es el siguiente:
Se encuentra en la raíz del proyecto Gradle [05-classes-kotlin], que es el directorio actual para el comando [gradlew run]:
Con un archivo inexistente (los argumentos del programa se pasan a [gradlew run] mediante la opción [--args]):
Cuando se usa una carpeta en lugar de un archivo, su lectura provoca otra excepción, [IOException], cuyo mensaje proporciona el sistema operativo:
Estas pruebas se ejecutaron en Linux; en Windows, el mensaje de este último error sería diferente. Por lo tanto, colocaremos los archivos de datos de nuestros programas y de la aplicación de ejemplo en el directorio raíz del proyecto. Cuando se inician desde IntelliJ e IDEA, los programas también tienen el directorio del proyecto como directorio actual.
5.6.2. Escritura de un archivo de texto
La clase [java.io.BufferedWriter] permite escribir en un archivo de texto. Al igual que [BufferedReader], utiliza un búfer y es capaz de manejar flujos que no son archivos.
Función | rol |
[path.bufferedWriter(charset = Charsets.UTF_8, vararg options)] | abre el archivo [path] para escritura y devuelve un [BufferedWriter]. El archivo se crea, o se vacía si ya existe. Los parámetros opcionales especifican la codificación y el modo de apertura: [path.bufferedWriter(options = arrayOf(StandardOpenOption.APPEND))] agrega los datos al final del archivo existente |
[writer.write(str)] | escribe [str] en el archivo |
[writer.newLine()] | escribe un carácter de fin de línea: el predeterminado del sistema, “\r\n” en Windows, “\n” en Linux y macOS |
[writer.flush()] | escribe el contenido del búfer en el archivo sin esperar a que esté lleno |
[writer.close()] | cierra el flujo después de escribir el contenido del búfer en el archivo. Debe hacerse una vez procesado el flujo: [use] se encarga de ello |
[path.writeText(text)], [path.appendText(text)] | crea (o sobrescribe) el archivo y escribe en él [text]; agrega [text] al final del archivo |
[file.printWriter()] | (para [java.io.File]) abre el archivo y devuelve un [PrintWriter], que tiene los métodos [print], [println], y [printf] |
Las escrituras en un archivo mediante [BufferedWriter] no son inmediatas: el texto se escribe primero en el búfer, y luego en el archivo cuando el búfer está lleno, cuando se vacía explícitamente mediante el método [flush], o cuando se cierra el flujo. Este es el modo más eficiente para los archivos porque limita los accesos al disco. No es adecuado para todos los flujos, en particular los flujos de red: en un diálogo entre dos interlocutores, lo que uno escribe debe ser leído de inmediato por el otro, y el búfer debe vaciarse después de cada mensaje. La clase [java.io.PrintWriter], que usaremos más adelante, agrega los métodos [print], [println] y [printf], y puede vaciar automáticamente su búfer después de cada [println] (constructor [PrintWriter(writer, true)]).
El programa [Files02.kt] es el siguiente:
Resultados (las líneas escritas en el teclado se ingresaron después de los mensajes de solicitud):
Comentarios:
- Línea 15: [bufferedWriter()] crea el archivo y devuelve un [BufferedWriter]; de nuevo, la función [use] cierra automáticamente el flujo al salir de la lambda (llave de cierre en la línea 28). Es este cierre el que escribe en el archivo el texto que queda en el búfer: sin él, el archivo podría quedar incompleto;
- línea 16: la codificación predeterminada del JDK es UTF-8. Las funciones de Kotlin, por su parte, usan UTF-8 por defecto sin importar la codificación del JDK;
- Líneas 19–20: el mensaje de solicitud se muestra con [print], que no salta a la línea siguiente, y luego [readlnOrNull] lee una línea del teclado; devuelve [null] si la entrada estándar está cerrada (fin de archivo), de ahí [?.trim() ?: ""];
- líneas 25–26: escribe una línea en el archivo de texto, seguida de un carácter de salto de línea;
- línea 31: la función [fileSize] (el método de Java [Files.size]) devuelve el tamaño de un archivo en bytes. Los 18 bytes se desglosan así: 16 caracteres, más dos saltos de línea de un byte ("\n" en Linux, donde se hicieron las pruebas; en Windows, cada salto de línea "\r\n" ocuparía 2 bytes). Un objeto [Path] insertado en una plantilla de cadena se muestra mediante su método [toString]: la ruta;
- línea 33: ¿por qué un [try / catch], que el compilador no exige? Podríamos especificar un nombre de archivo de la forma [dir1/dir2/file] con un directorio [dir1/dir2] que no existe, lo que imposibilitaría crear el archivo. Entonces se lanzaría una excepción [NoSuchFileException], derivada de [IOException]. Hay otros casos posibles de excepción (disco lleno, permisos insuficientes, etc.). Un programa que escribe un archivo debe prever estos errores: [try / catch] los convierte aquí en un mensaje claro, en lugar de provocar la terminación del programa.
5.6.3. Rutas y funciones de kotlin.io.path
Para las operaciones comunes, las funciones de [kotlin.io.path] eliminan la necesidad de manejar flujos: una sola función abre el archivo, lo lee o lo escribe por completo y luego lo cierra. También permiten crear, copiar, mover y eliminar archivos y carpetas. La mayoría de estas funciones llaman a un método de la clase de Java [Files], lo que las hace más cómodas: [path.exists()] en lugar de [Files.exists(path)].
función | rol |
[Path("data", "cities.txt")], [folder / "cities.txt"] | construye una ruta usando el separador del sistema (el operador [/] llama al método de Java [folder.resolve("cities.txt")]) |
[path.name], [path.nameWithoutExtension], [path.extension], [path.parent], [path.absolute()] | el nombre del archivo (sin la extensión), la extensión, la carpeta y la ruta completa |
[path.readText()], [path.readLines()], [path.useLines { }] | devuelve el contenido del archivo como una cadena, una lista de líneas o una secuencia de líneas leídas bajo demanda |
[path.writeText(text)], [path.appendText(text)] | crea (o sobrescribe) el archivo y escribe en él [text]; agrega [text] al final del archivo |
[path.writeLines(lines)], [path.appendLines(lines)] | escribe, agrega una colección (o secuencia) de líneas, cada una seguida de un salto de línea |
[path.readBytes()], [path.writeBytes(bytes)] | lee y escribe el archivo como un arreglo de bytes |
[path.exists()], [path.isDirectory()], [path.fileSize()], [path.deleteExisting()], [path.deleteIfExists()], [path.copyTo(target)], [path.moveTo(target)] | verifica si un archivo existe; si es una carpeta, devuelve su tamaño, lo elimina, lo copia o lo mueve |
[path.createDirectories()] | crea la carpeta y sus carpetas superiores si no existen |
[folder.listDirectoryEntries(glob)], [folder.walk()] | los elementos de la carpeta (una lista, posiblemente filtrada por un patrón como ["*.txt"]), de toda su estructura de árbol (una secuencia) |
El programa [Files03.kt] las utiliza:
Resultados:
Comentarios:
- línea 5: se importan todas las funciones de [kotlin.io.path] ;
- Líneas 10–13: el operador [/] (función [operator fun Path.div(other: String)]; véase la sobrecarga de operadores en el Capítulo 4) construye la ruta [data/cities.txt] usando el separador de rutas del sistema. Los ejercicios del curso se ejecutaron en Linux: la ruta resultante es [data/cities.txt]; en Windows, sería [data\cities.txt]. Construir rutas de esta manera, en lugar de concatenar cadenas, hace que el código sea portable. Las propiedades [name], [parent], [nameWithoutExtension], y [extension] descomponen la ruta; las dos últimas no existen en Java, donde hay que buscar el punto mediante [lastIndexOf];
- línea 16: la creación de la carpeta [data] no provoca un error si ya existe;
- líneas 19–26: escritura, adición y lectura, cada una en una sola instrucción. [appendLines] escribe cada elemento de la lista seguido de un salto de línea;
- líneas 28–30: [useLines] presenta las líneas como una secuencia: se leen una por una a medida que avanza el bucle, y se les pueden aplicar todas las operaciones de secuencias. Esto nos permite procesar un archivo de varios gigabytes sin cargarlo en memoria, que es lo que haría [readLines] . El archivo permanece abierto durante la iteración, y [useLines] lo cierra al final de la lambda: esto equivale a [Files.lines(path)] en un [try] con recursos;
- líneas 33–37: la clase [java.io.File] tiene las mismas funciones de extensión ([readText], [readLines], [writeText]…), y algunas otras, como [printWriter], que devuelve un [PrintWriter] (métodos [print] y [println]). Se pasa de un [File] a un [Path] mediante [toPath()], y viceversa mediante [toFile()];
- Líneas 40–47: el mismo texto “café” se escribe con tres codificaciones, y luego los bytes de los archivos se muestran en hexadecimal mediante la función de Kotlin [toHexString], configurada por un objeto [HexFormat] (en mayúsculas). Observe que la clase [HexFormat] que se usa aquí es la clase de Kotlin ([kotlin.text.HexFormat], importada automáticamente), no la clase de Java ([java.util.HexFormat]):
- en UTF-8, la codificación predeterminada, los caracteres acentuados ocupan 2 bytes (é = C3 A9) y los demás 1 byte: 5 bytes para 4 caracteres;
- en UTF-8 con BOM (Byte Order Mark, marca de orden de bytes), el archivo comienza con los tres bytes EF BB BF, que indican al software que el archivo está codificado en UTF-8. Ni Java ni Kotlin escriben el BOM por sí solos: se obtiene escribiendo el carácter U+FEFF al comienzo del texto, denotado como ["\uFEFF"];
- en Latin-1 (ISO-8859-1), la codificación tradicional de los textos de Europa occidental, cada carácter ocupa un byte (é = E9). El objeto de Kotlin [Charsets] da acceso a las codificaciones comunes ([UTF_8], [ISO_8859_1], [UTF_16]…), al igual que la clase de Java [StandardCharsets];
- líneas 50–57: leer un archivo con una codificación distinta de la utilizada al escribirlo corrompe los caracteres acentuados: el byte E9 al final del archivo no es válido en UTF-8. No todas las funciones de [kotlin.io.path] se comportan de la misma manera, como muestra la ejecución: [readLines] (que llama a [Files.readAllLines]) rechaza un archivo así lanzando una excepción [MalformedInputException] (derivada de [IOException]), mientras que [readText] reemplaza cada byte no válido por el carácter �, sin señalar ningún error. Hemos comprobado que [useLines] y [forEachLine] son tan estrictas como [readLines], y que [bufferedReader] y las funciones de [java.io.File] son tolerantes, igual que [readText];
- línea 58: al leerlo con la codificación correcta, el archivo es correcto;
- línea 60: al leer, ni Java ni Kotlin reconocen el BOM: se lee como un carácter invisible al comienzo del texto, que tiene entonces 5 caracteres en lugar de 4. Si necesita leer archivos UTF-8 generados con BOM (por ciertos programas de Windows), debe eliminar usted mismo este carácter ([text.removePrefix("\uFEFF")]). Hoy en día, la regla es simple: los archivos de texto se escriben y se leen en formato UTF-8, sin BOM;
- líneas 63–65: [exists] comprueba si un archivo existe; [listDirectoryEntries("*.txt")] devuelve una lista de los elementos de la carpeta cuyos nombres coinciden con el patrón (un “glob”: [*] coincide con cualquier secuencia de caracteres). Esta función no garantiza el orden de los nombres: [sorted] los ordena. A diferencia de [Files.list], devuelve una lista en lugar de un stream: no hay nada que cerrar;
- líneas 69–72: eliminación de la carpeta. [deleteExisting] (el método de Java [Files.delete]) se niega a eliminar una carpeta que no está vacía: recorremos todo el árbol mediante [walk], que devuelve una secuencia. Por defecto, [walk] devuelve solo archivos; la opción [PathWalkOption.INCLUDE_DIRECTORIES] hace que devuelva también las carpetas. Las rutas se ordenan en orden inverso ([sortedDescending]) para eliminar el contenido de una carpeta antes que la propia carpeta. Kotlin también tiene una función [deleteRecursively()] que hace todo esto, pero todavía es experimental: el compilador exige que se habilite explícitamente mediante la anotación [@OptIn(ExperimentalPathApi::class)].
Las funciones de archivos bloquean el hilo que las llama hasta que la operación termina. En el Capítulo 9, dedicado a las corrutinas, veremos cómo evitar bloquear un programa durante una operación de E/S prolongada.
5.7. Archivos binarios
5.7.1. Las clases DataOutputStream y DataInputStream
Las clases [java.io.DataOutputStream] y [java.io.DataInputStream] sirven para escribir y leer archivos binarios. En un archivo de este tipo, los datos no se escriben como texto sino en su forma interna: un [Int] siempre ocupa 4 bytes, sea cual sea su valor. Se trata de flujos de bytes: derivan de las clases [OutputStream] y [InputStream], mientras que los flujos de texto derivan de [Writer] y [Reader]. Kotlin no tiene un equivalente propio: utiliza las clases del JDK, junto con algunas funciones de extensión para crearlas ([path.outputStream()], [path.inputStream()], [stream.buffered()]…) y la función [use] para cerrarlas.
Consideremos la siguiente aplicación:
El archivo de texto [persons1.txt], ubicado en el directorio raíz del proyecto, tiene el siguiente contenido:
El programa [Files04.kt] es el siguiente:
Veamos más de cerca las operaciones que involucran la clase [DataOutputStream]:
- línea 26: el objeto [DataOutputStream] se construye alrededor de otro flujo de bytes, siguiendo el principio de los flujos anidados (el patrón de diseño “decorador”):
- [Path(binary).outputStream()] (el método de Java [Files.newOutputStream]) escribe un flujo de bytes en el archivo, que se crea, o se trunca si ya existe;
- [buffered()] le agrega un búfer, de modo que no accede al disco en cada escritura: es una función de extensión de Kotlin que devuelve un [BufferedOutputStream(this)];
- [DataOutputStream] agrega métodos para escribir tipos de datos básicos;
- Líneas 62–63: las operaciones de escritura. La clase [DataOutputStream] tiene un método por cada tipo de dato simple: [writeInt], [writeDouble], [writeLong], [writeBoolean], [writeUTF] para una cadena…;
- líneas 25–27: los tres archivos se abren mediante tres llamadas anidadas a
*[use]: Kotlin no tiene un equivalente de la instrucción*[try]de Java, que declara varios recursos separados por punto y coma. Cada [use] cierra su flujo al salir de su lambda: por lo tanto, los tres archivos se cierran en el orden inverso al de su apertura, incluso si se produce una excepción. Cerrar el flujo externo ([DataOutputStream]) cierra los flujos que contiene. El archivo de registro se escribe a través de un [Writer] ([writer()]) provisto de un búfer ([buffered()], que aquí devuelve un [BufferedWriter]); - línea 22: la desestructuración también se aplica a los arreglos: los tres primeros elementos de
*[args]* se almacenan en tres variables con nombres explícitos; - líneas 32–33: una función local (Capítulo 3), declarada dentro de la lambda, que escribe un mensaje de error en el archivo de registro. Tiene acceso a las variables circundantes ([logs], [lineNumber], [text]), lo que evita tener que repetir el comienzo del mensaje. [appendLine] es una función de extensión de Kotlin que escribe una cadena seguida de un salto de línea (["\n"], independientemente del sistema) en cualquier objeto [Appendable] y, por lo tanto, en cualquier
*[Writer]*; - Línea 35: el archivo de texto se lee línea por línea con [forEachLine], que es una extensión de [BufferedReader] ([Reader]). El cuerpo del bucle es una lambda: para pasar a la línea siguiente no se escribe [continue] sino [return@forEachLine] (líneas 39 y 45), un return con etiqueta que termina la ejecución de la lambda para la línea actual. Un simple [return] terminaría la función [main];
- línea 41: el separador es el carácter [:], rodeado de espacios cualesquiera, que se eliminan junto con él. La función de Kotlin [split] recibe aquí una expresión regular ([Regex], que se verá más adelante en este capítulo), escrita como una cadena sin procesar ["""..."""] en la que no es necesario duplicar la barra invertida. Atención: [split(":")] con una cadena dividiría según esa cadena tomada literalmente, y no según una expresión regular, a diferencia del método [split] de Java;
- línea 49: desempaquetado de una lista: sus dos elementos se almacenan en dos variables;
- Línea 55: la edad debe ser un entero positivo o cero. Mientras que el programa Java tenía que escribir un método que capturara la excepción [NumberFormatException], Kotlin usa [toIntOrNull], que devuelve [null] si la cadena no es un entero; el operador Elvis lo reemplaza entonces por -1, que es un valor no válido para una edad;
- líneas 20, 74, 77: [exitProcess(n)] (paquete [kotlin.system]) termina el programa con el código de salida n, que un script puede comprobar (0: éxito; es el código de salida de un programa cuya función [main] termina normalmente). Llama a [System.exit(n)] y tiene el tipo de retorno [Nothing]: el compilador sabe que las instrucciones que la siguen nunca se ejecutarán.
Los tres argumentos del programa se pasan mediante la opción [--args] de [gradlew run]. Los resultados son los siguientes:
El archivo de registro [logs.txt] contiene lo siguiente:
Sin argumentos, o con un archivo de texto inexistente:
El contenido del archivo binario [persons1.bin] puede mostrarse en hexadecimal con el comando de Linux [od] (en Windows, el comando de PowerShell [Format-Hex] produce una visualización similar):
Esto muestra cómo [DataOutputStream] escribe los datos:
- una cadena se escribe con [writeUTF], precedida por su longitud en bytes, en 2 bytes: 00 04, seguida de los 4 bytes de “paul” (70 61 75 6c). Los caracteres se codifican con una variante de UTF-8;
- un entero [Int] se escribe en 4 bytes, con el byte más significativo primero (el orden llamado “big-endian”, usado en los protocolos de red): 10 se escribe como 00 00 00 0a. Este formato es el mismo en todas las máquinas: un archivo escrito por [DataOutputStream] en Windows puede leerse en Linux;
- los datos se escriben de forma consecutiva, sin separadores ni saltos de línea: el archivo tiene 48 bytes (última línea: con la opción [-A d], [od] muestra las posiciones en decimal).
Para leer este archivo, es necesario conocer, por lo tanto, el orden y el tipo exactos de los datos escritos. Para cada método [writeXX] de [DataOutputStream], la clase [DataInputStream] tiene un método correspondiente [readXX]: [readUTF], [readInt], [readDouble]… Sin embargo, no puede indicar cuántos bytes quedan por leer: un archivo leído con [DataInputStream] debe comenzar con el número de registros que contiene, o bien leerse hasta que se produzca la excepción [EOFException], que señala el fin del flujo. Ahora bien, una excepción debe seguir siendo excepcional, y el fin de un archivo no lo es.
5.7.2. La clase RandomAccessFile
La clase [java.io.RandomAccessFile] lee y escribe en un archivo mediante acceso directo: se puede posicionar el cursor en cualquier punto del archivo antes de leer o escribir. Tiene los mismos métodos de lectura y escritura que [DataInputStream] y [DataOutputStream] (implementa las mismas interfaces, [DataInput] y [DataOutput]), y además:
método | función |
[RandomAccessFile(name: String, mode: String)] | abre el archivo para lectura ([mode] "r") o para lectura y escritura ("rw") |
[length(): Long] | el tamaño del archivo, en bytes |
[filePointer: Long] | la posición actual en el archivo (el método de Java [getFilePointer], visto desde Kotlin como una propiedad) |
[seek(pos: Long)] | se desplaza a la posición [pos] del archivo |
El programa [Files05.kt] realiza la operación inversa del programa anterior: lee el archivo binario para crear un archivo de texto. Si el archivo de texto resultante contiene los datos correctos del archivo original, sabremos que la conversión texto → binario → texto fue exitosa.
Veamos con más detalle las operaciones que involucran la clase [RandomAccessFile]:
- línea 24: el objeto [RandomAccessFile] se abre en modo de solo lectura (modo “r”). Implementa [Closeable]: [use] lo cerrará. El archivo de texto se abre con un segundo [use], anidado dentro del primero, y se cerrará antes que este;
- línea 28: la lectura continúa hasta que la posición actual en el archivo llega al final del archivo. Kotlin representa los métodos de Java con la forma [getXxx()] como propiedades [xxx]: se escribe [input.filePointer] y no [input.getFilePointer()]. Como [length] no tiene la forma [getXxx], sigue siendo un método;
- líneas 30–31: las operaciones de lectura, [readUTF] y [readInt]. Deben llamarse en el orden de las escrituras;
- línea 33: escritura de una línea en el archivo de texto;
- líneas 39–40: acceso directo: [seek] reposiciona el cursor al principio del archivo y se vuelve a leer el primer registro. Si todos los registros tuvieran el mismo tamaño, podríamos leer directamente el n-ésimo registro desplazándonos a la posición n × tamaño: este es el principio de los archivos de acceso directo, precursores de las bases de datos;
- línea 42: la excepción [EOFException] señala ahora una verdadera anomalía: un archivo que termina en medio de un registro. Como la excepción en sí no se usa, se nombra [_];
- línea 46: [RandomAccessFile], una subclase de [java.io], informa de un archivo inexistente mediante una [FileNotFoundException], cuyo mensaje —proporcionado por el sistema— contiene el nombre del archivo.
Ejecutemos el programa con el archivo [persons1.bin] generado anteriormente:
El contenido de [persons2.txt] es el siguiente:
Encontramos las 4 personas válidas del archivo [persons1.txt]. Con un archivo llamado [truncated.bin] formado por los primeros 33 bytes de [persons1.bin] (comando de Linux [head -c 33 persons1.bin > truncated.bin]), la lectura de la edad de Jacques falla:
Y con un archivo inexistente:
Java también tiene un mecanismo de serialización binaria de objetos: las clases [ObjectOutputStream] y [ObjectInputStream] escriben y leen objetos completos, siempre que su clase implemente la interfaz [java.io.Serializable]. Puede usarse desde Kotlin, pero está actualmente desaconsejado: la deserialización de datos provenientes de una fuente no confiable ha permitido numerosos ataques, ya que la deserialización puede ejecutar código elegido por el atacante. En su lugar se prefiere un formato basado en texto como JSON.
5.7.3. Serialización JSON con Jackson
Escribir y leer un archivo binario byte por byte es tedioso, y la más mínima discrepancia entre la escritura y la lectura produce resultados incorrectos. En general es preferible serializar los objetos: convertirlos automáticamente en una secuencia de caracteres y luego deserializarlos para reconstruirlos.
JSON (JavaScript Object Notation) es un formato basado en texto, legible por humanos y universal: es el formato de intercambio de los servicios web (Capítulo 13) y de muchos archivos de configuración. Un objeto se escribe entre llaves como pares “propiedad”: valor, y un arreglo se encierra entre corchetes.
Ni la biblioteca estándar de Java ni la de Kotlin pueden leer o escribir JSON. Se usa una biblioteca externa. Un programa Kotlin tiene tres opciones:
- Jackson, la biblioteca Java más utilizada, que Spring Boot usa de forma predeterminada. Su versión 3 (2025) cambió los paquetes: [tools.jackson.*] en lugar de [com.fasterxml.jackson.*] de la versión 2, que todavía se encuentra con frecuencia; sus anotaciones permanecen en el paquete [com.fasterxml.jackson.annotation]. Como cualquier biblioteca Java, puede usarse directamente desde Kotlin: es la que usamos aquí, igual que en el curso de Java;
- Jackson se complementa con el módulo [jackson-module-kotlin] ([tools.jackson.module:jackson-module-kotlin] para Jackson 3), que le enseña las particularidades de Kotlin: valores predeterminados de los parámetros, tipos que admiten nulos, clases [object] … Al final de esta sección veremos qué le falta a Jackson sin este módulo;
- kotlinx.serialization, la biblioteca de serialización de JetBrains, escrita para Kotlin: un complemento del compilador ([kotlin("plugin.serialization")]) genera, para cada clase anotada con [@Serializable], el código que la serializa, sin reflexión en tiempo de ejecución. Admite de forma natural los valores predeterminados y los tipos que admiten nulos, y también funciona fuera de la JVM (Kotlin Multiplatform). Es la opción natural para un proyecto puramente Kotlin; Jackson sigue siendo la opción para los proyectos Spring y los proyectos que mezclan Java y Kotlin.
Una biblioteca externa se declara en el archivo de compilación del proyecto (Capítulo 2). El proyecto Gradle [05-classes-kotlin] declara la dependencia de Jackson en su archivo [build.gradle.kts]:
Comentarios:
- Líneas 14–17: la dependencia de la biblioteca [jackson-databind]. Gradle la descarga del repositorio central (Maven Central, línea 11), junto con las bibliotecas de las que ella misma depende ([jackson-core] y [jackson-annotations]);
- línea 27: el compilador conserva en el bytecode los nombres de los parámetros de las funciones y de los constructores. Esto es esencial aquí: sin el módulo de Kotlin, Jackson crea una clase de datos llamando a su constructor principal, y es gracias a los nombres de sus parámetros que asocia cada uno con la propiedad JSON del mismo nombre. Esto equivale a la opción [-parameters] del compilador de Java;
- líneas 31–34: el programa ejecutado por [gradlew run] se especifica mediante la propiedad [main] de la línea de comandos ([-Pmain=...]);
- líneas 42–45: los programas lanzados por Gradle escriben su salida en UTF-8 para que los caracteres acentuados se muestren correctamente en Windows (Capítulo 2).
El objeto central de Jackson es [JsonMapper], que tiene dos métodos principales:
método | función |
[writeValueAsString(value: Any?): String] | devuelve el texto JSON que representa el objeto [value] |
[readValue(content: String, valueType: Class<T>): T] | reconstruye un objeto de tipo [T] a partir del texto JSON [content]; lanza una [JacksonException] si el texto es incorrecto. Una sobrecarga recibe un [TypeReference] en lugar de un [Class] |
El programa [Files06.kt] los utiliza:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 | |
Se ejecuta en la carpeta del proyecto, o desde el IDE:
Comentarios:
- Líneas 3–13: las clases de Jackson utilizadas. A diferencia del programa Java, que tenía que ser un proyecto Maven independiente, [Files06.kt] forma parte del proyecto Gradle del capítulo, igual que los demás: la dependencia de Jackson se declara para todo el proyecto;
- Línea 18: la clase de datos [Person] que se va a serializar. Jackson no reconoce Kotlin, pero ve lo que el compilador ha producido: una clase Java con métodos de acceso [getName], [getAge], [getHobbies] y un constructor de tres parámetros. Cada método de acceso devuelve una propiedad JSON con nombre ([getName] → [name]);
- línea 21: la anotación [@JsonProperty] establece el nombre de la propiedad JSON como [reference] en lugar de [code]. Cuando se coloca en un parámetro del constructor principal que declara una propiedad, la anotación podría aplicarse al parámetro, a la propiedad, al campo o al método de acceso: Kotlin 2.4 la aplica aquí al parámetro del constructor y al campo privado que almacena la propiedad (lo verificamos en el código compilado con el comando [javap -v]; las versiones anteriores de Kotlin la aplicaban solo al parámetro). Jackson, que asocia el parámetro, el campo y el método de acceso [getCode] a la misma propiedad, usa el nombre [reference] tanto para escribir como para leer. Se puede especificar el destino: [@param:JsonProperty], [@get:JsonProperty], [@field:JsonProperty];
- Líneas 40–41: un [JsonMapper] se crea mediante un constructor de objetos (builder): [JsonMapper.builder()] devuelve un objeto al que se pasan las opciones deseadas, y luego [build] crea el [JsonMapper]. Con las opciones predeterminadas, el texto se escribe en una sola línea y los caracteres acentuados se escriben tal cual (línea 1 de los resultados). [persons[1]] es la versión en Kotlin de [persons.get(1)];
- líneas 43–44: la opción [ESCAPE_NON_ASCII] indica al programa que escriba los caracteres no ASCII como secuencias de escape: [é] se convierte en [é]. El texto sigue siendo correcto, pero es difícil de leer; esto es útil cuando el texto JSON debe pasar por un sistema que solo reconoce ASCII;
- línea 47: la opción [INDENT_OUTPUT] produce un texto con sangría distribuido en varias líneas. Una lista se serializa como un arreglo JSON;
- líneas 49–52: el texto JSON se escribe en un archivo de texto con [writeText]y luego se vuelve a leer para mostrarlo: así es como hoy se reemplaza la serialización binaria;
- línea 57: la deserialización reconstruye la lista. Jackson crea los objetos [Person] llamando al constructor de la clase de datos, cuyos parámetros se asocian con las propiedades JSON del mismo nombre. Para una lista, hay que indicarle a Jackson el tipo de sus elementos. Sin embargo, la expresión [List<Person>::class.java] no existe: los genéricos se borran en tiempo de compilación (“type erasure”), en Kotlin igual que en Java, y en tiempo de ejecución solo existe una clase [List], sin ningún parámetro de tipo. El truco con [TypeReference] consiste en crear un objeto anónimo ([object : TypeReference<List<Person>>() {}]) de una clase derivada de [TypeReference<List<Person>>]: el tipo padre de una clase se conserva en el código compilado, y Jackson puede leerlo;
- líneas 59–60: el bucle desempaqueta cada persona a medida que se lee;
- línea 30: Kotlin permite escribir este truco una vez por todas. [readJson] es una función de extensión de [JsonMapper] e [inline], con un parámetro de tipo [reified] (Capítulo 4): su código se copia en cada llamada, con el tipo real en lugar de [T]. Por lo tanto, la llamada a [mapper.readJson<List<Person>>(text)] (línea 63) crea un objeto llamado [TypeReference<List<Person>>], y no [TypeReference<T>]. El módulo [jackson-module-kotlin] ofrece una función similar, [readValue<T>()], y una función [jacksonTypeRef<T>()];
- línea 64: para un arreglo, que es más sencillo, se pasa directamente la clase [Array<Person>::class.java] (el [Person[].class] de Java). La línea siguiente verifica que las dos listas leídas son iguales, en el sentido de la igualdad de las clases de datos;
- línea 68: serialización de un [Article]: la propiedad [reference] tiene el nombre especificado por la anotación. Un [BigDecimal] se escribe como un número JSON;
- Líneas 70–74: con la opción [ACCEPT_CASE_INSENSITIVE_PROPERTIES], Jackson ignora las mayúsculas y minúsculas en los nombres de las propiedades durante el análisis: [REFERENCE] y [Price] son aceptados. El texto JSON se escribe en una cadena sin procesar ["""..."""], donde las comillas no necesitan ir precedidas de una barra invertida;
- Líneas 76–82: un documento JSON no válido —en este caso, una cadena donde se espera un número— provoca una excepción derivada de [JacksonException], en concreto [InvalidFormatException]. En Jackson 3, estas excepciones derivan de [RuntimeException], mientras que en Jackson 2 derivaban de [IOException]; para Kotlin, que no tiene excepciones comprobadas, la diferencia no se nota. [originalMessage] devuelve el mensaje sin la información de ubicación, que [location] y [pathReference] proporcionan por separado: línea 1, columna 23, propiedad [age] de la clase [Person]. Kotlin trata los métodos Java [getOriginalMessage()], [getLocation()], [getLineNr()]… como propiedades.
La última parte del programa muestra lo que Jackson, sin el módulo de Kotlin, no reconoce de las clases de Kotlin. Lo verificamos con Jackson 3.1.5:
- línea 87: una propiedad JSON desconocida de la clase ([city]) se ignora. Este es un cambio de Jackson 3: la opción [DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES], que estaba habilitada de forma predeterminada en Jackson 2, está deshabilitada de forma predeterminada en Jackson 3; puede volver a habilitarse con [JsonMapper.builder().enable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)] si se desea que se rechace el documento;
- Línea 24: la clase [Subscriber] tiene valores predeterminados para [age] (18) y [hobbies] (una lista que contiene “reading”). Estos valores no los calcula el propio constructor, sino un segundo constructor sintético que el compilador agrega a la clase y que usan las llamadas escritas en Kotlin: Jackson, que llama directamente al constructor principal mediante reflexión, los ignora. Para una propiedad ausente del documento JSON, pasa al constructor el valor “vacío” del tipo: [null] para un objeto y, para un tipo primitivo como [Int]… un error, porque Jackson 3 habilita de forma predeterminada la opción [FAIL_ON_NULL_FOR_PRIMITIVES] (estaba deshabilitada en Jackson 2, que pasaba 0);
- Líneas 90–97: los cuatro documentos de prueba producen lo siguiente (líneas 27–30 de los resultados):
- un documento completo: el objeto se crea normalmente;
- sin [hobbies]: Jackson pasa [null] al parámetro [hobbies], que es del tipo no nulo [List<String>]. El constructor de Kotlin comprueba sus parámetros no nulos y lanza una [NullPointerException] (“Parameter specified as non-null is null”), que Jackson propaga como una [ValueInstantiationException]. El valor predeterminado [listOf("reading")] no se usó;
- sin [age]: [MismatchedInputException], no hay valor para el tipo primitivo [int]. El valor predeterminado 18 no se usó;
- con ["name": null]: la misma comprobación del constructor rechaza [null] para [name]. Este comportamiento es, en realidad, una buena noticia: Jackson no elude la seguridad de Kotlin respecto de [null] ;
- líneas 27, 100–105: una propiedad booleana cuyo nombre comienza con [is], como [isActive], tiene el método de acceso [isActive()] (Kotlin no lo llama [getIsActive]); Jackson, siguiendo las convenciones de JavaBeans, infiere una propiedad JSON [active]. Pero el parámetro del constructor se llama [isActive]: Jackson no puede encontrar esta propiedad en el documento que él mismo escribió, y la validación falla.
El módulo [jackson-module-kotlin] corrige estos tres problemas (uso de los valores predeterminados, propiedades [isXxx] que conservan su nombre, mensajes de error claros para [null]); kotlinx.serialization también los maneja correctamente. Sin ellos, conviene recordar la siguiente regla: cuando se usa Jackson solo, una clase de datos destinada a JSON no debe depender de sus valores predeterminados ni de nombres de propiedades que comiencen con [is]. Esto es lo que haremos en el resto del curso, donde nuestras clases JSON seguirán siendo simples.
Crear un [JsonMapper] es costoso, pero una vez creado es reutilizable y puede compartirse entre varios hilos: un programa suele crear solo uno, que se almacena en una constante (una propiedad de nivel superior o una propiedad de un [object]). Usaremos JSON en la aplicación de ejemplo al final del capítulo y, después, a lo largo de todo el curso.
5.8. Expresiones regulares
La biblioteca estándar de Kotlin proporciona la clase [kotlin.text.Regex], que permite el uso de expresiones regulares. Estas permiten validar el formato de una cadena. Por ejemplo, se puede verificar que una cadena que representa una fecha tenga efectivamente el formato dd/mm/aa. Para ello, se usa un patrón y se compara la cadena con ese patrón. En este ejemplo, d, m y a deben ser dígitos. El patrón de un formato de fecha válido es, por lo tanto, [\d\d/\d\d/\d\d], donde el símbolo [\d] representa un dígito. En la JVM, la clase [Regex] es un envoltorio de la clase [java.util.regex.Pattern] del JDK: la sintaxis de los patrones y el motor de búsqueda son exactamente los mismos que en Java; solo cambia la interfaz de programación. Los símbolos que pueden usarse en un patrón son los siguientes:
carácter | descripción |
[\] | marca el carácter siguiente como un carácter especial o literal. Por ejemplo, [n] corresponde al carácter n, [\n] corresponde a un carácter de salto de línea, [\\] corresponde a \, y [\(] corresponde a ( |
[^] | corresponde al comienzo de la cadena |
[$] | corresponde al final de la cadena |
[*] | coincide con el elemento anterior cero o más veces. Así, [zo*] coincide con z o zoo |
[+] | coincide con el elemento anterior una o más veces. Así, [zo+] coincide con "zoo", pero no con "z" |
[?] | coincide con el elemento anterior cero o una vez. Por ejemplo, [a?ve?] coincide con “ve” en “lever” |
[.] | coincide con cualquier carácter individual, excepto un carácter de salto de línea |
[(pattern)] | busca el patrón y almacena la coincidencia (un grupo). La subcadena coincidente puede extraerse del resultado mediante la propiedad [groupValues] o [groups]. Para encontrar coincidencias con caracteres entre paréntesis, use [\(] o [\)] |
[x|y] | coincide con x o con y. Por ejemplo, [z|foot] coincide con z o foot; [(z|f)oo] coincide con zoo o foo |
[{n}] | n es un entero no negativo. Coincide exactamente n veces con el elemento anterior. Por ejemplo, [o{2}] no coincide con la o de Bob, pero sí con las dos primeras o de fooooot |
[{n,}] | coincide con el elemento anterior al menos n veces. Por ejemplo, [o{2,}] no coincide con la 'o' de 'Bob', pero sí con todas las 'o' de 'fooooot'. [o{1,}] equivale a [o+], y [o{0,}] equivale a [o*] |
[{n,m}] | coincide con el elemento anterior al menos n veces y como máximo m veces. Por ejemplo, [o{1,3}] coincide con las tres primeras “o” de “foooooot”; [o{0,1}] equivale a [o?] |
[[xyz]] | conjunto de caracteres: coincide con uno de los caracteres especificados. Por ejemplo, [[abc]] coincide con la letra “a” de “plat” |
[[^xyz]] | conjunto de caracteres negativo: coincide con cualquier carácter que no figure en la lista. Por ejemplo, [[^abc]] coincide con "p" en "plat" |
[[a-z]] | rango de caracteres: coincide con cualquier carácter del rango especificado, en este caso una letra minúscula sin acento |
[[^m-z]] | rango de caracteres negativo: corresponde a cualquier carácter que no esté entre m y z |
[\b] | coincide con un límite de palabra, es decir, la posición entre un carácter de palabra y un carácter que no es de palabra. Por ejemplo, [er\b] coincide con "er" en "lever", pero no con "er" en "verb" |
[\B] | corresponde a una posición que no es un límite de palabra. [en*t\B] corresponde a “ent” en “entry” |
[\d] | coincide con un dígito; equivale a [[0-9]] |
[\D] | corresponde a un carácter que no es un dígito |
[\f], [\n], [\r], [\t] | corresponden a los caracteres de salto de página, nueva línea, retorno de carro y tabulación, respectivamente |
[\s] | corresponde a cualquier espacio en blanco: espacio, tabulación, salto de página, salto de línea… Equivale a [[ \t\n\x0B\f\r]] |
[\S] | coincide con cualquier carácter que no sea un espacio en blanco |
[\w] | coincide con cualquier carácter de palabra: de forma predeterminada, una letra sin acento, un dígito o un guion bajo; equivale a [[a-zA-Z_0-9]]. Con la opción [(?U)] (véase más adelante), también reconoce las letras con acento |
[\W] | coincide con cualquier carácter que no sea un carácter de palabra |
[\num] | num es un entero positivo: se refiere al grupo número num. Por ejemplo, [(.)\1] corresponde a dos caracteres idénticos consecutivos |
[\xnn], [\unnnn] | corresponde al carácter hexadecimal nn (2 dígitos) o nnnn (4 dígitos). Por ejemplo, [\x41] corresponde a A |
Un elemento de un patrón puede aparecer una vez o varias veces. Veamos algunos ejemplos con el símbolo [\d], que representa un solo dígito:
patrón | Significado |
[\d] | un dígito |
[\d?] | 0 o 1 dígito |
[\d*] | 0 o más dígitos |
[\d+] | 1 o más dígitos |
[\d{2}] | 2 dígitos |
[\d{3,}] | Al menos 3 dígitos |
[\d{5,7}] | entre 5 y 7 dígitos |
Imaginemos ahora un modelo capaz de describir el formato esperado de una cadena:
cadena objetivo | patrón |
una fecha en formato dd/mm/aa | [\d{2}/\d{2}/\d{2}] |
una hora en formato hh:mm:ss | [\d{2}:\d{2}:\d{2}] |
un entero sin signo | [\d+] |
una secuencia de espacios, que puede estar vacía | [\s*] |
un entero sin signo que puede estar precedido o seguido de espacios | [\s*\d+\s*] |
un entero que puede tener signo y estar precedido o seguido de espacios | [\s*[+-]?\s*\d+\s*] |
un número real sin signo que puede estar precedido o seguido de espacios | [\s*\d+(\.\d*)?\s*] |
un número real que puede tener signo y estar precedido o seguido de espacios | [\s*[+-]?\s*\d+(\.\d*)?\s*] |
una cadena que contiene la palabra "just" | [\bjust\b] |
Observe que, dentro de corchetes, el carácter [|] no tiene ningún significado especial: el patrón [[+|-]], que a veces se usa para el signo, también acepta el carácter | antes de un número. Del mismo modo, el punto decimal debe escaparse, [\.]: un punto sin escapar coincide con cualquier carácter.
Se puede especificar dónde buscar el patrón en la cadena:
patrón | significado |
[^pattern] | El patrón está al comienzo de la cadena |
[pattern$] | El patrón está al final de la cadena |
[^pattern$] | El patrón está al comienzo y al final de la cadena |
[pattern] | El patrón se busca en cualquier parte de la cadena, comenzando desde el principio de la cadena |
cadena de búsqueda | patrón |
una cadena que termina con un signo de exclamación | [!$] |
una cadena que termina con un punto | [\.$] |
una cadena que comienza con la secuencia // | [^//] |
una cadena formada por una sola palabra, posiblemente precedida o seguida de espacios | [^\s*\w+\s*$] |
una cadena formada exactamente por dos palabras, posiblemente precedidas o seguidas de espacios | [^\s*\w+\s+\w+\s*$] |
una cadena que contiene la palabra "secret" | [\bsecret\b] |
Se pueden “extraer” subconjuntos de un patrón. Así, no solo podemos verificar que una cadena coincide con un patrón determinado, sino también extraer de esa cadena los elementos que corresponden a los subconjuntos del patrón que se han encerrado entre paréntesis. Por ejemplo, si analizamos una cadena que contiene una fecha en formato dd/mm/aa y también queremos extraer los elementos dd, mm y aa de esa fecha, usaremos el patrón [(\d\d)/(\d\d)/(\d\d)].
Solo queda escribir el patrón en el código. En una cadena normal, delimitada por comillas dobles a cada lado, el carácter [\] es, como en Java, un carácter de escape: cada [\] del patrón debe duplicarse, y el patrón [\d+] se escribe como ["\\d+"]. Kotlin ofrece una solución mejor: las cadenas sin procesar (raw strings), delimitadas por comillas triples —que ya hemos visto—, donde [\] es un carácter normal. El patrón se escribe tal cual: ["""\d+"""], y el patrón [\\], que representa el carácter \, se escribe como ["""\\"""] en lugar de ["\\\\"]. Esta es la práctica habitual en Kotlin, que seguiremos. Una advertencia: en una cadena sin procesar, el carácter [$] seguido de un identificador o de una llave introduce una plantilla. El [$] al final de la cadena, seguido de comillas, no plantea ningún problema; para los demás casos, Kotlin 2.2 introdujo las cadenas de interpolación de “varios signos de dólar” (multi-dollar), que veremos en el programa [Regex03.kt]. El editor facilita la lectura: IntelliJ IDEA reconoce las cadenas pasadas a [Regex] o a [toRegex], las resalta como expresiones regulares y permite probarlas (Alt+Enter, Check RegExp).
5.8.1. Comprobar si una cadena coincide con un patrón dado
Un patrón se compila primero en un objeto [Regex], que luego proporciona las funciones de búsqueda. Mientras que Java usa un objeto intermedio [Matcher] para almacenar el estado de una búsqueda, Kotlin devuelve los resultados directamente:
función | función |
[Regex(pattern: String)] | compila el patrón [pattern]; lanza una excepción [PatternSyntaxException] si el patrón es incorrecto |
[Regex(pattern, option)], [Regex(pattern, options)] | igual que lo anterior, con una opción [RegexOption] o un conjunto de opciones [Set<RegexOption>] (véase más adelante) |
[String.toRegex()] | Función de extensión: ["""\d+""".toRegex()] equivale a [Regex("""\d+""")] |
[containsMatchIn(input)] | devuelve [true] si la cadena [input] contiene una ocurrencia del patrón |
[matches(input)] | devuelve [true] si la cadena completa coincide con el patrón |
[CharSequence.matches(regex)] | Función de extensión infija de [String]: ["18/05/97" matches date] |
[toPattern()] | devuelve el objeto [java.util.regex.Pattern] envuelto por el objeto [Regex] |
El programa [Regex01.kt] es el siguiente:
Resultados:
Comentarios:
- Línea 6: el patrón es un entero sin signo, posiblemente rodeado de espacios, que ocupa toda la cadena (anclas [^] y [$]). Gracias a la cadena sin procesar, las barras [\] no se duplican: el patrón se escribe exactamente como aparece en los resultados;
- línea 7: el patrón se compila con el constructor de la clase [Regex];
- línea 10: [containsMatchIn] busca el patrón en la cadena. La cadena “123a”, rodeada de espacios, no coincide con el patrón: el carácter “a” no puede ser un dígito ni un espacio. Sin las anclas [^] y [$], la cadena sí coincidiría, ya que contiene un número. Es el equivalente de [regex1.matcher(sample).find()] en Java;
- línea 17: la función de extensión [toRegex] de [String] es otra forma de compilar un patrón;
- líneas 18–19: la diferencia entre [containsMatchIn], que busca el patrón dentro de la cadena, y [matches], que exige que la cadena completa coincida con el patrón, como si estuviera delimitada por [^] y [$];
- Líneas 21–23: la función de extensión [matches] de [String] recibe un objeto [Regex]; está declarada como [infix] y puede escribirse sin punto ni paréntesis (línea 22). A diferencia de Java, Kotlin no ofrece una función [matches(String)] que reciba el patrón como cadena y lo compile en cada llamada: el compilador rechaza la llamada ["5/1/01".matches("\\d{2}")] ([argument type mismatch: actual type is 'String', but 'Regex' was expected]). El patrón debe compilarse explícitamente, lo que incentiva a hacerlo una sola vez;
- Líneas 25–26: el objeto
[Regex]envuelve un objeto[java.util.regex.Pattern]*, que devuelve la función*[toPattern]. Todo el código Java de laAPIsigue siendo, así, accesible; a la inversa, la función de extensión [toRegex] de [Pattern] transforma un [Pattern] en un [Regex]. Lo usaremos en el programa [Regex06.kt].
5.8.2. Encontrar todas las ocurrencias de un patrón en una cadena
La función [find] devuelve la primera ocurrencia del patrón en una cadena, o [null] si no hay ninguna. La función [findAll] devuelve todas las ocurrencias como una secuencia ([Sequence], evaluada de forma diferida: cada ocurrencia se busca solo cuando se solicita). Una ocurrencia es un objeto [MatchResult], que proporciona información sobre el elemento encontrado:
- [value]: el texto de la ocurrencia, es decir, un elemento que coincide con el patrón;
- [range]: el rango [IntRange] de las posiciones del elemento en la cadena examinada; [range.first] es la posición donde se encontró el elemento, y [range.last] es la posición de su último carácter;
- [next()]: la siguiente ocurrencia, o [null] si no hay más.
El programa [Regex02.kt] es el siguiente:
Resultados:
Comentarios:
- Línea 5: el patrón buscado es una secuencia de dígitos;
- línea 7: la cadena en la que se busca este patrón;
- Líneas 10–15: el bucle [for] recorre la secuencia de ocurrencias devuelta por [findAll]. Se muestra cada ocurrencia y su posición. No hay ni un objeto [Matcher] ni llamadas repetidas a [find], como en Java;
- líneas 17–20: el mismo recorrido paso a paso: [find] devuelve la primera ocurrencia, de tipo [MatchResult?], y [next] devuelve la siguiente, hasta llegar a [null]. Dentro del bucle, el compilador sabe que [result] no es [null] (conversión inteligente de tipos, Capítulo 4). La visualización de [range] muestra los rangos de posiciones: 2..4 para 123;
- línea 24: la secuencia de ocurrencias se presta a todas las operaciones de secuencias; aquí, sumamos los números encontrados con [sumOf]. En Java, hay que usar el método [results] de [Matcher], que devuelve un flujo de la API Stream;
- Línea 26: el número de ocurrencias del patrón [[aeiouy]], que denota una vocal, es el número de elementos de la secuencia, devuelto por [count].
5.8.3. Recuperar partes de un patrón
Como se indicó, las partes de un patrón encerradas entre paréntesis se almacenan: son los grupos. Un objeto [MatchResult] los proporciona de varias maneras:
- [groups]: la colección de grupos, de tipo [MatchGroupCollection]. Su elemento n.º 0 es la ocurrencia completa; los elementos siguientes son los grupos n.º 1, n.º 2, … Cada grupo es un objeto [MatchGroup], que tiene las propiedades [value] (el texto capturado) y [range] (sus posiciones); es de tipo [MatchGroup?], ya que un grupo opcional, como [(\.\d+)?], puede no capturar nada;
- [groupValues]: la lista de textos capturados, de tipo [List<String>]; un grupo que no ha capturado nada se representa allí con una cadena vacía;
- [destructured]: los grupos n.º 1 y siguientes, listos para ser desestructurados: [val (h, m, s) = result.destructured].
El programa [Regex03.kt] los utiliza:
Resultados:
Comentarios:
- Línea 12: la cadena [sample4] se compara con el patrón [regex3]; [find] busca la primera ocurrencia del patrón y devuelve [null] si no se encuentra ninguna. La comprobación de la línea 13 determina entonces que [result] puede usarse sin precauciones;
- líneas 16–17: la colección [groups] se recorre mediante su índice: el elemento n.º 0 es la ocurrencia completa, y los elementos n.º 1 a n.º 3 son los grupos entre paréntesis. Como los elementos son de tipo [MatchGroup?], se accede a ellos con el operador [?.]; aquí, todos los grupos han capturado algún texto. [range.first] es la posición de este texto dentro de la cadena explorada;
- Línea 20: la propiedad [destructured] permite recuperar los grupos n.º 1, n.º 2 y n.º 3 en tres variables con una sola instrucción, mediante desestructuración (Capítulo 3). Es la forma más concisa de procesar un patrón cuando se conocen sus grupos;
- línea 27: un grupo puede nombrarse con la sintaxis [(?<name>...)]. Aquí, el patrón reconoce una fecha en formato d/m/aaaa, con día y mes de uno o dos dígitos;
- líneas 32–34: un grupo con nombre se designa por su nombre en lugar de por su número, mediante el operador de indexación [groups]: el código es más legible y no depende del orden de los paréntesis. El resultado es de tipo [MatchGroup?] (un nombre desconocido provoca una excepción [IllegalArgumentException]; un grupo que no ha capturado nada produce [null]); aquí, los tres grupos siempre capturan texto cuando se encuentra el patrón, y el operador [!!] expresa esta certeza;
- líneas 35–36: la clase [java.time.LocalDate] representa una fecha sin hora. Se muestra con el patrón [EEEE d MMMM yyyy]: el día de la semana aparece en inglés. Kotlin usa directamente las clases [java.time] y el JDK;
- línea 41: la función [replace] reemplaza cada ocurrencia del patrón por una cadena en la que [${name}] (o [$1], [$2]… para los grupos numerados) designa el valor de un grupo. Así, las fechas se reformatean al formato año-mes-día. Pero en Kotlin, [${year}] en una cadena es una plantilla, que insertaría el valor de una variable [year]. Podríamos escribir ["\${year}-\${month}-\${day}"]. Aquí la cadena se escribe con la interpolación con varios signos de dólar de Kotlin 2.2: en una cadena precedida por [$$], una plantilla se escribe como [$${...}], y el carácter aislado [$] es un carácter normal. Con
***[$$$]***, se necesitarían tres, y así sucesivamente; - líneas 44–46: una variante de
*[replace]recibe una lambda (Capítulo 7) que calcula el texto de reemplazo a partir de cada ocurrencia, de la forma*[MatchResult]. Escrita después de los paréntesis, según la convención de Kotlin para el último parámetro de una función, la lambda recupera los grupos mediante desestructuración, construye la fecha y devuelve su forma normalizada ISO 8601, que produce la función [toString] de [LocalDate]: los días y los meses siempre tienen dos dígitos. Equivale al método*[replaceAll]de*[Matcher], que recibe una función (Java 9); - Líneas 50–51: la función [matchEntire], como [matches], exige que toda la cadena coincida con el patrón, pero devuelve el resultado de la comparación ([MatchResult]), o [null] si la comparación falla: es la función que se debe usar para comprobar una cadena y extraer partes de ella. Aquí se muestra la propiedad [groupValues] del resultado: la ocurrencia completa, seguida del valor de cada grupo.
5.8.4. Un programa de aprendizaje
Encontrar la expresión regular que verifica si una cadena coincide con cierto patrón puede ser a veces un verdadero reto. El programa [Regex04.kt] permite practicar. Recibe como entrada un patrón y una cadena, e indica si la cadena coincide o no con el patrón.
Comentarios:
- Líneas 15–19: compilación del patrón ingresado por teclado. Un patrón incorrecto provoca una excepción [java.util.regex.PatternSyntaxException]: la clase [Regex] deja pasar la excepción de la clase [Pattern] que envuelve. Sus propiedades [description] y [index] (los métodos Java [getDescription] y [getIndex], tratados como propiedades por Kotlin) proporcionan la descripción del error y su posición en el patrón. Su mensaje completo, la propiedad [message], abarca varias líneas y muestra el patrón con un marcador debajo del error. Observe que [try] es una expresión (Capítulo 3): su valor es el del bloque [try], el objeto [Regex], o el del bloque [catch]. Este bloque termina con [continue], una expresión de tipo [Nothing] que nunca devuelve un valor: el compilador infiere que [regex] es de tipo [Regex];
- líneas 28–30: la búsqueda no se realiza directamente sobre la cadena escrita, sino sobre un objeto [TimeLimitedString] (líneas 55–69), que limita la duración de la búsqueda a un segundo: si la búsqueda tarda más, se lanza una excepción [TimeoutExceededException] que se captura en la línea 40. Veremos más adelante por qué esto es útil y cómo funciona. El límite de tiempo se calcula con las clases de [kotlin.time] de la biblioteca estándar: [TimeSource.Monotonic.markNow()] es la hora actual, medida por un reloj monótono (insensible a los cambios de la hora del sistema), y [1.seconds] es una duración [Duration], escrita mediante una propiedad de extensión de [Int];
- líneas 35–36: para cada coincidencia, se muestran los grupos n.º 1 y siguientes, si los hay: [drop(1)] excluye el elemento n.º 0 de la colección [groups], la ocurrencia completa;
- línea 40: el nombre [_] indica que la excepción interceptada no se utiliza;
- líneas 48–50: a diferencia de los programas anteriores, la línea ingresada no se despoja de sus espacios; estos pueden formar parte del patrón o de la cadena que se va a probar. Al final del flujo de entrada, [readlnOrNull] devuelve [null], que se reemplaza por una cadena vacía, lo que termina el programa.
A continuación se muestra un ejemplo del programa en acción (la entrada, redirigida desde un archivo, se ha vuelto a insertar después de los mensajes de solicitud):
Los patrones [^\s*\d+\s*$] y [^\s*(\d+)\s*$] muestran la utilidad de los grupos: el primero reconoce la cadena “1456” precedida de tres espacios, incluidos los espacios; el segundo permite además extraer el número sin los espacios. Los patrones [^(a+)+$] y [^(a+)+\1$] se examinan más adelante. El último patrón, que es incorrecto, se rechaza: le falta un paréntesis de cierre (“Unclosed group”), que el motor detecta en la posición 4, al final del patrón. El mensaje de la excepción, generado por el JDK, está en inglés.
5.8.5. La función split
Ya hemos visto la función [split] de la clase [String]. La clase [Regex] tiene la misma función, que utiliza el patrón ya compilado:
función | función |
[split(input, limit = 0)] | La cadena [input] se divide en campos, cada uno separado por un delimitador que corresponde al patrón; devuelve una lista [List<String>]. Si [limit] es positivo, establece el número máximo de campos |
[splitToSequence(input)] | Igual que la anterior, pero los campos se devuelven como una secuencia, evaluada de forma diferida |
[CharSequence.split(regex)] | función de extensión de [String]: [line.split(separator)] equivale a [separator.split(line)] |
Supongamos, por ejemplo, que un archivo de texto contiene líneas de la forma campo1, campo2, ..., campon. Los campos están separados por una coma, pero la coma puede ir precedida o seguida de espacios. El patrón [\s*,\s*] describe exactamente este separador, como muestra el programa [Regex05.kt]:
Resultados:
Comentarios:
- línea 7: el separador: una coma precedida y seguida de cualquier cantidad de espacios. Los espacios se eliminan junto con el separador. Una vez compilado, el patrón puede dividir tantas líneas como se desee sin necesidad de recompilarse: este es el método para dividir todas las líneas de un archivo;
- línea 9: el resultado de [split] es una lista, recorrida mediante sus índices con [forEachIndexed];
- línea 11: un separador que puede adoptar varias formas: un punto y coma o una barra vertical ([[;|]]), o ([|]) una secuencia de espacios ([\s+]). El patrón se pasa a la función [split] de [String] en forma de un objeto [Regex];
- Línea 14: observe que esta es una diferencia importante con Java. Cuando la función de Kotlin [split] recibe una cadena ([String]), la trata como un separador literal, no como un patrón: ["1.5.2".split(".")] divide la cadena según el carácter punto y devuelve [[1, 5, 2]]. En Java, el método [split] de [String] siempre interpreta su parámetro como una expresión regular, en la que el punto coincide con cualquier carácter: ["1.5.2".split(".")] devuelve un arreglo vacío, una trampa clásica. En Kotlin no hay lugar para el error: un patrón se pasa como un objeto [Regex], y una cadena siempre se toma literalmente;
- Línea 16: otra diferencia con Java: los campos vacíos al final de la cadena se conservan. La cadena “a,b,,” produce cuatro campos, de los cuales los dos últimos están vacíos, mientras que el método [split] de Java devuelve solo dos. Así, el número de campos de una línea mal formada nunca se distorsiona: una línea que termina con un separador adicional tiene un campo de más;
- línea 17: el parámetro [limit] limita el número de campos; el último campo contiene entonces el resto de la cadena;
- línea 18: [splitToSequence] devuelve los campos como una secuencia, a la que aquí se aplica la operación [map] antes de convertirla en una lista. Los campos se dividen solo según se necesitan, lo que es útil para una cadena muy larga de la que solo se usan los primeros campos. Equivale al método [splitAsStream] de [Pattern].
5.8.6. Patrones precompilados, opciones y búsquedas que tardan demasiado
A diferencia de otras plataformas, ni Java ni Kotlin disponen de un mecanismo que genere el código de una búsqueda con expresión regular en el momento de compilar el programa: un patrón siempre se analiza en tiempo de ejecución mediante el constructor de [Regex]. Esta compilación tiene un costo; por lo tanto, la buena práctica es compilar cada patrón conocido una sola vez y de una vez por todas de antemano y almacenar el objeto [Regex] en una propiedad de solo lectura ([val]), ya sea en el nivel superior o dentro de un *[companion object], como hace el programa *[Regex06.kt] . En particular, evite escribir ["""\\d+""".toRegex()] dentro de un bucle: el patrón se recompilaría en cada iteración. Un objeto [Regex] es inmutable y puede ser utilizado simultáneamente por varios hilos: a diferencia del objeto [Matcher] de Java, no almacena el estado de una búsqueda, ya que cada búsqueda produce sus propios resultados.
Resultados:
Comentarios:
- Líneas 12–16: los patrones del programa se compilan una sola vez y se almacenan en propiedades de nivel superior, escritas en mayúsculas como es costumbre para las constantes. No pueden declararse [const]: solo pueden declararse así los valores de tipos básicos y las cadenas, conocidos en tiempo de compilación; un objeto [Regex] se crea en tiempo de ejecución, la primera vez que se usa el archivo;
- Líneas 20–23: las propiedades se utilizan de la misma manera que los objetos [Regex] de los programas anteriores. La función [let], llamada mediante el operador [?.], ejecuta su bloque solo si [find] ha encontrado una coincidencia; la línea 22 recupera los tres grupos con nombre en una sola instrucción, mediante una proyección [map] seguida de una desestructuración;
- Línea 14: el segundo parámetro del constructor de [Regex] es una opción de la enumeración [RegexOption]. [IGNORE_CASE] no distingue entre mayúsculas y minúsculas: “YES” y “Yes” coinciden con el patrón (línea 3 de los resultados). Se especifican varias opciones como un conjunto: [Regex(pattern, setOf(RegexOption.MULTILINE, RegexOption.IGNORE_CASE))], mientras que Java combina enteros con el operador [|];
- líneas 31–33: en la JVM, Kotlin siempre agrega la opción [UNICODE_CASE] de Java a la opción [IGNORE_CASE]; también se ignora la distinción de mayúsculas y minúsculas en las letras acentuadas: “ÉCLAIR” corresponde a “éclair” (línea 4 de los resultados). En Java, [CASE_INSENSITIVE] por sí sola no lo haría;
- líneas 35–36: [MULTILINE] hace coincidir [^] y [$] con el comienzo y el final de cada línea de la cadena, en lugar de solo con el comienzo y el final de la cadena misma. Sin embargo, con las opciones predeterminadas, [\w] solo reconoce las letras sin acento: la línea “café: 3” no se reconoce (línea 5 de los resultados);
- línea 38: la enumeración [RegexOption] no incluye la opción de Java [UNICODE_CHARACTER_CLASS], que da a [\w], [\d], [\s] y [\b] sus significados Unicode. Esto se logra escribiendo [(?U)] al comienzo del patrón: las letras acentuadas se tratan entonces como caracteres de palabra (línea 6 de los resultados). Se recomienda usarla para todo texto en francés;
- líneas 40–41: otra solución es compilar el patrón con la clase Java [Pattern], que ofrece todas las opciones disponibles (combinadas aquí con el operador [or], el operador “o” bit a bit de Kotlin), y luego convertir el objeto [Pattern] en [Regex] mediante la función de extensión [toRegex] (línea 7 de los resultados). Las otras opciones de [RegexOption] son [DOT_MATCHES_ALL] ([.] también corresponde a un salto de línea), [COMMENTS] (los espacios del patrón se ignoran, lo que permite escribirlo en varias líneas, con comentarios, en una cadena sin procesar), [LITERAL] (el patrón es texto sin formato; véanse también [Regex.escape] y [Regex.fromLiteral]), [UNIX_LINES], y [CANON_EQ];
- línea 43: las opciones también pueden escribirse al comienzo del patrón: [(?i)] para [IGNORE_CASE], [(?m)] para [MULTILINE], [(?s)] para [DOT_MATCHES_ALL], [(?U)]…;
- Líneas 64–66: la función [display] recorre la secuencia de valores [destructured] de las ocurrencias y desestructura cada una directamente dentro del bucle [for]: [(name, value)] son los grupos 1 y 2.
El resto del programa aborda un problema de seguridad. Algunos patrones son patológicos: aplicados a ciertas cadenas, obligan al motor de expresiones regulares a probar una cantidad enorme de maneras de hacer coincidir la cadena con el patrón antes de llegar a una conclusión. El motor de Java —el que Kotlin usa en la JVM— emplea un procedimiento llamado “backtracking” (retroceso): cuando un intento falla, vuelve a la última elección realizada y prueba otra. El patrón [^(a+)+\1$] de la línea 16 es un ejemplo de ello: aplicado a una secuencia de “a” que termina con un carácter diferente, prueba todas las formas posibles de distribuir las “a” entre las repeticiones del grupo y su referencia hacia atrás [\1] antes de concluir que ha fallado, y el número de intentos se multiplica con cada “a” adicional. Esto se conoce como un retroceso catastrófico. Aplicado a cadenas ingresadas por el usuario, un patrón así constituye una vulnerabilidad de seguridad (conocida como ReDoS, “regular expression denial of service”): bastan unas pocas solicitudes para paralizar un servidor.
- Líneas 46–49: la duración de la búsqueda se mide con 10, 15 y 20
a. La función*[measureTimedValue]de*[kotlin.time]ejecuta el bloque que recibe y devuelve tanto su valor como su duración, un objeto [Duration], en forma de un objeto [TimedValue] que se desempaqueta. La duración aumenta muy rápidamente (líneas 9–11 de los resultados; las duraciones varían de una ejecución a otra y de una máquina a otra). Como el tiempo de ejecución se duplica aproximadamente con cadaaadicional, la búsqueda tardaría varios minutos con 30a; - líneas 51–56: ni la clase [Regex] ni la clase [Pattern] tienen una opción de tiempo de espera. Se usa una técnica estándar: la búsqueda se realiza en un objeto [TimeLimitedString] (líneas 72–85), que implementa la interfaz [CharSequence] aceptada por las funciones de [Regex]. El motor de expresiones regulares lee la cadena carácter por carácter mediante el método [charAt] de la interfaz Java [CharSequence], que corresponde al operador [get] en Kotlin: es este el que comprueba el tiempo y lanza una excepción [TimeoutExceededException] (línea 89) si el plazo —almacenado al crear el objeto— ha vencido. La búsqueda se abandona después de 100 ms;
- líneas 72–75: la clase
*[TimeLimitedString]tiene dos propiedades, el texto y el plazo, una marca de tiempo del reloj monótono de*[kotlin.time]([ValueTimeMark]), cuya función [hasPassedNow] indica si se ha superado. La cláusula [CharSequence by text] es una delegación: la clase implementa la interfaz [CharSequence] delegando todos los miembros que no redefine —en este caso, la propiedad [length]— al objeto [text]. El compilador genera las funciones que reenvían las llamadas; en Java, estas deben escribirse a mano. Los únicos miembros que se redefinen son el operador [get], que vigila el tiempo, y la función [subSequence], que devuelve un [TimeLimitedString] sujeto al mismo plazo. La función [toString], que es un miembro de [Any] pero no de la interfaz, no se delega: también se redefine; - línea 89: la excepción [TimeoutExceededException] deriva de [RuntimeException]. Como Kotlin no tiene excepciones comprobadas, cualquier excepción podría ser lanzada por [get]; derivar de [RuntimeException] sigue siendo la práctica habitual, y el código Java que llame a la clase la trataría como una excepción no comprobada. El campo [serialVersionUID] que se encuentra en las excepciones de Java no es necesario aquí: el compilador de Kotlin no advierte de su ausencia;
- Líneas 59–60: el entorno de ejecución de Java puede reconocer y manejar eficientemente los casos simples de repeticiones anidadas: el patrón [^(a+)+$], que es problemático con otros entornos de ejecución, se resuelve aquí de inmediato. Es la referencia hacia atrás [\1] la que impide esta optimización en el patrón de la línea 16. Las duraciones de tipo [Duration] se comparan con el operador [<].
Es importante tener en cuenta que hay que desconfiar de los patrones que contienen repeticiones anidadas ([(a+)+], [(\w+\s?)*]…) y limitar la duración de las búsquedas en cuanto el patrón o la cadena en la que se busca provengan del exterior del programa. Los cuantificadores posesivos del motor de Java ([a++], [a*+]), que impiden el retroceso dentro del elemento que repiten, también permiten escribir patrones seguros, siempre que se comprenda bien su significado.
5.9. Aplicación de ejemplo - V3
Retomaremos la aplicación estudiada en el Capítulo 3 (Versión 1) y en el Capítulo 4 (Versión 2). Recuerde que se trata de un ejercicio: la tabla de impuestos utilizada es la de 2004 (basada en los ingresos de 2003), que se ha mantenido sin cambios desde el curso original.
5.9.1. Datos en un archivo
En la Versión 2, el cálculo del impuesto se realizaba en la clase abstracta [AbstractTax], que reutilizamos aquí en el paquete [taxv3] del proyecto: como en Java, la Versión 3 es autónoma y no depende de las clases del Capítulo 4. Los tramos del impuesto los proporciona una propiedad abstracta —una lista de solo lectura— y la división se realiza con 16 dígitos significativos, lo que es más que suficiente:
La función [calculate] utiliza los tramos del impuesto devueltos por la propiedad abstracta [taxBrackets] (línea 10). La clase [AbstractTax] no sabe de dónde provienen estos tramos: corresponde a las clases derivadas proporcionarlos redefiniendo la propiedad. En la versión 2, la clase derivada [HardwiredTax] los codificaba directamente en su código. Los cálculos se realizan con números decimales exactos [java.math.BigDecimal] (Capítulo 3), con los que la biblioteca estándar de Kotlin facilita el trabajo:
- las funciones de extensión [toBigDecimal] de [Int] y [String] reemplazan a [BigDecimal.valueOf(...)] y [new BigDecimal(...)] (["0.72".toBigDecimal()], línea 21);
- los operadores [+], [-], [*] y [+=] están definidos para [BigDecimal] (son funciones de extensión [plus], [minus], [times], declaradas con [operator], Capítulo 4): la línea 26 se lee como la fórmula que calcula;
- [BigDecimal] implementa [Comparable<BigDecimal>]: se aplican los operadores de comparación ([quotient <= it.limit], línea 24) y llaman a [compareTo];
- Sin embargo, hay que tener cuidado con el operador [/]: llama a [divide(other, RoundingMode.HALF_EVEN)], que conserva el número de decimales del dividendo. Con dos enteros, el resultado se redondea al entero más cercano: [3.toBigDecimal() / 2.toBigDecimal()] es igual a 2, y [1.toBigDecimal() / 2.toBigDecimal()] es igual a 0. Por lo tanto, las dos divisiones de la función se implementan con el método [divide]: la división exacta entre 2 (línea 15), que lanzaría una excepción si el resultado no fuera un decimal finito, y la división con 16 dígitos significativos ([MathContext.DECIMAL64], línea 22);
- línea 24: la búsqueda del tramo se escribe con operaciones de colecciones: [dropLast(1)] excluye el último tramo, [firstOrNull] devuelve el primer tramo cuyo límite no es superado por el cociente familiar, o [null] si no hay ninguno, y el operador [?:] selecciona entonces el último tramo, [last()];
- [toInt] devuelve la parte entera del resultado (método [intValue] de [BigDecimal]).
Un tramo se representa mediante la clase de datos [TaxBracket]:
y el cálculo se describe mediante la interfaz [ITax], documentada aquí con un comentario KDoc —el equivalente en Kotlin de Javadoc (las mismas etiquetas, como [@param] y [@return]):
La nueva versión almacena los datos en un archivo, lo que permite modificar la tabla sin recompilar el programa. Escribimos dos clases nuevas derivadas de [AbstractTax]:
- [FileTax] lee los tramos de un archivo de texto [TaxData.txt];
- [JsonTax] los lee de un archivo JSON [TaxData.json].
El archivo de texto [TaxData.txt] contiene un tramo por línea, con el formato limit:coeffR:coeffN :
Los números del archivo se escriben con punto decimal. Un archivo de datos no debe depender del idioma de la máquina que lo lee: un archivo escrito con comas decimales e interpretado según las reglas del francés ([NumberFormat.getInstance(Locale.FRANCE)]) sería rechazado o, peor aún, mal interpretado en una máquina configurada en inglés. La función [toBigDecimal] de [String], como [toDouble], siempre espera un punto decimal, sea cual sea el idioma de la máquina. Esta es también la convención de JSON y de la mayoría de los formatos de datos.
El archivo [TaxData.json] contiene los mismos datos, en forma de un arreglo JSON de objetos:
5.9.2. Errores
El procesamiento de estos archivos puede fallar por un archivo inexistente, una línea mal formada, un número incorrecto, etc. Creamos una clase de excepción especial para informar de estos errores, [TaxException]. También se usará para otras fuentes de datos (aquí el archivo JSON y, más adelante, las bases de datos). Lleva un código de error:
Comentarios:
- Línea 6: la clase completa cabe en su encabezado. El constructor principal recibe el mensaje, el código y la causa del error; el código se convierte en una propiedad de solo lectura ([val]), mientras que el mensaje y la causa, que son simples parámetros, se pasan al constructor de la clase padre
*[RuntimeException]*, que los pone a disposición mediante las propiedades*[message]* y*[cause]*; - el parámetro [cause], la excepción que causó el error, tiene un valor predeterminado, [null]: un único constructor reemplaza a los dos constructores de la versión Java; [TaxException(message, code)] y [TaxException(message, code, e)] se definen con el mismo constructor. Las versiones posteriores de la aplicación adoptarán esta excepción, que lleva un código entero, con un constructor ligeramente distinto (Capítulo 6);
- Línea 7: la clase extiende [RuntimeException]. Como Kotlin no tiene excepciones comprobadas (Capítulo 3), la elección de la clase padre no impone aquí ninguna restricción; sin embargo, para el código Java que utilice la clase, [TaxException] será una excepción no comprobada, que es el comportamiento buscado, como veremos. El campo [serialVersionUID] de la versión Java no es necesario: el compilador de Kotlin no emite ninguna advertencia al respecto.
Los códigos de error posibles se definen mediante una enumeración:
Comentarios:
- líneas 7–12: códigos de error posibles:
- [ACCESS]: error al acceder al archivo de datos;
- [LINE]: línea que no tiene los tres campos esperados, o archivo que no contiene ningún tramo;
- [FIELD1], [FIELD2], [FIELD3]: el campo 1, 2 o 3 de una línea es incorrecto;
- [JSON]: el documento JSON es incorrecto;
- línea 6: un enum de Kotlin ([enum class], capítulo 3) puede tener propiedades, declaradas en su constructor primario, y funciones. Cada constante se construye con su valor entero, entre paréntesis; la lista de constantes termina con un punto y coma cuando le siguen otros miembros;
- Líneas 14–17: algunos errores pueden ocurrir simultáneamente; los tres campos de una línea pueden ser incorrectos. Por eso los valores de los códigos son potencias de 2: cada uno corresponde a un bit del entero. Un error en los campos 2 y 3 producirá el código [8 or 16] = 24 ([or] es el operador «OR» bit a bit en Kotlin). La función [decode], ubicada dentro del [companion object] de la enumeración para poder llamarla mediante [ErrorCode.decode(code)], realiza la operación inversa: convierte el conjunto de códigos presentes en un entero probando cada bit con el operador [and]. La propiedad [entries] (Kotlin 1.9) es la lista de constantes del enum, y [filterTo] coloca las que cumplen la condición en la colección que se le pasa, en este caso un [java.util.EnumSet] vacío. Esta colección, especializada en las constantes de un enum, las almacena internamente como los bits de un entero; su método [toString] muestra una combinación con el formato «[FIELD2, FIELD3]». Con la misma facilidad podríamos devolver un [Set<ErrorCode>] de Kotlin ([entries.filter { ... }.toSet()]), que se mostraría de la misma manera.
5.9.3. La clase FileTax
La clase [FileTax] proporciona los tramos leídos desde un archivo de texto:
Comentarios:
- línea 8: la clase [FileTax] deriva de la clase [AbstractTax], igual que la clase [HardwiredTax] en la versión 2. Su constructor primario recibe el nombre del archivo de texto que contiene los datos. El parámetro [fileName], declarado sin [val], no es una propiedad: solo se usa durante la construcción del objeto;
- líneas 10–16: dos expresiones regulares, compiladas una sola vez y almacenadas en el [companion object] de la clase, el equivalente en Kotlin de las constantes [private static final] de Java: el separador de campos de una línea limit:coeffR:coeffN (el carácter [:], precedido y seguido de cualquier cantidad de espacios), y un número positivo o cero, formado por dígitos seguidos opcionalmente de un punto y más dígitos. Las cadenas sin procesar (raw strings) evitan duplicar el [\]. La lista [FIELD_CODES] asocia un código de error a cada campo;
- línea 20: la propiedad que redefine la propiedad abstracta de [AbstractTax]. Se declara sin valor inicial: se inicializará en el bloque [init], donde el compilador exige que se le asigne un valor, y solo uno;
- líneas 22–43: el bloque [init] se ejecuta cuando se construye el objeto, de forma similar al cuerpo de un constructor de Java. Su función es llenar la lista [taxBrackets];
- línea 25: el nombre del archivo sin su ruta, que se usa en los mensajes de error. En efecto, el constructor puede recibir una ruta completa, que no es necesario mostrar al usuario. La función [Path] de [kotlin.io.path] crea el objeto [java.nio.file.Path]; [fileName] es el método de Java [getFileName] tratado como una propiedad;
- Líneas 26–33: lectura del archivo. La función de extensión [useLines] de [Path] abre el archivo (en UTF-8), pasa la secuencia de sus líneas a la lambda y luego cierra el archivo sin importar cómo se salga de la lambda, ya sea normalmente o mediante una excepción: es el equivalente a [try] con recursos de Java. Como la lectura de un archivo de texto es un proceso secuencial, el número de líneas no se conoce hasta el final; la secuencia se presta para el procesamiento de cadenas:
- [mapIndexed] asocia cada línea (con los espacios eliminados por [trim]) con su número (el índice comienza en 0, la numeración de líneas en 1), en forma de un par [number to line];
- [filter] elimina las líneas vacías; el par se desempaqueta en los parámetros de la lambda, [(_, line)], y el número innecesario se reemplaza por [_];
- [map] convierte cada línea en un tramo mediante la función [bracket];
- [toList] recorre la secuencia y almacena los tramos en una lista. Esta llamada debe hacerse dentro de la lambda: una secuencia se evalúa de forma diferida, y una secuencia devuelta tal cual por [useLines] se recorrería después de cerrado el archivo;
- el bloque [try] es una expresión: su valor es la lista de tramos, almacenada en la variable [brackets];
- líneas 35–37: los errores de acceso al archivo ([IOException] y sus variantes, como [NoSuchFileException] para un archivo inexistente, [AccessDeniedException] para permisos insuficientes o [MalformedInputException] para un archivo que no está en UTF-8) se encapsulan en una [TaxException] con el código [ACCESS], y la excepción original pasa a ser su causa. Las excepciones [TaxException] lanzadas por la función [bracket] no son excepciones [IOException]: esta cláusula [catch] no las intercepta y salen del constructor tal cual, aunque [useLines] igualmente cierra el archivo;
- líneas 40–43: se rechaza un archivo vacío; de lo contrario, la lista pasa a ser el valor de la propiedad [taxBrackets], que era el propósito del bloque [init];
- líneas 49–51: la función [bracket] analiza una línea. La línea se divide en campos mediante una expresión regular; si no hay tres campos, se lanza una excepción [TaxException] con el código [LINE] . Observe que [split] conserva en Kotlin los campos vacíos del final: una línea que termina con un separador adicional, «4962:0:0: », tiene cuatro campos y se rechaza, mientras que el método [split] de Java, que elimina los campos vacíos del final, la aceptaría;
- Líneas 54–58: validación de los tres campos. La función [zip] asocia cada código de error con el campo correspondiente, en forma de pares; [filter] conserva los campos que no coinciden con la plantilla [NUMBER], y [fold] acumula sus códigos mediante el operador [or], comenzando desde 0. Así, los errores se informan de forma conjunta. La función [matches] exige que todo el campo coincida con la plantilla [NUMBER]: sin signos, espacios ni comas. De este modo se rechazan los números negativos, con lo que los datos se validan al mismo tiempo que se verifican;
- líneas 61–62: los campos, ya validados, se convierten a [BigDecimal] mediante [toBigDecimal], con un punto decimal sin importar el idioma de la máquina; la lista de tres números se desempaqueta para construir el tramo.
Encapsular las excepciones de bajo nivel ([IOException]) dentro de una excepción específica de la aplicación ([TaxException]) permite que el código llamador maneje un solo tipo de excepción, sin importar el origen de los datos: un archivo de texto, un archivo JSON y, más adelante en el curso, una base de datos. En Java, esta es también la razón por la que [TaxException] es una excepción no verificada: una excepción verificada tendría que ser declarada por cada método por el que pasa, lo que ataría el código llamador a los detalles del origen de los datos. Kotlin, que no tiene excepciones verificadas, no impone esta elección, pero la encapsulación sigue siendo igual de importante: el código llamador no necesita conocer las excepciones relacionadas con archivos en la API.
5.9.4. La clase JsonTax
La clase [JsonTax] devuelve los tramos leídos desde un archivo JSON. Utiliza la biblioteca Jackson 3, que ya se ha declarado en el archivo [build.gradle.kts] del proyecto:
Comentarios:
- Línea 15: un único [JsonMapper], almacenado dentro del [companion object], se usa para todos los objetos [JsonTax]. Las propiedades JSON [limit], [coeffR] y [coeffN] se llaman igual que los parámetros del constructor de la clase de datos [TaxBracket]: no se necesitan anotaciones, porque el compilador conserva estos nombres en el código compilado (opción [javaParameters = true] en el archivo [build.gradle.kts]) y Jackson 3 puede leerlos;
- Líneas 29–32: lectura del archivo mediante la función de extensión [readText] de [Path]; un error de acceso se maneja como en [FileTax];
- línea 36: una sola instrucción convierte el texto JSON en un arreglo de tramos; [Array<TaxBracket>::class.java] es la clase de Java para el arreglo, equivalente a [TaxBracket[].class]. Jackson construye cada tramo llamando al constructor de la clase de datos y convierte los números JSON a [BigDecimal] sin ninguna pérdida de precisión. Dado que el método de Java [readValue] puede devolver [null] (para el documento JSON [null]), el resultado se almacena en una variable de tipo [Array<TaxBracket>?]: sin esta declaración, Kotlin le asignaría un tipo «de plataforma» y no sabría si ese tipo acepta [null];
- líneas 37–40: un documento no válido provoca una [JacksonException], encapsulada en una [TaxException] con el código [JSON]. El mensaje indica la ubicación del error, especificada por la propiedad [location] (método [getLocation]); el operador [?.] protege contra una posición desconocida;
- líneas 43–49: la deserialización verifica el formato del documento, no la validez de los datos: queda por verificar que haya al menos un tramo (el documento [null] o [[]] es un JSON válido), lo cual hace [isNullOrEmpty] en una sola prueba, y que no haya valores negativos, lo cual se hace con la operación [any], aplicada directamente al arreglo. Después de la primera prueba, el compilador sabe que [brackets] no es [null]. Por último, el arreglo se convierte en una lista mediante [toList];
- línea 18: la función que prueba un valor, escrita como una expresión.
La versión en Java también verificaba que no faltara ningún valor: una propiedad faltante en un objeto JSON asigna el valor [null] al componente correspondiente de un record. En Kotlin, esta verificación es innecesaria: las propiedades de [TaxBracket] son de tipo *[BigDecimal]*, no ***[BigDecimal?]. El compilador de Kotlin agrega una verificación por cada parámetro no nulo al comienzo del constructor de la clase: si Jackson le pasa [null], el constructor lanza una excepción, que Jackson propaga como una [JacksonException]. La seguridad con respecto a *[null] se extiende así a los objetos creados por una biblioteca de Java: un tramo incompleto no puede existir. Lo verificaremos más adelante.
Comparar las dos clases es instructivo: con un formato de datos estructurado y una biblioteca que lo entiende, analizar el archivo requiere casi nada de código. Observe que existe un módulo de Jackson específico para Kotlin, [jackson-module-kotlin], que tiene en cuenta los valores predeterminados de los parámetros y los tipos que aceptan valores nulos, y ofrece funciones como [mapper.readValue<Array<TaxBracket>>(json)], donde el tipo se especifica mediante un parámetro genérico ([reified], capítulo 4). JetBrains también ofrece su propia biblioteca de serialización, [kotlinx.serialization], que genera el código de serialización en tiempo de compilación mediante un plugin del compilador. Para una clase de datos tan simple como [TaxBracket], Jackson por sí solo es suficiente.
5.9.5. El programa principal
A diferencia de la versión en Java, que formaba parte de un proyecto Maven independiente, la versión 3 es un programa de varios archivos dentro del proyecto Gradle del capítulo, organizado en su propio paquete, [taxv3]. La parte relevante del proyecto tiene la siguiente estructura de directorios:
Los archivos de datos se colocan en el directorio raíz del proyecto, junto al archivo [build.gradle.kts]: este es el directorio actual del programa cuando se ejecuta con el comando [gradlew run] o al hacer clic en el triángulo verde en IntelliJ o IDEA. La biblioteca Jackson se declara en el archivo [build.gradle.kts] del proyecto, que utilizan todos los programas de este capítulo:
El programa principal es el archivo [Main.kt]; su clase JVM es [taxv3.MainKt]:
Comentarios:
- Líneas 9–13: el texto de ayuda, en una cadena sin procesar de la cual [trimIndent] elimina la sangría común y la primera línea, que está vacía. Como el resultado de una llamada a función no es una constante en tiempo de compilación, la propiedad no puede declararse como [const]: [const val SYNTAX = """...""".trimIndent()] es rechazado por el compilador ([const 'val' initializer must be a constant value]). En cambio, el indicador del bucle de entrada, un literal de cadena, sí es una constante [const val] (línea 16);
- línea 20: el separador de los parámetros ingresados, compilado una sola vez;
- línea 24: el nombre del archivo de datos se pasa como argumento; de manera predeterminada es [TaxData.txt]. [firstOrNull] devuelve el primer argumento, o [null] si no hay ninguno, en cuyo caso se reemplaza por el valor predeterminado mediante el operador [?:]. Con Gradle, los argumentos del programa se pasan mediante la opción [--args]: [gradlew -q run -Pmain=taxv3.MainKt --args="TaxData.json"];
- líneas 28–31: una expresión [when] (capítulo 3) selecciona la clase que se va a instanciar según la extensión del archivo, extraída del nombre mediante [substringAfterLast]. Las dos ramas devuelven objetos de tipos distintos, [JsonTax] y [FileTax], ambos de tipo [ITax], que es el tipo declarado de la variable [tax]. El resto del programa solo reconoce la interfaz [ITax] y desconoce de dónde provienen los datos;
- líneas 33–39: la creación del objeto puede lanzar una [TaxException], que se muestra antes de que el programa termine. El código se decodifica en un conjunto de [ErrorCode] para mostrarse en texto legible; la excepción original, si la hay, se indica mediante su tipo: [e.cause?.let { ... } ?: ""] construye el texto si la causa existe y devuelve una cadena vacía en caso contrario. La función [exitProcess] de la biblioteca estándar termina el programa; es de tipo [Nothing]: el compilador sabe que nunca devuelve el control y, por lo tanto, que la variable [tax] está inicializada después del bloque [try]. Se elimina la instrucción innecesaria [return], que seguía a [System.exit] en la versión en Java y que el compilador de Java exigía;
- líneas 43–75: el bucle de diálogo es el mismo que en la versión 2. La línea leída por [readlnOrNull] es [null] al final del flujo, y entonces se reemplaza por una cadena vacía (línea 46). El número de hijos y el salario se convierten mediante [toIntOrNull], que devuelve [null] si la cadena no es un entero, y [takeIf { it >= 0 }] también devuelve [null] para un entero negativo (líneas 63, 69): una sola prueba sobre [null] detecta ambos errores. La expresión se escribe directamente, sin la función [positiveInteger] de la versión 2 (ni la función [integer] de la versión en Java, que devolvía -1 en caso de error). Después de esta prueba, el compilador sabe que [nbChildren] y [salary] son de tipo [Int].
5.9.6. Ejecuciones
Con el archivo [TaxData.txt], de manera predeterminada (la entrada, redirigida desde un archivo, se reinsertó después de los indicadores):
Los valores son los mismos que en las versiones anteriores: 4282 euros para una pareja casada con 2 hijos, 2959 euros para una pareja casada con 3 hijos y 11 519 euros para una persona soltera sin hijos, con un salario anual de 60 000 euros. Las entradas incorrectas se señalan como en la versión 2.
Con el archivo [TaxData.json]:
Con un archivo [xx.txt] inexistente:
Con el siguiente archivo [TaxDataInvalid.txt], en el que la tercera línea usa una coma decimal:
Los campos 2 y 3 de la línea 3 se rechazan: el código de error es la combinación [[FIELD2, FIELD3]]. El campo 1 (14753), que no tiene parte decimal, es correcto.
Con el siguiente archivo, [TaxDataInvalid.json], en el que un coeficiente está escrito como cadena:
El mensaje de Jackson especifica el error con precisión: la cadena «0,068» no se puede convertir a [BigDecimal]. Jackson acepta una cadena donde se espera un número si contiene un número válido («0.068»); lo que se rechaza es la coma decimal. El error se ubica en la línea 3 del documento (ya que Jackson numera las líneas a partir de 1) y en la columna 30, al comienzo del valor incorrecto.
Por último, con el siguiente archivo, [TaxDataIncomplete.json], en el que falta la propiedad [coeffR] del segundo tramo:
Es la verificación que el compilador de Kotlin agrega al constructor de la clase de datos [TaxBracket] la que rechaza el valor [null] para el parámetro [coeffR] («Parameter specified as non-null is null»). Jackson informa el error como una excepción [ValueInstantiationException], derivada de [JacksonException], ubicada al final del objeto incompleto (línea 3, columna 37): el tramo incompleto nunca existió y no se escribió ninguna prueba para él.
5.10. Conclusión
Este capítulo ha presentado las clases y funciones de Kotlin que se utilizan en casi todos los programas:
- las cadenas inmutables [String], que se comparan con [==] (que llama a [equals]), sus numerosas funciones de extensión, [buildString] y [StringBuilder] para construirlas pieza por pieza, las plantillas de cadena, la función [format] y las cadenas sin procesar ([trimIndent], [trimMargin]);
- los arreglos ([Array], [IntArray]…) y sus funciones;
- las colecciones de Kotlin ([List], [Set], [Map]), que son de solo lectura o mutables ([MutableList], [MutableSet], [MutableMap]), se crean con [listOf], [mutableListOf], [mapOf]… y se basan en las colecciones del JDK, además de otras colecciones ([ArrayDeque], conjuntos y diccionarios ordenados…);
- las operaciones funcionales sobre colecciones ([filter], [map], [sortedBy], [groupBy], [associate], [fold], [partition], [zip]…) y las secuencias, incluidas sus versiones diferidas, con la posibilidad de seguir usando la API Stream de Java;
- los archivos de texto ([File], [Path], y las extensiones de [kotlin.io] y [kotlin.io.path]: [readLines], [useLines], [writeText]…), en UTF-8 de manera predeterminada, y los archivos binarios ([DataOutputStream], [DataInputStream], [RandomAccessFile]) y la serialización JSON con Jackson y clases de datos;
- las expresiones regulares de la clase [Regex], escritas como cadenas sin procesar, compiladas una sola vez y protegidas contra búsquedas excesivamente largas al procesar datos externos.
Cabe destacar especialmente cómo Kotlin aprovecha la plataforma Java: la biblioteca estándar de Kotlin no reemplaza al JDK, sino que lo extiende con funciones de extensión ([readLines], [toBigDecimal], [toRegex]…), operadores ([BigDecimal]) e interfaces de solo lectura, mientras que las clases de Java ([Path], [BigDecimal], [LocalDate], [Pattern], Jackson…) pueden usarse directamente.
La aplicación de ejemplo ahora lee sus datos desde un archivo de texto o JSON. El siguiente capítulo la reorganiza en capas: la lectura de datos, el cálculo de impuestos y la interacción con el usuario se convertirán en componentes independientes.