Kotlin Basics: Data Types
Tags: kotlin, beginners, datatypes
Published: 2023-02-07 02:57:06

## Mutable and immutable variables

Before proceeding, it’s important to know that Kotlin has two kinds of attributes:

* `var` - it's mutable (variable)

* `val` - it's immutable (constant)

Why is `val` preferred?

* Legible: as the value doesn’t change, the developer doesn’t need to look for that variable in other places. It’s easier to understand, less complex.

* Testable: it’s easier to test because it minimizes state changing.

* Thread-safe: it doesn’t allow to be changed in another thread

Now, let’s move on :)

## Data Types

When declaring variables, it’s not required to pass the type. Kotlin infers it from the value.
All the data types are objects, some of the types like numbers, characters and booleans can be represented as primitive values at runtime. But to the user, they look like ordinary classes.

More info on data types can be founded [here](https://kotlinlang.org/docs/reference/basic-types.html).

And the code for these notes can be founded on my [Github](https://github.com/alinebone/KotlinBasics)

## Numbers

### Integers

If we don’t specify the number type Kotlin infers that it’s an `Int`, unless the value exceeds the maximum allowed. In this case, it infers that it's a `Long`.
To explicitly create a `Long` attribute, just add an 'L' at the end (ie.: `val longNumber = 1234L`).

It’s possible to use underscores to make numbers more readable: `val oneMillion = 1_000_000`

Here’s a table with the number types and their range:
{% gist https://gist.github.com/alinebone/004ae5823d229c3fa3bf6c71e09170d9.js %}

### Floating points

We can use `Float` and `Double` types for floating types.
In general, we use `Double` because it's more precise.

`Double` is the default type for floating points, so Kotlin will infer that it is a `Double` if we don't specify the type. To specify it, we just have to add an 'F' at the end of the number (IE.: var n: `Float` = 77.9F).

A `Float` can hold 6-7 decimal digits while `Double` can hold 15-16 digits. So, if a `Float` number has more than 7 digits, the number will be rounded. (ie.: 2.7182818284f will be 2.7182817).

### Conversion

To convert a number we can use the following functions:

* `toByte()`

* `toShort()`

* `toInt()`

* `toLong()`

* `toFloat()`

* `toDouble()`

* `toChar()`

*Note: Kotlin does not convert numbers in function parameters. Therefore, a function with a Double parameter can be called only on Double values.*  

## Boolean

A `Boolean` type can be only `true` or `false`. The operations are:

* Disjunction — OR ( `||` )
{% gist https://gist.github.com/alinebone/18fa40d9e3b41af2f407584f7ef345d2.js %}
* Conjunction — AND ( `&&` )
{% gist https://gist.github.com/alinebone/bd23526ad7ac101ae156dc1c375ce0c6.js %}
* Negation ( `!` ) - denies the current result:
`true` equals `!false`

## Characters

A `Char` cannot be treated directly as a number. As it happens in the `String` type, special characters can be escaped using a backslash (`\`).
To create a `Char`, you need to use single quotes (`'a'`), if you use double quotes (`"a"`) it will be a `String`.
The supported types are character, *ASCII* (numerical representation of a character - the supported ones are `\t`, `\b`, `\n`, `\r`, `\'`, `\"`, `\\` and `\$`), and Unicode (provides unique code number for every character):
{% gist https://gist.github.com/alinebone/c84b2921dddd95028b758230ea9fae0a.js %}

## Strings

Strings represent words or any other group of characters.
We can use templates (`${}` or just `$`) to interpolate variables and strings. Ie: `val greeting = "Welcome $userName"`.

The backslash (`\`) skips special characters as it is in the `Char` type. If you want to display a dollar sign, it's necessary to use it as `\$`.

Some string methods:

* `.length`: show the size of the string

* `.subSequence(1, 3)`: show the characters between specific index positions

A raw string is delimited by a triple quote (`"""`) and can contain new lines and any other special characters, without escaping:

```kotlin
    val rawString = """
        | I can have special characters $&%#
        | New lines
        
        
        | And so on...
    """
```

Kotlin’s strings are immutable. It never changes the memory allocated to a `String`, it always creates a new one. To begin it's fine to use `String` only. But if you have to make a lot of changes in a string, consider looking into the `StringBuilder` class.