# Kotlin 数组

> 原文： [http://zetcode.com/kotlin/arrays/](http://zetcode.com/kotlin/arrays/)

Kotlin 数组教程展示了如何在 Kotlin 中使用数组。

数组是固定数量的值的集合。 数组项称为数组的元素。 每个元素都可以由索引引用。 数组从零开始。

使用诸如`arrayOf()`或`intArrayOf()`之类的函数或诸如`IntArray`或`FloatArray`之类的类创建 Kotlin 数组。

## Kotlin 数组初始化

在第一个示例中，我们展示了如何在 Kotlin 中初始化数组。

`KotlinArrayInit.kt`

```kt
package com.zetcode

import java.util.Arrays

fun main() {

    val nums = arrayOf(1, 2, 3, 4, 5)
    println(Arrays.toString(nums))

    val nums2 = (3..12).toList().toTypedArray()
    println(Arrays.toString(nums2))

    val nums3 = IntArray(5, { i -> i * 2 + 3})
    println(Arrays.toString(nums3))
}

```

该示例创建三个数组。

```kt
val nums = arrayOf(1, 2, 3, 4, 5)

```

使用`arrayOf()`函数创建一个数组。

```kt
println(Arrays.toString(nums))

```

我们使用`Arrays'` `toString()`方法来打印数组的内容。

```kt
val nums2 = (3..12).toList().toTypedArray()

```

在这一行中，我们根据一系列数字创建一个数组。

```kt
val nums3 = IntArray(5, { i -> i * 2 + 3})

```

该行使用`IntArray`创建一个数组。 它以元素数量和工厂功能为参数。

```kt
[1, 2, 3, 4, 5]
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
[3, 5, 7, 9, 11]

```

这是输出。

## Kotlin 数组索引

下一个示例显示 Kotlin 中的数组索引操作。

`KotlinArrayIndexing.kt`

```kt
package com.zetcode

fun main() {

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

    println(nums[2])

    nums[0] = 11
    println(nums[0])
}

```

我们使用索引操作来获取和修改数组值。

```kt
println(nums[2])

```

我们用索引 2 打印该值，即数组中的第三个元素。 数组值的索引添加在一对方括号之间。

## Kotlin 数组基本操作

以下示例介绍了 Kotlin 数组的一些基本操作。

`KotlinArrayBasicOperations.kt`

```kt
package com.zetcode

import java.util.Arrays

fun main() {

    val nums = arrayOf(1, 2, 3, 4, 5)
    println(nums.get(0))

    nums.set(0, 0)
    println(Arrays.toString(nums))

    val nums2 = nums.plus(1)
    println(Arrays.toString(nums2))

    val slice = nums.sliceArray(1..3)
    println(Arrays.toString(slice))

    println(nums.first())
    println(nums.last())
    println(nums.indexOf(5))
}

```

在该示例中，我们检索和修改数组元素，创建切片，并获取元素的索引。

```kt
println(nums.get(0))

```

我们使用`get()`函数获得索引为 0 的元素。

```kt
nums.set(0, 0)

```

`set()`方法将指定索引处的数组元素设置为指定值。

```kt
val nums2 = nums.plus(1)

```

我们向数组添加一个新元素，创建一个新数组。 （请记住，数组是固定大小的；因此，创建了一个新的数组）。

```kt
val slice = nums.sliceArray(1..3)

```

使用`sliceArray()`方法，我们从数组中创建一个切片。 索引都包含在内。

```kt
println(nums.first())
println(nums.last())

```

我们得到数组的第一个和最后一个元素。

```kt
println(nums.indexOf(5))

```

我们获得元素 5 首次出现的索引。

```kt
1
[0, 2, 3, 4, 5]
[0, 2, 3, 4, 5, 1]
[2, 3, 4]
0
5
4

```

这是输出。

## Kotlin 数组内置方法

在下面的示例中，我们使用一些内置的数组方法。

`KotlinArrayBuiltins.kt`

```kt
package com.zetcode

fun main() {

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

    val avg = nums.average()
    println("The average is $avg")

    val nOfValues = nums.count()
    println("There are $nOfValues elements")

    val sumOfValues = nums.sum()
    println("The sum of values is $sumOfValues")

    val maxValue = nums.max()
    println("The maximum is $maxValue")

    val minValue = nums.min()
    println("The minimum is $minValue")
}

```

该示例计算数组的平均值，总和，最大值，最小值和大小。

```kt
val avg = nums.average()

```

`average()`函数计算数组值的平均值。

```kt
val nOfValues = nums.count()

```

元素数由`count()`确定。

```kt
The average is 3.0
There are 5 elements
The sum of values is 15
The maximum is 5
The minimum is 1

```

这是示例的输出。

## Kotlin 数组计数

`count()`方法对数组中的元素进行计数。

`KotlinArrayCount.kt`

```kt
package com.zetcode

fun main() {

    val nums = intArrayOf(2, 3, 4, 5, 6, 7)

    println("There are ${nums.count()} elements in the array")

    val nOfEvens = nums.count { it % 2 == 0 }

    println("There are $nOfEvens even values in the array")
}

```

该示例计算数组中值的总数和偶数的数量。

```kt
There are 6 elements in the array
There are 3 even values in the array

```

这是输出。

## Kotlin 数组遍历

在下一个示例中，我们遍历 Kotlin 数组。

`KotlinTraverseArrays.kt`

```kt
package com.zetcode

fun main() {

    val nums = arrayOf(1, 2, 3, 4, 5, 6, 7)

    nums.forEach({ e -> print("$e ") })

    println()

    nums.forEachIndexed({i, e -> println("nums[$i] = $e")})

    for (e in nums) {
        print("$e ")
    }

    println()

    val it: Iterator<Int> = nums.iterator()

    while (it.hasNext()) {

        val e = it.next()
        print("$e ")
    }
}

```

该示例使用四种不同的遍历方式遍历数组。

```kt
nums.forEach({ e -> print("$e ") })

```

我们使用`forEach()`遍历数组。 此方法对数组的每个元素应用操作。 在我们的情况下将其打印出来。

```kt
nums.forEachIndexed({i, e -> println("nums[$i] = $e")})

```

`forEachIndexed()`在每个元素上执行给定的操作，为元素提供顺序索引。

```kt
for (e in nums) {
    print("$e ")
}

```

我们在`for`循环中遍历数组。

```kt
val it: Iterator<Int> = nums.iterator()

while (it.hasNext()) {

    val e = it.next()
    print("$e ")
}

```

最后，我们使用迭代器和`while`循环遍历数组。

```kt
1 2 3 4 5 6 7 
nums[0] = 1
nums[1] = 2
nums[2] = 3
nums[3] = 4
nums[4] = 5
nums[5] = 6
nums[6] = 7
1 2 3 4 5 6 7 
1 2 3 4 5 6 7 

```

这是示例的输出。

## Kotlin 数组排序

我们展示了如何对 Kotlin 数组进行排序。

`KotlinArraySort.kt`

```kt
package com.zetcode

fun main() {

    val nums = arrayOf(7, 3, 3, 4, 5, 9, 1)

    val sortedNums = nums.sortedArray()
    println(Arrays.toString(sortedNums))

    val sortedNumsDesc = nums.sortedArrayDescending()
    println(Arrays.toString(sortedNumsDesc))
}

```

该示例对数组进行排序，其中`sortedArray()`为升序，`sortedArrayDescending()`为降序。 该方法创建新的排序数组。

```kt
[1, 3, 3, 4, 5, 7, 9]
[9, 7, 5, 4, 3, 3, 1]

```

这是示例的输出。

## Kotlin 二维数组

在 Kotlin 中，我们可以创建二维数组。

`KotlinArrayTwoDim.kt`

```kt
package com.zetcode

fun main() {

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

    println(Arrays.deepToString(array))
}

```

该示例通过将`intArrayOf()`函数调用嵌套到`arrayOf()`函数中来创建二维数组。

```kt
[[1, 2], [3, 4], [5, 6, 7]]

```

这是输出。

## Kotlin 数组过滤

使用`filter()`方法，我们可以过滤数组中的数据。

`KotlinArrayFilter.kt`

```kt
package com.zetcode

fun main() {

    val nums = arrayOf(1, -2, 3, 4, -5, 7)

    nums.filter { e -> e > 0 }.forEach { e -> print("$e ") }
}

```

本示例创建一个正负整数数组。 `filter()`方法仅用于拾取正值。

```kt
1 3 4 7 

```

这是输出。

## Kotlin 数组查找元素

我们可以使用`find()`和`findLast()`找到元素。

`KotlinArrayFind.kt`

```kt
package com.zetcode

fun main() {

    val nums = intArrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9)

    val firstEven = nums.find { it % 2 == 0 }
    println("The first even value is: $firstEven")

    val lastEven = nums.findLast { it % 2 == 0 }
    println("The last even value is: $lastEven")
}

```

该示例在数组中查找第一个和最后一个偶数值。

```kt
The first even value is: 2
The last even value is: 8

```

这是输出。

## Kotlin 数组归约

归约是将数组值聚合为单个值的终端操作。 `reduce()`方法对累加器和数组中的每个元素（从左到右）应用一个函数，以将其减小为单个值。

`KotlinArrayReduce.kt`

```kt
package com.zetcode

fun main() {

    val nums = intArrayOf(2, 3, 4, 5, 6, 7)

    val total = nums.reduce { product, next -> product * next }

    println(total)
}

```

我们使用`reduce()`方法从数组元素计算乘积。

```kt
val total = nums.reduce { product, next -> product * next }

```

`product`是累加器，`next`是数组中的下一个值。

```kt
5040

```

这是输出。

## Kotlin 数组`all()`

如果所有元素都匹配给定谓词，则`all()`方法返回`true`。

`KotlinArrayAll.kt`

```kt
package com.zetcode

fun main() {

    val nums = intArrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9)

    val hasAllEvens = nums.all { it % 2 == 0 }

    if (hasAllEvens) {

        println("The array contains only even values")
    } else {

        println("The array contains odd values")
    }
}

```

该示例检查数组元素是否全部为偶数。

```kt
The array contains odd values

```

该数组包含一些奇数值。

## Kotlin 数组`any()`

如果至少一个元素与给定谓词匹配，则`any()`方法返回`true`。

`KotlinArrayAny.kt`

```kt
package com.zetcode

fun main() {

    val nums = intArrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9)

    val hasEvenVals = nums.any { it % 2 == 0 }

    if (hasEvenVals) {

        println("The array contains even values")
    } else {

        println("The array does contain even values")
    }
}

```

该示例检查数组元素是否包含任何偶数值。

```kt
The array contains even values

```

这是输出。

在本教程中，我们介绍了 Kotlin 数组。 您可能也对相关教程感兴趣： [Kotlin 列表教程](/kotlin/lists/)， [Kotlin 设置教程](/kotlin/sets/)， [Kotlin 映射教程](/kotlin/maps/)或列出[所有 Kotlin 教程](/all/#kotlin) ]。