Notes of a Web Developer Learning Kotlin and Android Development - part 2
Tags: android, kotlin, programming, beginners
Published: 2022-08-18 00:01:00


---
title: Notes of a Web Developer Learning Kotlin and Android Development - part 2
published: true
tags: android, kotlin, programming, beginners
date: 2022-08-18 00:01:00 UTC
canonical_url: https://eevis.codes/blog/2022-08-18/notes-of-a-web-developer-learning-kotlin-and-android-development-part-2/
series: Learning Kotlin and Android Development
---

*This blog post is the second in a series of posts about me working through the [Android Basics on Kotlin-course][2]. You can find the first one here: [Notes of a Web Developer Learning Kotlin and Android Development - part 1](https://dev.to/eevajonnapanula/notes-of-a-web-developer-learning-kotlin-and-android-development-part-1-4bd1)*

The second unit of the course, "Android Basics in Kotlin," is about Layouts. It also goes through some Kotlin-concepts, such as lists and `with`-syntax. From the Android side, the most significant theme is layouts, particularly adapters.

## Kotlin: Lists and Other Things

### Lists

There are different list types in Kotlin. Lists can be either mutable or immutable - you need to decide which one when defining the list. That's different from JavaScript: Even though you define them as constant in JS, you can still add and remove things. In Kotlin, you need to have a mutable list to do that. 

Lists are defined with the following syntaxes:
```kotlin
val immutableList = listOf("list", "of", "words")
val mutableList = mutableListOf("other", "words")
```

Printing these would result in
```shell
[list, of, words]
```
and
```shell
[other, words]
```

You can get the first item from a list with method `first()` and the last item with method `last()`. Sorting a list happens with the `sorted()`-method, and you can reverse a list with `reversed()`.

Mutable lists have a set of additional methods to mutate the list; here are some examples:

<dl>
<dt><code>add()</code></dt>
<dd>Add an item to the list.</dd>
<dt><code>addAll()</code></dt>
<dd>Add a collection to the list. More about other collection types in the next part.</dd>
<dt><code>remove()</code></dt>
<dd>Remove an item from the list.</dd>
<dt><code>clear()</code></dt>
<dd>Clear the list.</dd>
<dt><code>isEmpty()</code></dt>
<dd>Check if the list is empty.</dd>
</dl>

Again, here's plenty more than what you'll have with JavaScript. I mean, you can do all of these with JS, but you need to write more code for that, and it's not as verbose. Let's take a look at checking if a list is empty. With Kotlin, it would be:

```kotlin
// Kotlin

val list = listOf(...)
val isListEmpty = list.isEmpty()
```

And with JavaScript:

```javascript
// JavaScript

const list = [...]
const isListEmpty = list.length === 0
// or
const isListEmptyShorter = !list.length
```

A final thing about the lists in this post is looping through them. The material mentions two methods - `while` and `for`-loops. 

`while`-loops go on, as long its condition is satisfied. It first checks the condition and executes the body if it's true.

```kotlin
while (x < 10) {
	// Do something
	++x
}
```

For-loops iterates through the collection provided. So, for example, looping through the range of numbers could look like this:

```kotlin
for (i in 1..6) {
   // Do something with the current number
}
```

### `with`

`with`-syntax is nice when working with, for example, a specific class instance, and there's a need to access more than one of its properties and functions. 

So, for example:

```kotlin
with(cat) {
	println("Cat's name is ${name}")
	println("It often sleeps in ${favoritePlace}")
	meow()
}
```

I could access these properties with `cat.name` or `cat.meow()`, but I need to write less code this way.

## Android: Let's Talk About Adapters

Adapters are the most significant learning in this unit - or refresher, as I recall some distant things about them. They work as, you guessed, adapters between views and underlying data. 

The adapter is a design pattern. It adapts the data and transforms it into something the client can use. In the course, the example is about `RecyclerView`, and how the data is adapted to it.

When introducing the adapters, the app being built is a list of affirmations. `RecyclerView` is suitable for this project as it's a good component for creating dynamic lists efficiently. 

The course explains how an adapter works with `RecyclerView` in the app with the following words:
> When you run the app, RecyclerView uses the adapter to figure out how to display your data on screen. RecyclerView asks the adapter to create a new list item view for the first data item in your list. Once it has the view, it asks the adapter to provide the data to draw the item. This process repeats until the RecyclerView doesn't need any more views to fill the screen. If only 3 list item views fit on the screen at once, the RecyclerView only asks the adapter to prepare those 3 list item views (instead of all 10 list item views).

In the app, the adapter has multiple parts. First, a layout is created for an individual list item. The next step is to create an `ItemAdapter`-class, which takes in a list of affirmations, and context-object instance. 

After that, an `ItemViewHolder` is created inside the `ItemAdapter`. It represents a single list item view in the `RecyclerView` and can be reused. That view holder is the one that handles updating and showing data. 

The adapter needs to implement three methods: `onCreateViewHolder`, `getItemCount` and `onBindViewHolder`. 

The layout manager calls `onCreateViewHolder` to create new view holders for the `RecyclerView`, if there are no existing view holders that it could reuse.  

`getItemCount` is for, as the name suggests, getting the item count for the list data. The layout manager calls `onBindViewHolder` to replace the contents of a list item view.

There's one more step: Once the adapter is created, `RecyclerView` needs to know about it. In the course project, `MainActivity` is the place to do that. To be more specific, in the `onCreate`-method of that activity.

I've had a hard time wrapping my head around the pattern. However, I think it's partly because it's a new, complex thing, and to be honest, it's been a while since the last last time I did object-oriented programming.

So I need to keep practicing - this concept among all the others. Luckily, from what I've understood, this is something I'll need many times when learning more about Android development.

## Wrapping Up

There were many things to learn in unit 2 of the Android Basics in Kotlin-course. I know I will return to these topics in the following units - and definitely when I start creating something of my own. 

The next unit is about navigation, and that's an interesting one. I've already started it, and there's so much to know! I'm so excited about these new concepts I'm learning. As there is so much material and new things in the Navigation unit, I might split it into two posts. We'll see.

Have you been learning Kotlin or Android development? Have any tips or thoughts?

## Links

- [Android Basics on Kotlin-course][2]
- [Notes of a Web Developer Learning Kotlin and Android Development - part 1][1]

[1]: https://eevis.codes/blog/2022-08-02/notes-of-a-web-developer-learning-kotlin-and-android-development-part-1/
[2]: https://developer.android.com/courses/android-basics-kotlin/course