Kotlin - Tipos básicos

En este capítulo, aprenderemos sobre los tipos de datos básicos disponibles en el lenguaje de programación Kotlin.

Números

La representación de números en Kotlin es bastante similar a Java, sin embargo, Kotlin no permite la conversión interna de diferentes tipos de datos. La siguiente tabla enumera diferentes longitudes variables para diferentes números.

En el siguiente ejemplo, veremos cómo Kotlin trabaja con diferentes tipos de datos. Introduzca el siguiente conjunto de códigos en nuestro campo de codificación.

fun main(args: Array<String>) {
   val a: Int = 10000
   val d: Double = 100.00
   val f: Float = 100.00f
   val l: Long = 1000000004
   val s: Short = 10
   val b: Byte = 1
   
   println("Your Int Value is "+a);
   println("Your Double  Value is "+d);
   println("Your Float Value is "+f);
   println("Your Long Value is "+l);
   println("Your Short Value is "+s);
   println("Your Byte Value is "+b);
}

Cuando ejecuta el fragmento de código anterior en el campo de codificación, generará la siguiente salida en la consola web.

Your Int Value is 10000
Your Double  Value is 100.0
Your Float Value is 100.0
Your Long Value is 1000000004
Your Short Value is 10
Your Byte Value is 1

Caracteres

Kotlin representa al personaje usando char. El carácter debe declararse en una comilla simple como‘c’. Ingrese el siguiente código en nuestro campo de codificación y vea cómo Kotlin interpreta la variable de carácter. La variable de caracteres no se puede declarar como variables numéricas. La variable Kotlin se puede declarar de dos maneras: una usando“var” y otro usando “val”.

fun main(args: Array<String>) {
   val letter: Char    // defining a variable 
   letter = 'A'        // Assigning a value to it 
   println("$letter")
}

El fragmento de código anterior producirá el siguiente resultado en la ventana de resultados del navegador.

A

Booleano

Boolean es muy simple como otros lenguajes de programación. Solo tenemos dos valores para Boolean: verdadero o falso. En el siguiente ejemplo, veremos cómo Kotlin interpreta Boolean.

fun main(args: Array<String>) {
   val letter: Boolean   // defining a variable 
   letter = true         // Assinging a value to it 
   println("Your character value is "+"$letter")
}

El fragmento de código anterior producirá el siguiente resultado en el navegador.

Your character value is true

Instrumentos de cuerda

Las cadenas son matrices de caracteres. Como Java, son de naturaleza inmutable. Tenemos dos tipos de cuerdas disponibles en Kotlin: una se llamaraw String y otro se llama escaped String. En el siguiente ejemplo, haremos uso de estas cadenas.

fun main(args: Array<String>) {
   var rawString :String  = "I am Raw String!"
   val escapedString : String  = "I am escaped String!\n"
   
   println("Hello!"+escapedString)
   println("Hey!!"+rawString)   
}

El ejemplo anterior de cadena de escape permite proporcionar espacio de línea adicional después de la primera declaración de impresión. Lo siguiente será la salida en el navegador.

Hello!I am escaped String!

Hey!!I am Raw String!

Matrices

Las matrices son una colección de datos homogéneos. Al igual que Java, Kotlin admite matrices de diferentes tipos de datos. En el siguiente ejemplo, usaremos diferentes matrices.

fun main(args: Array<String>) {
   val numbers: IntArray = intArrayOf(1, 2, 3, 4, 5)
   println("Hey!! I am array Example"+numbers[2])
}

El fragmento de código anterior produce el siguiente resultado. La indexación de la matriz es similar a otros lenguajes de programación. Aquí, estamos buscando un segundo índice, cuyo valor es "3".

Hey!! I am array Example3

Colecciones

La recopilación es una parte muy importante de la estructura de datos, lo que facilita el desarrollo de software para los ingenieros. Kotlin tiene dos tipos de colección: una esimmutable collection (lo que significa listas, mapas y conjuntos que no se pueden editar) y otro es mutable collection(este tipo de colección es editable). Es muy importante tener en cuenta el tipo de colección que se utiliza en su aplicación, ya que el sistema Kotlin no representa ninguna diferencia específica en ellas.

fun main(args: Array<String>) { 
   val numbers: MutableList<Int> = mutableListOf(1, 2, 3) //mutable List 
   val readOnlyView: List<Int> = numbers                  // immutable list 
   println("my mutable list--"+numbers)        // prints "[1, 2, 3]" 
   numbers.add(4) 
   println("my mutable list after addition --"+numbers)        // prints "[1, 2, 3, 4]" 
   println(readOnlyView)     
   readOnlyView.clear()    // ⇒ does not compile  
// gives error  
}

El fragmento de código anterior producirá el siguiente resultado en el navegador. Da un error cuando intentamos borrar la lista mutable de colección.

main.kt:9:18: error: unresolved reference: clear
   readOnlyView.clear()    // -> does not compile  
                 ^

En la recopilación, Kotlin proporciona algunos métodos útiles como first(), last(), filter(), etc. Todos estos métodos son autodescriptivos y fáciles de implementar. Además, Kotlin sigue la misma estructura que Java al implementar la colección. Puede implementar cualquier colección de su elección, como Mapa y Conjunto.

En el siguiente ejemplo, hemos implementado Map and Set utilizando diferentes métodos integrados.

fun main(args: Array<String>) {
   val items = listOf(1, 2, 3, 4)
   println("First Element of our list----"+items.first())
   println("Last Element of our list----"+items.last())
   println("Even Numbers of our List----"+items.
      filter { it % 2 = = 0 })   // returns [2, 4]
   
   val readWriteMap = hashMapOf("foo" to 1, "bar" to 2)
   println(readWriteMap["foo"])  // prints "1"
   
   val strings = hashSetOf("a", "b", "c", "c")
   println("My Set Values are"+strings)
}

El fragmento de código anterior produce el siguiente resultado en el navegador.

First Element of our list----1
Last Element of our list----4
Even Numbers of our List----[2, 4]
1
My Set Values are[a, b, c]

Rangos

Los rangos son otra característica única de Kotlin. Al igual que Haskell, proporciona un operador que le ayuda a recorrer un rango. Internamente, se implementa utilizandorangeTo() y su forma de operador es (..).

En el siguiente ejemplo, veremos cómo Kotlin interpreta este operador de rango.

fun main(args: Array<String>) {
   val i:Int  = 2
   for (j in 1..4) 
   print(j) // prints "1234"
   
   if (i in 1..10) { // equivalent of 1 < = i && i < = 10
      println("we found your number --"+i)
   }
}

El fragmento de código anterior produce el siguiente resultado en el navegador.

1234we found your number --2