In Kotlin, unlike in Java, everything is an object. In Java, we have primitive types such as: int, char, byte, float and so on. In Kotlin each of this primitives is represented by (and only) by class. Kotlin does not have primitive types!
Here is the list of number classes:
Double – 64 bits
Float – 32 bits
Long – 64 bits
Int – 32 bits
Short – 16 bits
Byte – 8 bits
To represent numbers we can use the following literals:
- Decimal numbers: 100, 200, 123 …
- Long decimal numbers: 400L, 10L, 200L …
- Hexadecimal numbers: 0x0F …
- Floating point numbers: 1.23, 2.16 … Default type used is Double, to use Float define it like 1.23f, 2.16f ...
Kotlin does no support octal literals!
All numbers are stored in JVM. Bigger numbers are not the classes that are extending smaller ones or vice versa!
(Numbers.kt)
fun playWithNumbers() {
val a: Int = 1 // a is boxed Int (java.lang.Integer)
var b: Long? = null // We can't pass b directly to a!
b = a.toLong() // We must convert it!
println("a: $a") // prints 1
println("b: $b") // prints 1
print(a.equals(b)) // We compare them
}
So, the conversation between numbers is done by one of methods (each number class has them):
- toByte(): Byte
- toShort(): Short
- toInt(): Int
- toLong(): Long
- toFloat(): Float
- toDouble(): Double
- toChar(): Char
The type is inferred from the context, and arithmetical operations are overloaded for appropriate conversions, for example:
val x = 1L + 1 // Long + Int = Long
All arithmetical operations are defined as operators defined in number classes. Standard set of arithmetical operations is supported, such as: +, -, /, * etc.
Here is the list of bitwise operations available for Int and Long classes:
- shl(bits) - signed shift left (in Java: <<)
- shr(bits) - signed shift right (in Java >>)
- ushr(bits) - unsigned shift right (in Java >>>)
- and(bits) - bitwise and
- or(bits) - bitwise or
- xor(bits) – bitwise xor
- inv() - bitwise inversion
Characters cannot be treated directly as numbers! To convert them use toInt() class method. Each literal character goes in single quotes, for example: ‘1’, ‘m’, ‘p’ and so on. Also, there are some important escape sequences that we will need for sure: \t , \b , \n , \r , \' , \" , \\ and \$.
Class Boolean represents boolean type in Kotlin. It has two possible values: true or false.
There are 3 major operations we can perform on booleans in Kotlin:
- || - lazy disjunction, example: a || b
- && - lazy conjunction, example: a && b
- ! - negation, example: !a || !b
Let’s take a look at the following example: Arrays.kt, it demonstrates Kotlin arrays with self-explanatory code:
fun arraysExample(){
// Array of 10 items which values are genereted by: index + 100
val a = Array(5, { i -> i + 100 })
for(x in a) println("A member: $x")
println("- - - - - - - - - - - - - set 1000 to element at 2")
a[2] = 1000 // or: a.set(2, 1000)
for(x in a) println("A member: $x")
println("- - - - - - - - - - - - - ")
val y = a.get(0)
println("Member at 0 position: $y")
println("- - - - - - - - - - - - - ")
val b = arrayOf(2, 4, 6, "Some string", "One more string", 8, 10)
b[1] = 10 // Replace 4 with 10!
for(x in b) println("B member : $x")
println("- - - - - - - - - - - - - ")
val c = arrayOfNulls<Int>(5)
for(x in c) println("C member: $x")
println("- - - - - - - - - - - - - set values to members")
for (x in c.indices) c[x] = x + 1000 // or: c.set(x, x + 1000)
for(x in c) println("C member: $x")
println("- - - - - - - - - - - - - ")
val d = intArrayOf(10, 100, 1000, 10000)
for(x in d) println("D member: $x")
println("- - - - - - - - - - - - - set values to members")
for (x in d.indices) d[x] = d[x] + 5000 // or: d.set(x, d.get(x) + 5000)
for(x in d) println("D member: $x")
println("- - - - - - - - - - - - - ")
println("A size ${a.size}")
println("B size ${b.size}")
println("C size ${c.size}")
println("D size ${d.size}")
println("- - - - - - - - - - - - - ")
}
Console output:
A member: 100
A member: 101
A member: 102
A member: 103
A member: 104
- - - - - - - - - - - - - set 1000 to element at 2
A member: 100
A member: 101
A member: 1000
A member: 103
A member: 104
- - - - - - - - - - - - -
Member at 0 position: 100
- - - - - - - - - - - - -
B member : 2
B member : 10
B member : 6
B member : Some string
B member : One more string
B member : 8
B member : 10
- - - - - - - - - - - - -
C member: null
C member: null
C member: null
C member: null
C member: null
- - - - - - - - - - - - - set values to members
C member: 1000
C member: 1001
C member: 1002
C member: 1003
C member: 1004
- - - - - - - - - - - - -
D member: 10
D member: 100
D member: 1000
D member: 10000
- - - - - - - - - - - - - set values to members
D member: 5010
D member: 5100
D member: 6000
D member: 15000
- - - - - - - - - - - - -
A size 5
B size 7
C size 5
D size 4
- - - - - - - - - - - - -
Strings in Kotlin are immutable. Elements in one String are characters that can be accessed like any other array. To each element we can access using Iterrator, or using for loop.
Let’s look at Strings.kt:
val s = "Some string"
// Iterate:
val iterator = s.iterator()
while(iterator.hasNext()) println("Character: ${iterator.next()}")
println("- - - - - - - - - - - - - ")
// For loop:
for(c in s) println("Character: $c")
println("- - - - - - - - - - - - - ")
Console output:
Character: S
Character: o
Character: m
Character: e
Character:
Character: s
Character: t
Character: r
Character: i
Character: n
Character: g
- - - - - - - - - - - - -
Character: S
Character: o
Character: m
Character: e
Character:
Character: s
Character: t
Character: r
Character: i
Character: n
Character: g
- - - - - - - - - - - - -
Strings can be defined in several ways:
val s1 = "Some string"
val s2 = "Some\tstring\n"
val s3 = """
Raw string example...
We have multiline here!
"""