> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Kotlin Multiplication The `*` token in Kotlin functions as a binary arithmetic operator for multiplication, a unary prefix spread operator for array unpacking, a star projection token within the generic type system, and a wildcard character in import directives. ## Binary Arithmetic Operator (Multiplication) As a binary operator, `*` performs arithmetic multiplication. Kotlin resolves this via operator overloading, mapping the `*` symbol to the `times()` member or extension function. ```kotlin theme={"dark"} // Syntactic representation val result = a * b // Compiler translation val result = a.times(b) ``` To enable the `*` operator for custom classes, the type must declare a function named `times` accompanied by the `operator` modifier. The operand type and return type are strictly defined by the function signature. ```kotlin theme={"dark"} class Matrix { operator fun times(scalar: Int): Matrix { return Matrix() } } ``` ## Unary Prefix Spread Operator When positioned as a prefix immediately preceding an array identifier, `*` acts as the spread operator. It unpacks the elements of an array, allowing them to be passed as discrete arguments to a function parameter declared with the `vararg` modifier. ```kotlin theme={"dark"} fun processElements(vararg elements: String) { // Function body } val stringArray = arrayOf("A", "B", "C") // Applying the spread operator processElements(*stringArray) ``` **Mechanical Characteristics:** * **Type Restriction:** The spread operator is strictly compatible with arrays (e.g., `Array`, `IntArray`, `DoubleArray`). It cannot be applied directly to a `Collection` (which requires conversion via `.toTypedArray()`) or a pure `Iterable` (which requires conversion via `.toList().toTypedArray()`). * **Memory Allocation and Mutation:** Invoking the spread operator creates a shallow copy of the array elements. For object types, a `vararg` parameter compiles to `Array`, where the `out` variance inherently prevents element mutation at compile time. However, for primitive arrays (e.g., `IntArray`), element mutation is permitted. In these cases, the shallow copy ensures that any modifications to the array's elements within the function do not affect the original array. * **Argument Composition:** The operator can be interleaved with standard, comma-separated arguments within the same function invocation. ```kotlin theme={"dark"} processElements("Prefix", *stringArray, "Suffix") ``` ## Star Projection (Generics) While structurally a type projection rather than an expression-level operator, `*` is utilized within angle brackets to denote an unknown type argument in parameterized types. ```kotlin theme={"dark"} val heterogeneousList: List<*> = listOf(1, "Two", 3.0) ``` Mechanically, `*` provides a safe approximation of a generic type based on its variance declaration and upper bounds: * For a covariant type parameter (`out T : TUpper`), `*` projects to `out TUpper`, allowing safe reads of the upper bound. If no explicit upper bound is declared, it defaults to `out Any?`. * For a contravariant type parameter (`in T`), `*` projects to `in Nothing`, preventing unsafe writes to the generic instance. * For an invariant type parameter (`T : TUpper`), `*` projects to `out TUpper` for reading and `in Nothing` for writing. ## Wildcard Import In file headers, the `*` token acts as a wildcard within `import` directives. It instructs the compiler to import all accessible top-level declarations (classes, interfaces, functions, and properties) from a specified package or classifier, eliminating the need to import each member individually. ```kotlin theme={"dark"} // Imports all members of java.util import java.util.* // Imports all nested declarations of a specific class or object import org.example.Constants.* ```

Tired of Poor Kotlin Skills? Fix That With Deep Grasping! Learn More