Kotlin - Tipi di base

In questo capitolo, impareremo i tipi di dati di base disponibili nel linguaggio di programmazione Kotlin.

Numeri

La rappresentazione dei numeri in Kotlin è abbastanza simile a Java, tuttavia, Kotlin non consente la conversione interna di diversi tipi di dati. La tabella seguente elenca diverse lunghezze variabili per numeri diversi.

genere	Taglia
Doppio	64
Galleggiante	32
Lungo	64
Int	32
Corto	16
Byte	8

Nell'esempio seguente, vedremo come funziona Kotlin con diversi tipi di dati. Si prega di inserire il seguente set di codice nel nostro campo di codifica.

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);
}

Quando esegui la parte di codice sopra nella base di codifica, genererà il seguente output nella console 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

Personaggi

Kotlin rappresenta l'uso del personaggio char. Il carattere dovrebbe essere dichiarato in una singola virgoletta come‘c’. Inserisci il seguente codice nel nostro campo di codifica e guarda come Kotlin interpreta la variabile carattere. La variabile carattere non può essere dichiarata come le variabili numeriche. La variabile Kotlin può essere dichiarata in due modi: uno utilizzando“var” e un altro utilizzando “val”.

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

La parte di codice precedente produrrà il seguente output nella finestra di output del browser.

Booleano

Boolean è molto semplice come altri linguaggi di programmazione. Abbiamo solo due valori per Boolean: true o false. Nell'esempio seguente, vedremo come 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")
}

La parte di codice precedente produrrà il seguente output nel browser.

Your character value is true

stringhe

Le stringhe sono matrici di caratteri. Come Java, sono immutabili in natura. Abbiamo due tipi di stringa disponibili in Kotlin: uno è chiamatoraw String e un altro si chiama escaped String. Nell'esempio seguente, utilizzeremo queste stringhe.

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)   
}

L'esempio precedente di stringa con escape consente di fornire uno spazio di riga aggiuntivo dopo la prima istruzione di stampa. Di seguito sarà l'output nel browser.

Hello!I am escaped String!

Hey!!I am Raw String!

Arrays

Gli array sono una raccolta di dati omogenei. Come Java, Kotlin supporta array di diversi tipi di dati. Nell'esempio seguente, utilizzeremo diversi array.

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

La parte di codice precedente produce il seguente output. L'indicizzazione dell'array è simile ad altri linguaggi di programmazione. Qui stiamo cercando un secondo indice, il cui valore è "3".

Hey!! I am array Example3

Collezioni

La raccolta è una parte molto importante della struttura dei dati, che semplifica lo sviluppo del software per gli ingegneri. Kotlin ha due tipi di raccolta: uno èimmutable collection (che significa elenchi, mappe e set che non possono essere modificabili) e un altro lo è mutable collection(questo tipo di raccolta è modificabile). È molto importante tenere presente il tipo di raccolta utilizzata nella propria applicazione, poiché il sistema Kotlin non rappresenta alcuna differenza specifica in essi.

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  
}

La parte di codice precedente produrrà il seguente output nel browser. Dà un errore quando proviamo a cancellare l'elenco modificabile della raccolta.

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

Nella raccolta, Kotlin fornisce alcuni metodi utili come first(), last(), filter(), ecc. Tutti questi metodi sono auto-descrittivi e facili da implementare. Inoltre, Kotlin segue la stessa struttura di Java durante l'implementazione della raccolta. Sei libero di implementare qualsiasi raccolta di tua scelta come Mappa e Set.

Nell'esempio seguente, abbiamo implementato Map e Set utilizzando diversi metodi incorporati.

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)
}

La parte di codice precedente produce il seguente output nel browser.

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]

Gamme

Gli intervalli sono un'altra caratteristica unica di Kotlin. Come Haskell, fornisce un operatore che ti aiuta a scorrere un intervallo. Internamente, è implementato utilizzandorangeTo() e la sua forma operatore è (..).

Nell'esempio seguente, vedremo come Kotlin interpreta questo operatore di intervallo.

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)
   }
}