Kotlin List plus (+) Function

The plus function in Kotlin is used to create a new list by adding elements to an existing list. This function belongs to the List interface in the Kotlin standard library and provides a straightforward way to concatenate lists or add elements to a list without modifying the original list.

Table of Contents

1. Introduction
2. plus Function Syntax
3. Using the + operator instead of plus function
4. Examples
   • Basic Usage
   • Adding an Element to a List
   • Concatenating Two Lists
5. Real-World Use Case
6. Conclusion

Introduction

The plus function creates a new list by adding elements to an existing list. This is useful for tasks such as appending elements, merging lists, and creating modified copies of lists while preserving immutability.

plus Function Syntax

The syntax for the plus function is as follows:

operator fun <T> List<T>.plus(element: T): List<T>
operator fun <T> List<T>.plus(elements: Collection<T>): List<T>
operator fun <T> List<T>.plus(elements: Array<out T>): List<T>

Parameters:

• element: A single element to add to the list.
• elements: A collection or array of elements to add to the list.

Returns:

• A new list containing the original elements and the added elements.

Using the + operator instead of plus function

In Kotlin, the + operator is a convenient shorthand for the plus function across various list types. Whether you’re working with a list of numbers, strings, or custom objects, list + element is syntactic sugar for list.plus(element). This operator provides a clean and intuitive way to add elements or concatenate lists while ensuring the original list remains unchanged. Both approaches are interchangeable, so you can use the + operator or plus function based on your preferred coding style.

Examples

Basic Usage

To demonstrate the basic usage of plus, we will add an element to a list and create a new list.

Example

fun main() {
    val originalList = listOf(1, 2, 3)
    val newList = originalList + 4
    println("Original list: $originalList")
    println("New list: $newList")
}

Output:

Original list: [1, 2, 3]
New list: [1, 2, 3, 4]

In the examples above, the + operator is used instead of the plus function to add elements to lists. In Kotlin, the + operator is an overloaded shortcut for the plus function, providing a more concise and readable syntax. Both approaches are equivalent, as originalList + element internally calls originalList.plus(element). Using + helps keep the code cleaner and quickly conveys the intent to add or concatenate elements without modifying the original list.

Adding an Element to a List

This example shows how to add a single element to a list using the plus function.

Example

fun main() {
    val fruits = listOf("apple", "banana")
    val newFruits = fruits + "cherry"
    println("Original list: $fruits")
    println("New list: $newFruits")
}

Output:

Original list: [apple, banana]
New list: [apple, banana, cherry]

Concatenating Two Lists

This example demonstrates how to concatenate two lists using the plus function.

Example

fun main() {
    val list1 = listOf(1, 2, 3)
    val list2 = listOf(4, 5, 6)
    val combinedList = list1 + list2
    println("List 1: $list1")
    println("List 2: $list2")
    println("Combined list: $combinedList")
}

Output:

List 1: [1, 2, 3]
List 2: [4, 5, 6]
Combined list: [1, 2, 3, 4, 5, 6]

Real-World Use Case

Adding Items to a Shopping Cart

In real-world applications, the plus function can be used to add items to a shopping cart without modifying the original list of items.

Example

fun main() {
    val cart = listOf("Apple", "Banana")
    val newCart = cart + "Cherry"
    println("Original cart: $cart")
    println("Updated cart: $newCart")
}

Output:

Original cart: [Apple, Banana]
Updated cart: [Apple, Banana, Cherry]

Conclusion

The plus function in Kotlin's List interface is a useful method for creating new lists by adding elements to existing lists. It provides a simple way to concatenate lists or add elements while preserving the immutability of the original list. 

By understanding and using this function, you can effectively manage list operations and ensure your applications handle data efficiently and immutably.