CODEWITHSUNDEEP
syntaxkotlin
mojtab23
mojtab23

Reputation: 2675

Kotlin asterisk operator before variable name or Spread Operator in Kotlin

I want to know what exactly an asterisk does before a variable name in Kotlin. I saw this (*args) in a Spring boot Kotlin example:

@SpringBootApplication
open class Application {

    @Bean
    open fun init(repository: CustomerRepository) = CommandLineRunner {
        repository.save(Customer("Jack", "Bauer"))
        repository.save(Customer("Chloe", "O'Brian"))
        repository.save(Customer("Kim", "Bauer"))
        repository.save(Customer("David", "Palmer"))
        repository.save(Customer("Michelle", "Dessler"))
    }
}

fun main(args: Array<String>) {
    SpringApplication.run(Application::class.java, *args)
}

Upvotes: 174

Views: 73135

Answers (5)

Suraj Vaishnav
Suraj Vaishnav

Reputation: 8305

Consider a function which accepts a vararg (Variable number of arguments) parameter like below:

fun sum (vararg data: Int) {
   // function body here         
}

We can call this method with

sum(1,2,3,4,5)

But if we have these same values in an array, like:

val array = intArrayOf(1,2,3,4,5)

Then, we can call this method using the spread operator, like:

sum(*array)

Here, *(spread operator) will pass all the content of the array to the function.

*array is equivalent to 1,2,3,4,5

But a call like this:

sum(array)

will give us Type Mismatch compile time error:

Type mismatch.
Required:Int
Found:IntArray

This is because the array sum(array) will be passed as IntArray, but this call sum(*array) will pass the contents of the array to the function.

Upvotes: 9

byxor
byxor

Reputation: 6349

The * operator is known as the Spread Operator in Kotlin.

From the Kotlin Reference:

When you call a vararg-function, you can pass arguments individually, for example asList(1, 2, 3). if you already have an array and want to pass its contents to the function, use the spread operator (prefix the array with *):

It can be applied to an Array before passing it into a function that accepts vararg.

For Example...

If you have a function that accepts a varied number of arguments...

fun sumOfNumbers(vararg numbers: Int): Int {
    return numbers.sum()
}

Use the spread operator to pass an array's elements as the arguments:

val numbers = intArrayOf(2, 3, 4)
val sum = sumOfNumbers(*numbers)
println(sum) // Prints '9'

Notes:

  • The * operator is also the multiplication operator (of course).
  • The operator can only be used when passing arguments to a function. The result of the operation cannot be stored since it yields no value (it is purely syntactic sugar).
  • The operator may confuse some C/C++ programmers at first because it looks like a pointer is being de-referenced. It isn't; Kotlin has no notion of pointers.
  • The operator can be used in-between other arguments when calling a vararg-function. This is demonstrated in the example here.
  • The operator is similar to the apply function in various functional programming languages.

Upvotes: 294

Gulzar Bhat
Gulzar Bhat

Reputation: 1355

In Java you can pass an array as is but an advantage of unpacking an array with spread operator * is that spread operator lets you combine the values from an array and some fixed values in a single call. Java doesn't support this.

Upvotes: 7

Jayson Minard
Jayson Minard

Reputation: 85946

In addition to the answers that were directly towards "what is this thing!?!", you often have the case where you have a List and want to pass it to a function that is expecting a vararg. For this, the conversion is:

someFunc(x, y, *myList.toTypedArray())

Assuming that last parameter of someFunc is vararg of the same type as the elements in the list.

Upvotes: 35

miensol
miensol

Reputation: 41638

As described in the documentation this is a spread operator:

When we call a vararg-function, we can pass arguments one-by-one, e.g. asList(1, 2, 3), or, if we already have an array and want to pass its contents to the function, we use the spread operator (prefix the array with *):

val a = arrayOf(1, 2, 3) 
val list = asList(-1, 0, *a, 4)

Upvotes: 13

Related Questions