亚洲成人视频区,一区二区日韩人妻

Kotlin 為數組添加了一個Array類，使用Array<T>來表示。

聲明和創(chuàng)建 Array

arrayOf(vararg elements: T): Array<T>
聲明時傳入所有元素
Kotlin 此時可以推斷出數組元素的類型，所以就不需要在 arrayOf() 函數上使用泛型來指定數組元素的類型。
arrayOfNulls(size: Int): Array<T?>
顯式指定數組的長度，數組全部初始化為 null
Kotlin 此時無法推斷出數組元素類型，所以需要在 arrayOfNulls() 函數上使用泛型來指定數組元素的類型。
emptyArray(): Array<T>
創(chuàng)建一個長度為0的空數組
Kotlin 此時無法推斷出數組元素類型，所以需要在 emptyArray() 函數上使用泛型來指定數組元素的類型。
Array<T> constructor(size: Int, init: (Int) -> T)
顯式指定數組的長度，并可通過 Lambda 表達式來計算個數組元素的值

// 創(chuàng)建包含指定元素的數組
val array1 = arrayOf("Java", "Kotlin", "Go") //["Java", "Kotlin", "Go"]
val intArray1 = arrayOf(1, 2, 400, -90) //[1, 2, 400, -90]

// 創(chuàng)建指定長度，元素為 null 的數組
val array2 = arrayOfNulls<String>(5) //[null, null, null, null, null]
val intArray2 = arrayOfNulls<Int>(10) //[null, null, null, null, null, null, null, null, null, null]

// 創(chuàng)建長度為0的空數組
val array3 = emptyArray<String>() //[]
val intArray3 = emptyArray<Int>() //[]

// 創(chuàng)建指定長度，并使用 Lambda 表達式來初始化元素的數組
val array4 = Array(6) {"Language $it"} //["Language 0", "Language 1", "Language 2", "Language 3", "Language 4", "Language 5"]
val intArray4 = Array(5) {it * 2 + 97} //[97, 99, 101, 103, 105]

當元素為基本類型的值時，Koltin 還為提供了以下8種實例：

實例	初始化
`ByteArray`	`byteArrayOf(vararg elements: Byte): ByteArray` `ByteArray constructor(size: Int, init: (Int) -> Byte)`
`ShortArray`	`shortArrayOf(vararg elements: Short): ShortArray` `ShortArray constructor(size: Int, init: (Int) -> Short)`
`IntArray`	`intArrayOf(vararg elements: Int): IntArray` `IntArray constructor(size: Int, init: (Int) -> Int)`
`LongArray`	`longArrayOf(vararg elements: Long): LongArray` `LongArray constructor(size: Int, init: (Int) -> Long)`
`CharArray`	`charArrayOf(vararg elements: Char): CharArray` `CharArray constructor(size: Int, init: (Int) -> Char)`
`FloatArray`	`floatArrayOf(vararg elements: Float): FloatArray` `FloatArray constructor(size: Int, init: (Int) -> Float)`
`DoubleArray`	`doubleArrayOf(vararg elements: Double): DoubleArray` `DoubleArray constructor(size: Int, init: (Int) -> Double)`
`BooleanArray`	`booleanArrayOf(vararg elements: Boolean): BooleanArray` `BooleanArray constructor(size: Int, init: (Int) -> Boolean)`

使用 Array 中的方法

all(predicate: (T) -> Boolean): Boolean

val array = arrayOf("Java", "Kotlin", "Go")
// 如果所有的元素都滿足給定的條件，則返回 true
println(array.all { it.length > 4 }) //false

any(predicate: (T) -> Boolean): Boolean

val array = arrayOf("Java", "Kotlin", "Go")
// 如果至少有一個元素滿足給定的條件，則返回 true
println(array.any { it.length > 4 }) //true

轉換成 List
asList(): List<T>

val array = arrayOf("Java", "Kotlin", "Go")
// 將該數組轉換成 List 集合
println(array.asList()) //[Java, Kotlin, Go]

轉換成 Map
associate(transform: (T) -> Pair<K, V>): Map<K, V>
associateTo(destination: M, transform: (T) -> Pair<K, V>): M
associateBy(keySelector: (T) -> K): Map<K, T>
associateBy(keySelector: (T) -> K, valueTransform: (T) -> V): Map<K, V>
associateByTo(destination: M, keySelector: (T) -> K): M
associateByTo(destination: M, keySelector: (T) -> K, valueTransform: (T) -> V): M

val array = arrayOf("Java", "Kotlin", "Go")
val map = mutableMapOf(10 to "TypeScript", 5 to "Swift")
// 使用 Lambda 表達式根據數組元素計算，返回 Map<K, V>
println(array.associate { it.length to "$it length" }) //{4=Java length, 6=Kotlin length, 2=Go length}
// 使用 Lambda 表達式根據數組元素計算，并添加到可變 map 集合中，返回修改后的 map
println(array.associateTo(map, { it.length to "$it length" })) //{10=TypeScript, 5=Swift, 4=Java length, 6=Kotlin length, 2=Go length}
// 使用 Lambda 表達式根據數組元素計算，返回 Map<K, V>，其中 V 是數組元素
println(array.associateBy { it.length }) //{4=Java, 6=Kotlin, 2=Go}
// 使用 Lambda 表達式根據數組元素計算，返回 Map<K, V>
println(array.associateBy({ it.length }, { "$it length" })) //{4=Java length, 6=Kotlin length, 2=Go length}
// 使用 Lambda 表達式根據數組元素計算，并添加到可變 map 集合中，返回修改后的 map
println(array.associateByTo(map, { it.length })) //{10=TypeScript, 5=Swift, 4=Java, 6=Kotlin, 2=Go}
// 使用 Lambda 表達式根據數組元素計算，并添加到可變 map 集合中，返回修改后的 map
println(array.associateByTo(map, { it.length }, { "$it length" })) //{10=TypeScript, 5=Swift, 4=Java length, 6=Kotlin length, 2=Go length}

計算數值型數組的平均值
average(): Double

val intArray = intArrayOf(2, 67, 6, -1)
// 計算數值型數組的平均值
println(intArray.average()) //18.5

二分查找（數組元素必須按照升序排序）
binarySearch(element: Int, fromIndex: Int = 0, toIndex: Int = size): Int

val intAscArray = intArrayOf(-1, 2, 6, 67)
val intArray = intArrayOf(2, 67, 6, -1)
// 用二分法查找元素在數組中出現的位置，要求數組中的元素按升序排列，否則無法得到正確的結果
println(intAscArray.binarySearch(6)) //2，由于數組元素是升序，故結果正確
println(intArray.binarySearch(6)) // -2，由于數組元素無序，故結果錯誤

包含
contains(element: T): Boolean

val array = arrayOf("Java", "Kotlin", "Go")
// 判斷該數組是否包含某個元素，可使用 in !in 運算符執(zhí)行
println(array.contains("Java")) //true
println("Swift" in array) //false

相等比較
contentEquals(other: Array<out T>?): Boolean

val array = arrayOf("Java", "Kotlin", "Go")
// 比較兩個數組是否相等
val otherArray = arrayOf("Java", "Kotlin", "Go")
println(array.contentEquals(otherArray)) //true

轉換為字符串
contentToString(): String

val array = arrayOf("Java", "Kotlin", "Go")
// 把數組轉換成字符串
println(array.contentToString()) // "[Java, Kotlin, Go]"

復制數組
copyOf(): Array<T>
copyOf(newSize: Int): Array<T?>
copyOfRange(fromIndex: Int, toIndex: Int): Array<T>

val array = arrayOf("Java", "Kotlin", "Go")
// 復制一個新數組，若指定 size：<= 原size，取前 size 個；> 原size，不足的后面補0（數值類型），false（布爾類型），null（引用類型）
println(array.copyOf().asList()) //[Java, Kotlin, Go]
println(array.copyOf(2).asList()) //[Java, Kotlin]
println(array.copyOf(5).asList()) //[Java, Kotlin, Go, null, null]
// 復制一個新數組，指定區(qū)間范圍，不可超過原數組的 size
println(array.copyOfRange(1, 2).asList()) //[Kotlin]

獲取元素個數
count(predicate: (T) -> Boolean): Int
count(): Int

val array = arrayOf("Java", "Kotlin", "Go")
// 返回該數組給定 Lambda 條件的元素個數，若不指定參數，則返回數組中的元素個數，與 size 相同
println(array.count { it.length > 4 }) //1
println(array.count()) //3

數組去重
distinct(): List<T>

val distinctArray = arrayOf("one", "two", "five", "one")
// 該方法用于去掉數組中的重復元素
println(distinctArray.distinct()) //[one, two, five]

刪除數組首位元素
drop(n: Int): List<T>
dropLast(n: Int): List<T>
dropWhile(predicate: (T) -> Boolean): List<T>
dropLastWhile(predicate: (T) -> Boolean): List<T>

val array = arrayOf("Java", "Kotlin", "Go")
// 去掉數組前面或后面 n 個元素，n >= size 時，返回空集合
println(array.drop(1)) //[Kotlin, Go]
println(array.drop(4)) //[]
println(array.dropLast(1)) //[Java, Kotlin]
println(array.dropLast(4)) //[]
// 去掉數組前面或后面的某些元素，直到不滿足條件為止
println(array.dropWhile { it.length >= 4 }) //[Go]
println(array.dropLastWhile { it.length < 4 }) //[Java, Kotlin]

覆蓋元素
fill(element: T, fromIndex: Int = 0, toIndex: Int = size): Unit

val array = arrayOf("Java", "Kotlin", "Go")
// 將數組從 fromIndex 到 toIndex 索引的元素賦值為 element
array.fill("Swift", 0, array.size)
println(array.asList()) //[Swift, Swift, Swift]

過濾集合
filter(predicate: (T) -> Boolean): List<T>
filterTo(destination: C, predicate: (T) -> Boolean): C
filterIndexed(predicate: (index: Int, T) -> Boolean): List<T>
filterIndexedTo(destination: C, predicate: (index: Int, T) -> Boolean): C
filterIsInstance(): List<@kotlin.internal.NoInfer R>
filterIsInstance(klass: Class<R>): List<R>
filterIsInstanceTo(destination: C): C
filterIsInstanceTo(destination: C, klass: Class<R>): C
filterNot(predicate: (T) -> Boolean): List<T>
filterNotTo(destination: C, predicate: (T) -> Boolean): C
filterNotNull(): List<T>
filterNotNullTo(destination: C): C

val array = arrayOf("Java", "Kotlin", "Go")
// filterXxx，一系列過濾數組元素的方法
// 根據 Lambda 表達式中的條件進行過濾
println(array.filter { it.length > 4 }) //[Kotlin]
// 根據 Lambda 表達式中的條件進行過濾，并添加到 C 中
val otherList = mutableListOf("C++")
println(array.filterTo(otherList, { it.length > 4 })) //[C++, Kotlin]
// 根據 Lambda 表達式中的條件進行過濾，index：索引 s：元素值
println(array.filterIndexed { index, s -> index >=1 && s.length > 1 }) //[Kotlin, Go]
// 根據 Lambda 表達式中的條件進行過濾，index：索引 s：元素值，并添加到另個可變集合 c 中，最終返回 c
val filterOtherArray = mutableListOf("TypeScript", "JavaScript")
println(array.filterIndexedTo(filterOtherArray, { index, s -> index >=1 && s.length > 1 })) //[TypeScript, JavaScript, Kotlin, Go]
// filterIsInstance 返回數組中是 R 的實例的元素，適用于一個抽象類集合中有多種子元素的情況
val animals = arrayOf(
    Dog("Dog 1"),
    Cat("Cat 1"),
    Bird("Bird 1"),
    Dog("Dog 2")
)
println(animals.filterIsInstance<Dog>()) //[Dog 1, Dog 2]
println(animals.filterIsInstance(Dog::class.java)) //[Dog 1, Dog 2]
// filterIsInstanceTo 返回數組中是 R 的實例的元素，并添加到 C 中
val dogs = mutableListOf(
    Dog("Dog a"),
    Dog("Dog b")
)
println(animals.filterIsInstanceTo(dogs)) //[Dog a, Dog b, Dog 1, Dog 2]
println(animals.filterIsInstanceTo(dogs, Dog::class.java)) //[Dog a, Dog b, Dog 1, Dog 2, Dog 1, Dog 2]
// 返回一個與給定條件不匹配的 List 集合，與 filter 方法取反
println(animals.filterNot { it.name == "Dog 1" }) //[Cat 1, Bird 1, Dog 2]
// 返回一個與給定條件不匹配的 List 集合，并添加到 C 中，與 filterTo 方法取反
val otherAnimals = mutableListOf(
    Dog("Dog a"),
    Cat("Cat a"),
    Bird("Bird a"),
    Dog("Dog b")
)
println(animals.filterNotTo(otherAnimals, { it.name == "Dog 1" })) //[Dog a, Cat a, Bird a, Dog b, Cat 1, Bird 1, Dog 2]
// 過濾掉 null，返回一個沒有 null 的 List
val nullableArray = arrayOf("aaa", "bbb", null, "ccc")
println(nullableArray.filterNotNull()) //[aaa, bbb, ccc]
// 過濾掉 null，并添加到 C 中，返回 C
val otherNullableList = mutableListOf("AAA", null, "BBB")
println(nullableArray.filterNotNullTo(otherNullableList)) //[AAA, null, BBB, aaa, bbb, ccc]

abstract class Animal(var name: String)

class Dog(name: String) : Animal(name) {
    override fun toString(): String = name
}

class Cat(name: String) : Animal(name) {
    override fun toString(): String = name
}

class Bird(name: String) : Animal(name) {
    override fun toString(): String = name
}

查找元素
find(predicate: (T) -> Boolean): T?
findLast(predicate: (T) -> Boolean): T?

val array = arrayOf("Java", "Kotlin", "Go")
// findXxx 一系列用于查找元素的方法
println(array.find { it.length > 2 }) //Java
println(array.findLast { it.length > 2 }) //Kotlin

返回第一個/最后一個元素
first(): T
first(predicate: (T) -> Boolean): T
firstOrNull(): T?
firstOrNull(predicate: (T) -> Boolean): T?
last(): T
last(predicate: (T) -> Boolean): T
lastOrNull(): T?
lastOrNull(predicate: (T) -> Boolean): T?

val array = arrayOf("Java", "Kotlin", "Go")
// firstXxx（正序遍歷） lastXxx（倒序遍歷）
// 返回數組第一個元素，若是空數組，則會拋異常
println(array.first()) //Java
// 返回滿足條件的第一個元素，若都不滿足條件，則會拋異常
println(array.first { it.length > 2 }) //Java
// 返回數組第一個元素，若是空數組，則返回 null
println(array.firstOrNull()) //Java
// 返回滿足條件的第一個元素，若都不滿足條件，則返回 null
println(array.firstOrNull { it.length > 6 }) //null
// 返回數組最后一個元素，若是空數組，則會拋異常
println(array.last()) //Go
// 返回滿足條件的最后一個元素，若都不滿足條件，則會拋異常
println(array.last { it.length > 2 }) //Kotlin
// 返回數組最后一個元素，若是空數組，則返回 null
println(array.lastOrNull()) //Go
// 返回滿足條件的最后一個元素，若都不滿足條件，則返回 null
println(array.lastOrNull { it.length > 6 }) //null

增值運算
fold(initial: R, operation: (acc: R, T) -> R): R
foldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): R
foldRight(initial: R, operation: (T, acc: R) -> R): R
foldRightIndexed(initial: R, operation: (index: Int, T, acc: R) -> R): R
runningFold(initial: R, operation: (acc: R, T) -> R): List<R>
runningFoldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): List<R>

val array = arrayOf("Java", "Kotlin", "Go")
// 將元素作為參數傳入 operation 表達式后執(zhí)行計算，將結果作為下一個數組的 initial，直到執(zhí)行完所有元素，并返回最終值
// fold 正序遍歷 acc：增值器，s：元素
println(array.fold("", { acc, s -> s + acc })) //GoKotlinJava
// foldIndexed 正序遍歷 index：索引，acc：增值器，s：元素
println(array.foldIndexed("", { index, acc, s -> "$index$s$acc" })) //2Go1Kotlin0Java
// foldRight 倒序遍歷 s：元素，acc：增值器
println(array.foldRight("", { s, acc -> s + acc })) //JavaKotlinGo
// foldRightIndexed 倒序遍歷 index：索引，s：元素，acc：增值器
println(array.foldRightIndexed("", { index, s, acc -> "$index$s$acc" })) //0Java1Kotlin2Go
// runningFold 正序遍歷 acc：增值器，s：元素 返回 List
println(array.runningFold("", { acc, s -> s + acc })) //[, Java, KotlinJava, GoKotlinJava]
// runningFoldIndexed 正序遍歷 index：索引，acc：增值器，s：元素 返回 List
println(array.runningFoldIndexed("", { index, acc, s -> "$index$s$acc" })) //[, 0Java, 1Kotlin0Java, 2Go1Kotlin0Java]

獲取元素的索引
indexOf(element: T): Int
lastIndexOf(element: T): Int
indexOfFirst(predicate: (T) -> Boolean): Int
indexOfLast(predicate: (T) -> Boolean): Int

val array = arrayOf("Java", "Kotlin", "Go")
// 正序/倒序搜索元素 element 在數組中的索引
println(array.indexOf("Java")) //0
println(array.lastIndexOf("Java")) //0
// 正序/倒序搜索元素，當滿足條件時
println(array.indexOfFirst { it.isNotEmpty() }) //0
println(array.indexOfLast { it.isNotEmpty() }) //2

獲取元素的交集或并集
intersect(other: Iterable<T>): Set<T>
union(other: Iterable<T>): Set<T>

val array = arrayOf("Java", "Kotlin", "Go")
val otherMutableList = mutableListOf("Java", "Swift", "C++")
// 獲取兩個數組的交集
println(array.intersect(otherMutableList)) //[Java]
// 獲取兩個數組的并集
println(array.union(otherMutableList)) //[Java, Kotlin, Go, Swift, C++]

添加元素或數組
plus(element: T): Array<T>
plusElement(element: T): Array<T>
plus(elements: Collection<T>): Array<T>

val array = arrayOf("Java", "Kotlin", "Go")
// 添加元素或數組
println(array.plus("Dart").contentToString()) //[Java, Kotlin, Go, Dart]
println(array.plusElement("Dart").contentToString()) //[Java, Kotlin, Go, Dart]
println(array.plus(otherMutableList).contentToString()) //[Java, Kotlin, Go, Java, Swift, C++]

獲取最大/最小值
maxOrNull(): T?
minOrNull(): T?

val array = arrayOf("Java", "Kotlin", "Go")
// 按照自然排序規(guī)則，獲取數組中元素最大值/最小值
println(array.maxOrNull()) //Kotlin
println(array.minOrNull()) //Go

排序
sort(): Unit
sortWith(comparator: Comparator<in T>): Unit

val array = arrayOf("Java", "Kotlin", "Go")
// 數組排序，按自然排序
array.sort()
println(array.contentToString()) //[Go, Java, Kotlin]
// 數組排序，按自定義規(guī)則排序
array.sortWith { s1, s2 -> s2.length - s1.length }
println(array.contentToString()) //[Kotlin, Java, Go]

Array 的遍歷

for(item in array) { ... }
for-in 遍歷，遍歷元素
for(index in array.indices) { ... }
for-in 遍歷，遍歷下標，indices 方法返回數組的索引區(qū)間
for ((index, item) in array.withIndex()) { ... }
withIndex() 方法返回一個 Iterable 對象，該對象的所有元素都是 IndexedValue
array.forEach { ... }
forEach Lambda 表達式遍歷

val array1 = arrayOf("Java", "Kotlin", "Go")
// for-in 遍歷，遍歷元素
for (item in array1) {
    println(item)
}

// for-in 遍歷，遍歷下標
for (index in array1.indices) {
    println(array1[index])
}

// for-in 遍歷，使用 withIndex
for ((index, item) in array1.withIndex()) {
    println("第 $index 個元素是 $item")
}

// forEach 遍歷
array1.forEach {
    println(it)
}

多維數組

// 二維數組：所有元素都是一維數組，本質還是一維數組
val twoDimensionalArray = arrayOf(arrayOf(1, 2), arrayOf(3, 4), arrayOf(5, 6))
twoDimensionalArray.forEach {
    println(it.contentToString())
}
//[1, 2]
//[3, 4]
//[5, 6]

// 三維數組：所有元素都是二維數組，本質還是一維數組
val threeDimensionalArray = arrayOf(
    arrayOf(arrayOf(1, 2), arrayOf(3, 4), arrayOf(5, 6)),
    arrayOf(arrayOf(7, 8), arrayOf(9, 10), arrayOf(11, 12))
)
threeDimensionalArray.forEach {
    it.forEach { second ->
        println(second.contentToString())
    }
}
//[1, 2]
//[3, 4]
//[5, 6]
//[7, 8]
//[9, 10]
//[11, 12]

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

Kotlin-數組與集合-Array

Kotlin-數組與集合-Array

聲明和創(chuàng)建 Array

使用 Array 中的方法

Array 的遍歷

多維數組

友情鏈接更多精彩內容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九 欧美,1769亚洲,黄色成人av

Kotlin-數組與集合-Array

聲明和創(chuàng)建 Array

使用 Array 中的方法

Array 的遍歷

多維數組

友情鏈接更多精彩內容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av