How do I use map, filter and foreach with Kotlin collections?

By Wayan in Kotlin 0 Comment

In Kotlin collections:

  • map transforms each element into a new value.
  • filter keeps only elements that match a condition.
  • forEach performs an action for each element.

map: transform elements

Use map when you want to create a new collection by changing each item.

val numbers = listOf(1, 2, 3, 4)

val doubled = numbers.map { number ->
    number * 2
}

println(doubled) // [2, 4, 6, 8]

You can use it when the lambda has one parameter:

val numbers = listOf(1, 2, 3, 4)

val doubled = numbers.map { it * 2 }

println(doubled) // [2, 4, 6, 8]

filter: keep matching elements

Use filter when you want only items that satisfy a condition.

val numbers = listOf(1, 2, 3, 4, 5, 6)

val evenNumbers = numbers.filter { it % 2 == 0 }

println(evenNumbers) // [2, 4, 6]

Another example with strings:

val names = listOf("Alice", "Bob", "Charlie", "Anna")

val namesStartingWithA = names.filter { it.startsWith("A") }

println(namesStartingWithA) // [Alice, Anna]

forEach: perform an action

Use forEach when you want to do something with each element, such as printing.

val names = listOf("Alice", "Bob", "Charlie")

names.forEach { name ->
    println(name)
}

Using it:

val names = listOf("Alice", "Bob", "Charlie")

names.forEach {
    println(it)
}

Chaining them together

You can combine filter, map, and forEach.

val numbers = listOf(1, 2, 3, 4, 5, 6)

numbers
    .filter { it % 2 == 0 }
    .map { it * 10 }
    .forEach { println(it) }

Output:

20
40
60

This means:

  1. Keep only even numbers: [2, 4, 6]
  2. Multiply each by 10: [20, 40, 60]
  3. Print each result

Example with objects

data class User(
    val name: String,
    val age: Int
)

val users = listOf(
    User("Alice", 25),
    User("Bob", 17),
    User("Charlie", 30)
)

val adultNames = users
    .filter { it.age >= 18 }
    .map { it.name }

println(adultNames) // [Alice, Charlie]

Important difference

map and filter return new collections:

val numbers = listOf(1, 2, 3)

val doubled = numbers.map { it * 2 }

println(numbers) // [1, 2, 3]
println(doubled) // [2, 4, 6]

forEach is usually used for side effects and does not create a transformed list:

val numbers = listOf(1, 2, 3)

numbers.forEach { println(it) }

Quick summary

val numbers = listOf(1, 2, 3, 4, 5)

val squared = numbers.map { it * it }
// [1, 4, 9, 16, 25]

val greaterThanTwo = numbers.filter { it > 2 }
// [3, 4, 5]

numbers.forEach { println(it) }
// Prints each number

Use:

  • map when you want to transform values
  • filter when you want to select values
  • forEach when you want to perform an action for each value

How do I loop through collections using for, foreach and indices in Kotlin?

By Wayan in Kotlin 0 Comment

In Kotlin, you can loop through collections in several common ways depending on whether you need the element, the index, or both.

1. Using for

Use for when you want a simple, readable loop over elements.

val names = listOf("Alice", "Bob", "Charlie")

for (name in names) {
    println(name)
}

Output:

Alice
Bob
Charlie

This works with many Kotlin types, including:

val numbers = arrayOf(1, 2, 3)

for (number in numbers) {
    println(number)
}

2. Using forEach

Use forEach when you prefer a functional style.

val names = listOf("Alice", "Bob", "Charlie")

names.forEach { name ->
    println(name)
}

If the lambda has only one parameter, you can use it:

names.forEach {
    println(it)
}

forEach is useful for concise operations, but a regular for loop is often clearer if you need break, continue, or more complex control flow.

3. Looping with indices

Use indices when you need the index of each element.

val names = listOf("Alice", "Bob", "Charlie")

for (i in names.indices) {
    println("Index $i: ${names[i]}")
}

Output:

Index 0: Alice
Index 1: Bob
Index 2: Charlie

indices gives the valid index range for the collection, such as 0..lastIndex.

4. Using withIndex

If you need both the index and the value, withIndex() is often cleaner than indexing manually.

val names = listOf("Alice", "Bob", "Charlie")

for ((index, name) in names.withIndex()) {
    println("Index $index: $name")
}

5. Using forEachIndexed

The forEach equivalent for index + value is forEachIndexed.

val names = listOf("Alice", "Bob", "Charlie")

names.forEachIndexed { index, name ->
    println("Index $index: $name")
}

Summary

val items = listOf("A", "B", "C")

// Element only
for (item in items) {
    println(item)
}

// Element only, functional style
items.forEach { item ->
    println(item)
}

// Index only / index-based access
for (i in items.indices) {
    println("items[$i] = ${items[i]}")
}

// Index and value
for ((index, item) in items.withIndex()) {
    println("$index -> $item")
}

// Index and value, functional style
items.forEachIndexed { index, item ->
    println("$index -> $item")
}

Use:

  • for (item in items) for simple iteration
  • items.forEach { ... } for concise functional-style iteration
  • items.indices when you need index-based access
  • withIndex() or forEachIndexed when you need both index and value

How do I use ConcurrentHasMap forEach() method?

By Wayan in Util Package 0 Comment

The forEach() method in ConcurrentHashMap is used for iteration over the entries in the map. The method takes a BiConsumer as an argument, which is a functional interface that represents an operation that accepts two input arguments and returns no result.

Here’s an example of how to use forEach() with a ConcurrentHashMap:

package org.kodejava.util.concurrent;

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapForEachExample {
    public static void main(String[] args) {
        // Create a new ConcurrentHashMap
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

        // Add some key-value pairs
        map.put("One", 1);
        map.put("Two", 2);
        map.put("Three", 3);
        map.put("Four", 4);

        // Use forEach to iterate over the ConcurrentHashMap.
        // The BiConsumer takes a key (k) and value (v), and we're
        // just printing them here.
        map.forEach((k, v) -> System.out.println("Key: " + k + ", Value: " + v));
    }
}

Output:

Key: One, Value: 1
Key: Four, Value: 4
Key: Two, Value: 2
Key: Three, Value: 3

In the above example, forEach() is used to iterate over the entries of the map. For each entry, the key and value are printed. The forEach() method is often more convenient to use than an iterator, especially when you’re only performing a single operation (like print) for each entry in the map.

How do I use the Map.forEach() default method?

By Wayan in Java 8, Util Package 0 Comment

The forEach() method in the Map interface in Java 8, allows you to iterate over each entry in the map, allowing you to use each key-value pair in some way.

Here’s a basic usage of the forEach() method:

package org.kodejava.util;

import java.util.HashMap;
import java.util.Map;

public class MapForEachExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Apple", 10);
        map.put("Orange", 20);
        map.put("Banana", 30);

        // Use the forEach method. Here, each key-value pair is printed.
        map.forEach((key, value) -> System.out.println("Key: " + key + ", Value: " + value));
    }
}

Output:

Key: Apple, Value: 10
Key: Orange, Value: 20
Key: Banana, Value: 30

In this example, a HashMap is created and populated with some data. The forEach method is then called on this map, with a lambda expression that accepts a key and a value, then prints them. The key and value parameters represent the current key-value pair the forEach method is handling. In this lambda expression, they are printed to the console.

This operation is applied to each entry in the map, hence the name forEach.

Using the forEach method with lambda expressions has several benefits:

  1. Improved Readability: Traditional iteration requires creating an iterator, a while or for loop, and handling each element. With forEach and lambdas, you can express what you want to do with each element clearly and concisely, making the code easier to read and understand
  2. Concurrency Safety: The forEach method is inherently safer to use in concurrent environments. You don’t need to worry about ConcurrentModificationException errors which you might get while using an Iterator and modifying the collection concurrently.
  3. Less Boilerplate Code: The forEach function in combination with a lambda function provides a way to iterate over a collection with fewer lines of code compared to using iterators
  4. Functional Programming: Lambda expressions and functional interfaces pave the way towards functional programming in Java, which allows for more expressive ways to manipulate collections.

Remember, although forEach can make your code more concise, it does not necessarily make it faster.

How do I handle exceptions in Stream.forEach() method?

By Wayan in Java 8, Stream API, Util Package 0 Comment

When using Java’s Stream.forEach() method, you might encounter checked exceptions. Checked exceptions can’t be thrown inside a lambda without being caught because of the Consumer functional interface. It does not allow for this in its method signature.

Here is an example of how you might deal with an exception in a forEach operation:

package org.kodejava.basic;

import java.util.List;

public class ForEachException {
    public static void main(String[] args) {
        List<String> list = List.of("Java", "Kotlin", "Scala", "Clojure");
        list.stream().forEach(item -> {
            try {
                // methodThatThrowsExceptions can be any method that throws a 
                // checked exception
                methodThatThrowsExceptions(item);
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
    }

    public static void methodThatThrowsExceptions(String item) throws Exception {
        // Method implementation
    }
}

In the above code, we have a method methodThatThrowsExceptions that can throw a checked exception. In the forEach operation, we have a lambda in which we use a try-catch block to handle potential exceptions from methodThatThrowsExceptions.

However, this approach is not generally recommended because it suppresses the exception where it occurs and doesn’t interrupt the stream processing. If you need to properly handle the exception and perhaps stop processing, you may need to use a traditional for-or-each loop.

There are several reasons why exception handling within lambda expressions in Java Streams is not generally recommended.

  1. Checked Exceptions: Lambda expressions in Java do not permit checked exceptions to be thrown, so you must handle these within the lambda expression itself. This often results in bloated, less readable lambda expressions due to the necessity of a try-catch block.

  2. Suppressed Exceptions: If you catch the exception within the lambda and print the stack trace – or worse, do nothing at all – the exception is effectively suppressed. This could lead to silent failures in your code, where an error condition is not properly propagated up the call stack. This can make it harder to debug issues, as you may be unaware an exception has occurred.

  3. Robust Error Handling: Handling the exception within the lambda expression means you’re dealing with it right at the point of failure, and it might not be the best place to handle the exception. Often, you’ll want to stop processing the current operation when an exception occurs. Propagate the error up to a higher level in your software where it can be handled properly (e.g., by displaying an error message to the user, logging the issue, or retrying the operation).

  4. Impure Functions: By handling exceptions (a side effect) within lambda expressions, we are making them impure functions – i.e., functions that modify state outside their scope or depend on state from outside their scope. This goes against the principles of functional programming.

In summary, while you can handle exceptions within forEach lambda expressions in Java, doing so can create challenges in how the software handles errors, potentially leading to suppressed exceptions, less readable code, and deviations from functional programming principles. Better approaches often are to handle exceptions at a higher level, use optional values, or use features from new versions of Java (like CompletableFuture.exceptionally) or third-party libraries designed to handle exceptions in functional programming contexts.