Оператор звездочки в Kotlin перед именем переменной или оператор распространения в Kotlin

Я хочу знать, что именно делает звездочка перед именем переменной в Kotlin. Я видел это ( *args) в примере Spring boot Kotlin :

@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)
}

Этот *оператор известен в Котлине как оператор распространения .

Из справочника Kotlin ...

Когда мы вызываем vararg-функцию, мы можем передавать аргументы один за другим, например asList (1, 2, 3), или, если у нас уже есть массив и мы хотим передать его содержимое в функцию, мы используем распространение оператор (префикс массива с *):

Его можно применить к массиву перед передачей в функцию, которая принимает varargs.

Например...

Если у вас есть функция, которая принимает различное количество аргументов ...

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

Вы можете передать в него массив так ...

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

Примечания:

• *Оператор также оператор умножения (конечно).
• Оператор можно использовать только при передаче аргументов функции. Результат операции не может быть сохранен, поскольку он не дает никакого значения (это чисто синтаксический сахар).
• Оператор может сначала сбить с толку некоторых программистов C / C ++, потому что похоже, что ссылка на указатель отменяется. Это не так; Котлин не знает указателей .
• Оператор может использоваться между другими аргументами при вызове функции vararg. Это продемонстрировано на примере здесь .
• Оператор аналогичен applyфункции в различных языках функционального программирования.

В дополнение к ответам, которые относились непосредственно к «что это за штука!?!», Вы часто имеете дело с тем, что у вас есть Listи вы хотите передать его функции, ожидающей vararg. Для этого преобразование:

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

Предполагая, что последний параметр someFuncимеет varargтот же тип, что и элементы в списке.

Как описано в документации, это оператор распространения:

Когда мы вызываем vararg-функцию, мы можем передавать аргументы один за другим, например asList (1, 2, 3), или, если у нас уже есть массив и мы хотим передать его содержимое в функцию, мы используем распространение оператор (префикс массива с *):

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

Если функция, которая принимает параметр vararg (переменное количество аргументов), например:

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

Теперь, чтобы вызвать этот метод, мы можем:

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

Но что, если у нас есть эти значения в массиве, например:

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

затем, чтобы вызвать этот метод, мы должны использовать оператор распространения, например:

 sum(*array)

Здесь * (оператор распространения) передаст все содержимое этого массива.

* массив эквивалентен 1,2,3,4,5

Но подождите, а что, если мы назовем это так: sum(array) это даст нам ошибку времени компиляции Type Mismatch:

Type mismatch.
Required:Int
Found:IntArray

Проблема в том, что sumфункция принимает vararg Intпараметр (который принимает значение, например: 1,2,3,4,5), и если мы передадим массив, он будет передан как IntArray.

В Java вы можете передавать массив как есть, но преимущество распаковки массива с оператором распространения *заключается в том, что оператор распространения позволяет вам комбинировать значения из массива и некоторые фиксированные значения за один вызов. Java этого не поддерживает.