## 1. Overview

The average of a list of numbers indicates a central point in a data set. Further, finding the average has many practical use cases when analyzing data and generating reports.

In this tutorial, we’ll explore multiple ways to find the average of all items in a list in Kotlin.

## 2. Using Loops

In this section, we’ll learn how to use loop constructs to solve our use case.

### 2.1. With for Loop

Let’s write the averageUsingForLoop() function that uses a for loop to iterate over the numbers list for computing the average:

``````fun averageUsingForLoop(numbers: List<Int>): Double {
var sum = 0.0
for (num in numbers) {
sum += num
}
val average = sum / numbers.size
return average
}``````

Next, let’s define the numbers list with a few sample integer values:

``val numbers = listOf(10, 2, 3, 40, 5)``

We’ll reuse the numbers list to validate all our approaches.

Lastly, let’s test the averageUsnigForLoop() function:

``````val average: Double = averageUsingForLoop(numbers)
assertEquals(12.0, average)``````

Great! We got this one right.

### 2.2. With forEach Loop

Similar to the for loop approach, letâ€™s write the averageUsingForEachLoop() function that uses a forEach construct:

``````fun averageUsingForEachLoop(numbers: List<Int>): Double {
var sum = 0.0
numbers.forEach { sum += it }
val average = sum / numbers.size
return average
}``````

Like earlier, letâ€™s verify our function:

``````val average: Double = averageUsingForEachLoop(numbers)
assertEquals(12.0, average)``````

It works as expected.

## 3. Using Extension Functions

In this section, weâ€™ll explore a set of extension functions with lists to calculate the average.

### 3.1. With average()

Letâ€™s useÂ the average() extension function to calculate the average of all items of the numbers list:

``val average: Double = numbers.average()``

Now, letâ€™s verify that itâ€™s working correctly:

``assertEquals(12.0, average)``

Great! It works!

### 3.2. With sumByDouble()

We can also use the sumBy() extension function. Letâ€™s use it in the averageUsingSumByDouble() function:

``````fun averageUsingSumByDouble(numbers: List<Int>): Double {
val sum = numbers.sumByDouble { it.toDouble() }
val average = sum / numbers.size
return average
}``````

Itâ€™s interesting to note that we used the it identifier to specify that we must use each element from the list.

Next, letâ€™s confirm that itâ€™s giving the right results:

``````val average: Double = averageUsingSumByDouble(numbers)
assertEquals(12.0, average)``````

### 3.3. With fold()

Now, letâ€™s use the fold() extension function within the averageUsingFold() function to find the average:

``````fun averageUsingFold(numbers: List<Int>): Double {
val sum = numbers.fold(0.0) { acc, num -> acc + num }
val average = sum / numbers.size
return average
}``````

We must note the initial value of the accumulator (acc) is 0.0, and we add each number (num) to update the accumulator value.

Like earlier, letâ€™s verify our function:

``````val average: Double = averageUsingFold(numbers)
assertEquals(12.0, average)``````

### 3.4. With reduce()

Letâ€™s see how we can write the averageUsingReduce() function that uses the reduce() extension function on the numbers list:

``````fun averageUsingReduce(numbers: List<Int>): Double {
val sum = numbers.reduce { acc, num -> acc + num }
val average = sum.toDouble() / numbers.size
return average
}
``````

Itâ€™s worth noting that reduce() is almost similar to fold(), except that the initial value is set as the first member of the list.

Further, letâ€™s see this in action:

``````val average: Double = averageUsingReduce(numbers)
assertEquals(12.0, average)``````

Fantastic! It looks like we nailed this one.

## 4. Using Sequence

For large data sets, we can use the asSequence() method to wrap the list in a sequence. It’s required to access the elements of the list lazily and avoid the creation of any intermediate collection during transformations.

Let’s write the averageUsingSequence() function to compute the average of the numbers list by using the map() and sum() functions:

``````fun averageUsingSequence(numbers: List<Int>): Double {
val sum = numbers.asSequence().map { it.toDouble() }.sum()
val average = sum / numbers.size
return average
}``````

Now, we should also test this approach:

``````val average: Double = averageUsingSequence(numbers)
assertEquals(12.0, average)``````

Perfect! Our approach worked fine.

## 5. Conclusion

In this article, we learned several approaches, such as loops, extension functions, and sequences, to calculate the average of all items in a listÂ in Kotlin.