kotlin中的List集合類

 

kotlin中的List集合類

2018年02月09日 14:30:07 秦川小將 閱讀數：8714 標籤： kotlin List Android 更多

我的分類： Android

 

版權聲明：本文爲博主原創文章，未經博主容許不得轉載。 https://blog.csdn.net/mjb00000/article/details/79298165

Kotlin的集合分類：

• 可變集合類（Mutable）
• 不可變集合類（Immutable）。

集合類存放的都是對象的引用，而非對象自己，咱們一般說的集合中的對象指的是集合中對象的引用。集合類型主要有List(列表)，Set(集)，Map(映射)。

kotlin中List與Java同樣都是實現了Collection接口，源碼以下：

public interface List<out E> : Collection<E> {
    // Query Operations override val size: Int override fun isEmpty(): Boolean override fun contains(element: @UnsafeVariance E): Boolean override fun iterator(): Iterator<E> // Bulk Operations override fun containsAll(elements: Collection<@UnsafeVariance E>): Boolean // Positional Access Operations /** * Returns the element at the specified index in the list. */ public operator fun get(index: Int): E // Search Operations /** * Returns the index of the first occurrence of the specified element in the list, or -1 if the specified * element is not contained in the list. */ public fun indexOf(element: @UnsafeVariance E): Int /** * Returns the index of the last occurrence of the specified element in the list, or -1 if the specified * element is not contained in the list. */ public fun lastIndexOf(element: @UnsafeVariance E): Int // List Iterators /** * Returns a list iterator over the elements in this list (in proper sequence). */ public fun listIterator(): ListIterator<E> /** * Returns a list iterator over the elements in this list (in proper sequence), starting at the specified [index]. */ public fun listIterator(index: Int): ListIterator<E> // View /** * Returns a view of the portion of this list between the specified [fromIndex] (inclusive) and [toIndex] (exclusive). * The returned list is backed by this list, so non-structural changes in the returned list are reflected in this list, and vice-versa. * * Structural changes in the base list make the behavior of the view undefined. */ public fun subList(fromIndex: Int, toIndex: Int): List<E> }

1.建立不可變List

使用listOf函數來構建一個不可變的List(只讀的List)，listOf這個構建函數有下面3個重載函數。
源碼：

/** Returns a new read-only list of given elements. The returned list is serializable (JVM). */ public fun <T> listOf(vararg elements: T): List<T> = if (elements.size > 0) elements.asList() else emptyList() /** Returns an empty read-only list. The returned list is serializable (JVM). */ @kotlin.internal.InlineOnly public inline fun <T> listOf(): List<T> = emptyList() /** * Returns an immutable list containing only the specified object [element]. * The returned list is serializable. */ @JvmVersion public fun <T> listOf(element: T): List<T> = java.util.Collections.singletonList(element)

這些函數建立的List都是是隻讀的，不可變的、可序列化的。其中，

• listOf()用於建立沒有元素的空List
• listOf(vararg elements: T)用於建立擁有多個元素的List
• listOf(element: T)用於建立只有一個元素的List

建立一個空List

val mList: List<Int> = listOf() println(mList)

• 1
• 2

打印輸出：

[]

建立只有一個元素的List

val mList: List<Int> = listOf(0) println(mList)

• 1
• 2

打印輸出：

[0]

建立多個元素的List

val mList: List<Int> = listOf(1, 3, 5, 7, 9) println(mList)

• 1
• 2

打印輸出：

[1, 3, 5, 7, 9]

2.建立可變集合

List的可變集合有兩種，源碼以下：

/** Returns an empty new [MutableList]. */ @SinceKotlin("1.1") @kotlin.internal.InlineOnly public inline fun <T> mutableListOf(): MutableList<T> = ArrayList() /** Returns an empty new [ArrayList]. */ @SinceKotlin("1.1") @kotlin.internal.InlineOnly public inline fun <T> arrayListOf(): ArrayList<T> = ArrayList() /** Returns a new [MutableList] with the given elements. */ public fun <T> mutableListOf(vararg elements: T): MutableList<T> = if (elements.size == 0) ArrayList() else ArrayList(ArrayAsCollection(elements, isVarargs = true)) /** Returns a new [ArrayList] with the given elements. */ public fun <T> arrayListOf(vararg elements: T): ArrayList<T> = if (elements.size == 0) ArrayList() else ArrayList(ArrayAsCollection(elements, isVarargs = true))

 

• mutableListOf(): MutableList
• arrayListOf(): ArrayList

在MutableList中，除了繼承List中的那些函數外，另外新增了add/addAll、remove/removeAll/removeAt、set、clear、retainAll等更新修改的操做函數。

MutableList源碼：

public interface MutableList<E> : List<E>, MutableCollection<E> {
    // Modification Operations override fun add(element: E): Boolean override fun remove(element: E): Boolean // Bulk Modification Operations override fun addAll(elements: Collection<E>): Boolean /** * Inserts all of the elements in the specified collection [elements] into this list at the specified [index]. * * @return `true` if the list was changed as the result of the operation. */ public fun addAll(index: Int, elements: Collection<E>): Boolean override fun removeAll(elements: Collection<E>): Boolean override fun retainAll(elements: Collection<E>): Boolean override fun clear(): Unit // Positional Access Operations /** * Replaces the element at the specified position in this list with the specified element. * * @return the element previously at the specified position. */ public operator fun set(index: Int, element: E): E /** * Inserts an element into the list at the specified [index]. */ public fun add(index: Int, element: E): Unit /** * Removes an element at the specified [index] from the list. * * @return the element that has been removed. */ public fun removeAt(index: Int): E // List Iterators override fun listIterator(): MutableListIterator<E> override fun listIterator(index: Int): MutableListIterator<E> // View override fun subList(fromIndex: Int, toIndex: Int): MutableList<E> }

 

可變集合示例

val mList = mutableListOf(2, 4, 6, 8, 10) println(mList) mList.add(0, 0) // 在下標爲0的地方添加一個0元素 println(mList)

打印輸出：

[2, 4, 6, 8, 10]
[0, 2, 4, 6, 8, 10]

toMutableList()轉換函數：

若是已經有了一個不可變的List，想把他轉換成可變的List，可直接調用轉換函數toMutableList()

// 不可變集合 val mList: List<Int> = listOf(1, 3, 5, 7, 9) // 調用toMutableList()函數進行轉換 val mMutableList = mList.toMutableList() // 調用可變函數的add()方法 mMutableList.add(11) // 打印輸出 println(mMutableList)

打印輸出：

[1, 3, 5, 7, 9, 11]

3.遍歷List元素

使用Iterator迭代器遍歷List元素

val mList: List<Int> = listOf(0, 1, 2, 3, 4, 5) val mIndex = mList.iterator() while (mIndex.hasNext()) { println(mIndex.next()) }

打印輸出：

0
1
2
3
4
5

使用for循環遍歷List元素

val mList: List<Int> = listOf(0, 1, 2, 3, 4, 5) for (i in mList.indices){ println(mList[i]) }

打印輸出：

0
1
2
3
4
5

逆向循環

for (i in mList.size downTo 0){ println("$i") }

打印輸出：

6
5
4
3
2
1
0

使用函數withIndex()遍歷List元素

val mList: List<Int> = listOf(0, 1, 2, 3, 4, 5) for ((index, value) in mList.withIndex()) { println("下標 = $index\t值 = $value") }

打印輸出：

下標 = 0 值 = 0
下標 = 1 值 = 1
下標 = 2 值 = 2
下標 = 3 值 = 3
下標 = 4 值 = 4
下標 = 5 值 = 5

使用forEach遍歷List元素

val mList: List<Int> = listOf(0, 1, 2, 3, 4, 5) mList.forEach { println(it) }

打印輸出：

0
1
2
3
4
5

4.常見的List元素操做函數

add, remove, set, clear

這幾個操做符與Java中的List同樣。

retainAll

取兩個集合交集:

val mList1 = mutableListOf(0, 1, 3, 5, 7, 9) val mList2 = mutableListOf(0, 2, 4, 6, 8, 10) mList1.retainAll(mList2) println(mList1)

打印輸出：

[0]

contains(element: T): Boolean

判斷集合中是否有指定元素，有就返回true，不然返回false 。

val mList = mutableListOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10) // 取集合中存在的元素 println(mList.contains(5)) // 取集合中不存在的元素 println(mList.contains(20))

打印輸出：

true
false

elementAt(index: Int): T

查找下標對應的元素，若是下標越界會拋IndexOutOfBoundsException。

val mList = mutableListOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10) println("下標爲5的元素值:${mList.elementAt(5)}")

打印輸出：

下標爲5的元素值:5

elementAtOrElse(index: Int, defaultValue: (Int) -> T): T

查找下標對應元素，若是越界會根據方法返回默認值。

val mList = mutableListOf(0,1,2,3,4,5) println(mList.elementAtOrElse(5, {0})) println(mList.elementAtOrElse(6, {0}))

打印輸出：

5
0

elementAtOrNull(index: Int): T?

查找下標對應元素，若是越界就返回null

val mList = mutableListOf(0,1,2,3,4,5) println(mList.elementAtOrNull(6))

打印輸出：

null

first()

返回集合第1個元素，若是是空集，拋出異常java.util.NoSuchElementException: List is empty.。

val mList = mutableListOf(0,1,2,3,4,5) println(mList.first())

打印輸出：

0

firstOrNull(): T?

返回集合第1個元素，若是是空集, 對空指針異常處理的函數，若是集合爲空，則返回null。

val mList = listOf<Int>() println(mList.firstOrNull())

打印輸出：

null

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

返回符合條件的第一個元素，沒有則拋異常NoSuchElementException 。

val mList = listOf(1, 2, 3) println(mList.first { it % 2 == 0 })

打印輸出：

2

對應的有針對異常處理的函數firstOrNull(predicate: (T) -> Boolean): T? ，返回符合條件的第一個元素，沒有就返回null

indexOf(element: T): Int

返回指定元素的下標，沒有就返回-1

val mList = listOf(1, 2, 3) println(mList.indexOf(3)) println(mList.indexOf(0))

打印輸出：

2
-1

indexOfFirst(predicate: (T) -> Boolean): Int

返回第一個符合條件的元素的下標，沒有就返回-1 。

val mList = listOf(1, 2, 3) println(mList.indexOfFirst { it == 2})

集合中元素2對應的下標是1，因此打印輸出：

1

indexOfLast(predicate: (T) -> Boolean): Int

返回最後一個符合條件的元素下標，沒有就返回-1 。

val mList = listOf("java for android", "gradle for android", "kotlin for android") println(mList.indexOfLast { it.contains("android")})

打印輸出：

2

集合元素kotlin for android的下標恰好對應的是2 。

last()

返回集合最後一個元素，空集則拋出異常NoSuchElementException。

val mList = listOf("java for android", "gradle for android", "kotlin for android") println(mList.last())

打印輸出：

kotlin for android

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

返回符合條件的最後一個元素，沒有就拋NoSuchElementException

val mList = listOf("java for android", "gradle for android", "kotlin for android") println(mList.last { it.contains("android") })

打印輸出：

kotlin for android

lastOrNull(predicate: (T) -> Boolean): T?

返回符合條件的最後一個元素，沒有就返回null

val mList = listOf("java for android", "gradle for android", "kotlin for android") println(mList.lastOrNull { it.contains("android") }) println(mList.lastOrNull { it.contains("JavaScript") })

打印輸出：

kotlin for android
null

lastIndexOf(element: T): Int

返回符合條件的最後一個元素的下標，沒有就返回-1

val mList = listOf("java for android", "android", "kotlin", "android") println(mList.lastIndexOf("android")) println(mList.lastIndexOf("JavaScript"))

打印輸出：

3
-1

single(): T

該集合若是隻有1個元素，則返回該元素。爲空時會拋出NoSuchElementException 異常，存在多個元素時會拋 IllegalArgumentException異常。

val mList = listOf(1) println(mList.single())

打印輸出：

1

singleOrNull(): T?

返回符合條件單個元素, 若是集合爲空或者有多個元素，則返回null

val mList = listOf(1, 2) println(mList.singleOrNull())

打印輸出：

null

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

返回符合條件的單個元素，若有沒有符合的拋異常NoSuchElementException，或超過一個的拋異常IllegalArgumentException。

val mList = listOf(1) println(mList.single { it == 1 }) println(mList.single { it == 2 })

打印輸出：

1
Exception in thread 「main」 java.util.NoSuchElementException: Collection contains no element matching the predicate.
at KotlinUtilsTestKt.main(KotlinUtilsTest.kt:48)

singleOrNull(predicate: (T) -> Boolean): T?

返回符合條件單個元素，若是未找到符合的元素或找到多個元素，則返回null。

val mList = listOf(1, 2) println(mList.singleOrNull { it == 2 })

打印輸出：

2

5.List集合運算的基本函數

any(): Boolean

判斷集合元素，若是集合爲空，返回false, 集合中存有一個或多個元素時返回true

val mList1 = arrayListOf(1, 2, 3, 4, 5) val mList2: ArrayList<Int> = arrayListOf() println(mList1.any()) println(mList2.any())

打印輸出：

true
false

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

判斷集合元素，若是集合爲空或者沒有符號條件的元素返回false, 集合中存有一個或多個元素符合條件時返回true

val mList = arrayListOf(1, 2, 2, 3, 4, 5) println(mList.any { it == 2})

打印輸出：

true

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

當且僅當該集合中全部元素都知足條件時，返回true；不然都返回false。

val mList = arrayListOf(0, 2, 4, 6, 8) println(mList.all { it % 2 == 0 })

打印輸出：

true

val mList = arrayListOf(0, 1, 2, 3, 4) println(mList.all { it % 2 == 0 })

打印輸出：

false

none(): Boolean

若是集合中沒有元素，則返回true，不然返回false。

val mList = arrayListOf(0, 1, 2, 3, 4) println(mList.none())

打印輸出：

false

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

若是集合中沒有符合匹配條件的元素，返回true，不然返回false 。

val mList = arrayListOf(0, 1, 2, 3, 4) println(mList.none { it == 5 })

打印輸出：

true

count(): Int

返回集合元素個數

val mList = arrayListOf(0, 1, 2, 3, 4) println(mList.count())

打印輸：

5

count(predicate: (T) -> Boolean): Int

返回符合匹配條件的元素的個數

val mList = arrayListOf(0, 1, 2, 3, 4) println(mList.count { it % 2 == 0 })

打印輸出：

3

max, min 查詢最大，最小元素，空集返回null

max函數定義

public fun <T : Comparable<T>> Iterable<T>.max(): T? { val iterator = iterator() if (!iterator.hasNext()) return null var max = iterator.next() while (iterator.hasNext()) { val e = iterator.next() if (max < e) max = e } return max }

經過max函數源代碼定義看出，max函數是經過迭代器遍歷集合進行比較，返回最大元素。

min函數定義

public fun <T : Comparable<T>> Iterable<T>.min(): T? { val iterator = iterator() if (!iterator.hasNext()) return null var min = iterator.next() while (iterator.hasNext()) { val e = iterator.next() if (min > e) min = e } return min }

經過min函數源代碼定義看出，min函數也是經過迭代器遍歷集合進行比較，返回最小元素。

val mList = arrayListOf(0, 1, 2, 3) println(mList.max()) println(mList.min())

打印輸出：

3
0

6.過濾操做函數

take(n: Int): List

take函數是根據傳入的參數挑出該集合前n個元素的子集合

val mList = arrayListOf(0, 1, 2, 3) val mNewList = mList.take(2) println(mNewList)

打印mNewList集合元素：

[0, 1]

7.映射操做符

map(transform: (T) -> R): List

將集合中的元素經過轉換函數transform映射後的結果，存到一個集合中返回。

val mList = mutableListOf(1, 3, 2, 4) println(mList.map { it + 1 })

打印輸出：

[2, 4, 3, 5]

mapNotNull(transform: (T) -> R?)

遍歷集合每一個元素，獲得經過函數算子transform映射以後的值，剔除掉這些值中的null，返回一個無null元素的集合。

val mList = mutableListOf(1, null, 3, null, 2, 4) println(mList.mapNotNull { it })

打印輸出：

[1, 3, 2, 4]

8.排序操做符

reversed(): List

倒序排列集合元素。如:[1, 2, 7, 6, 4, 5]排列後爲:[5, 4, 6, 7, 2, 1]。

val mList = listOf(1, 3, 2, 4) println(mList.reversed())

打印輸出：

[4, 2, 3, 1]

sorted(): List和sortedDescending(): List

升序排序和降序排序。

val mList = listOf(1, 3, 2, 4) println(mList.sorted()) println(mList.sortedDescending())

打印輸出：

[1, 2, 3, 4]
[4, 3, 2, 1]

sortedBy和sortedByDescending

可變集合MutableList的排序操做。根據函數映射的結果進行升序排序和降序排序。

val mList = mutableListOf(1, 3, 2, 4) println(mList.sorted()) println(mList.sortedDescending())

打印輸出：

[1, 2, 3, 4]
[4, 3, 2, 1]

9.生產操做符

zip(other: Iterable): List

val mList3 = arrayListOf("x1", "x2", "x3", "x4") val mList4 = arrayListOf("y1", "y2", "y3") println(mList3.zip(mList4))

打印輸出：

[(x1, y1), (x2, y2), (x3, y3)]

plus(elements: Iterable): List

合併兩個List

val mList1 = arrayListOf(0, 1, 2, 3) val mList2 = arrayListOf(4, 5, 6, 7, 8) println(mList1.plus(mList2))

打印輸出：

[0, 1, 2, 3, 4, 5, 6, 7, 8]