Array為例

Kotlin中，常見的集合函數(shù)的運用。以Array數(shù)組的操作為例，先來直接看一下代碼~

/**
 * 數(shù)組詳解 
 */
class TestArray {

    private var _array:Array<Int>

    /**
     * 初始化方法 
     */
    init {
        _array = arrayOf(1, 3, 2, 3, 4)
    }

    /**
     * 除去重復(fù)元素，返回List列表 
     */
    fun distinct() {
        println("TestArray.distinct()   ->   " + this._array.distinct())
    }

    /**
     * 追加元素 
     */
    fun plus() {
        println("TestArray.plus()   ->   " + this._array.plus(arrayOf(5, 6)).toList())
    }

    /**
     * 倒序
     */
    fun reverse() {
        println("TestArray.reverse()   ->   " + this._array.reversed())
    }

    /**
     * 切片 
     */
    fun slice() {
        println("TestArray.slice()   ->   " + this._array.slice(IntRange(0, 2)))
    }

    /**
     * 切片 
     */
    fun sort() {
        this._array.sort()
        println("TestArray.sort()   ->   " + this._array.toList())
    }

    /**
     * 對象排序 
     */
    fun sortWith() {
        var array1 = ArrayEntity()
        array1.id = 2

        var array2 = ArrayEntity()
        array2.id = 1

        var array3 = ArrayEntity()
        array3.id = 3

        var array = arrayOf(array1, array2, array3)
        array.sortWith(Comparator { o1, o2 -> o2.id.compareTo(o1.id) })
        for (entity in array)
            println("TestArray.sortWith()   ->   " + entity.id)
    }

    /**
     * 如果至少有一個元素與指定條件相符，則返回true 
     */
    fun any() {
        println("TestArray.any()   ->   " + this._array.any())
        var tmp:Array<Int> = arrayOf()
        println("TestArray.any()   ->   " + tmp.any())
    }

    /**
     * 判斷是否有指定的元素存在，有就返回true 2
     */
    fun contains() {
        println("TestArray.contains()   ->   " + this._array.contains(1))
    }

    /**
     * 刪除前兩位 
     */
    fun drop() {
        var tmp:Array<Int> = arrayOf(1, 2, 3, 4)
        println("TestArray.drop()   ->   " + tmp.drop(2))

        // dropWhile  這個方法的意思是返回所有元素列表，但不包括第一個滿足指定條件的元素。
        // 但看了里面的源代碼，寫得有點問題 2017/4/1 17:03
        // tmp.dropWhile { it > 3 }
    }

    /**
     * 刪除后兩位 
     */
    fun dropLast() {
        var tmp:Array<Int> = arrayOf(1, 2, 3, 4)
        println("TestArray.dropLast()   ->   " + tmp.dropLast(2))
    }

    /**
     * 提取前兩位元素返回 
     */
    fun take() {
        var tmp:Array<Int> = arrayOf(1, 2, 3, 4)
        println("TestArray.take()   ->   " + tmp.take(2))
    }

    /**
     * 提取最后兩位元素返回 
     */
    fun takeLast() {
        var tmp:Array<Int> = arrayOf(1, 2, 3, 4)
        println("TestArray.takeLast()   ->   " + tmp.takeLast(2))
    }

    /**
     *過濾掉剩下條件為true的元素 
     */
    fun filter() {
        println("TestArray.filter()   ->   " + this._array.filter { it % 2 == 0 })
    }

    /**
     * 過濾掉剩下條件為true的元素，另一種寫法 
     */
    fun filterTo() {
        var list = ArrayList<Int>()
        println("TestArray.filterTo()   ->   " + this._array.filterTo(list, { it % 2 == 0 }))
    }

    /**
     * 過濾掉條件為true的元素 
     */
    fun filterNotTo() {
        var list = ArrayList<Int>()
        println("TestArray.filterNotTo()   ->   " + this._array.filterNotTo(list, { it % 2 == 0 }))
    }

    /**
     * 返回所有元素列表，但不包括null元素 
     */
    fun filterNotNull() {
        println("TestArray.filterNotNull()   ->   " + this._array.filterNotNull())
    }

    /**
     * 根據(jù)指定索引，獲取元素 
     */
    fun elementAt() {
        println("TestArray.elementAt()   ->   " + this._array.elementAt(2))
    }

    /**
     * 查找元素，可以判斷是否存在該元素，沒有的話返回null 
     */
    fun find() {
        println("TestArray.find()   ->   " + this._array.find { it == 3 })
    }

    /**
     * 遍歷 
     */
    fun forEach() {
        println("TestArray.forEach()   ->   " + this._array.toList())
        this._array.forEach({
            println(it)
        })
    }

    /**
     * 對每一個元素操作后，返回一個新的列表 
     */
    fun map() {
        println("TestArray.forEach()   ->   " + this._array.map { it * 2 })
    }

    /**
     * 從第一元素到最后一個元素運算的累加，acc每一個元素累計后的值，i當(dāng)前的元素 
     */
    fun reduce() {
        println("TestArray.reduce()   ->   " + this._array.reduce { acc, i -> acc + i })
    }

    /**
     * 返回最小的元素 
     */
    fun min() {
        println("TestArray.min()   ->   " + this._array.min())
    }

    /**
     * 返回最大的元素 
     */
    fun max() {
        println("TestArray.max()   ->   " + this._array.max())
    }

}

/**
 * 實體 
 */
class ArrayEntity {
    var id:Int = 0
    var name:String? = null
}

以上的操作基本上是最常見的集合函數(shù)運用，我們再來看下各個函數(shù)的描述，是我整合網(wǎng)上的資源的，如下：

集合

雖然，我們可以只使用Java集合，然而Kotlin提供了一套很好的本機接口:

Iterable ：父類。任何類繼承這個接口就表示可以遍歷序列的元素。
MutableIterable ：在迭代期間支持移除項目的迭代。
Collection ：這個類表示元素的泛型集合。我們可以訪問函數(shù)：返回集合尺寸、集合是否為空、包含一項或一組。由于集合是不可變的，這類集合的所有方法只能請求數(shù)據(jù)。
MutableCollection ：支持添加和移除元素的Collection。它提供額外的函數(shù)，如：add、remove或clear等等。
List ：或許這是最常用的集合。這表示有序的元素泛型集合。由于是有序的，我們可以用get函數(shù)，按照項目的位置請求項目。
MutableList ：支持添加和移除元素的List。
Set ：不支持重復(fù)元素的無序元素集合。
MutableSet ：支持添加和移除元素的Set。
Map ：key-value（鍵-值）對集合。在映射表（map）中key（鍵）是唯一的，就是說在一個映射表中不能有兩對有相同的key。
MutableMap ：支持添加和移除元素的Map。

1、 聚合操作

        /**
         * 1.聚合操作
         */
        //1.any
        // 如果至少有一個元素與指定條件相符，則返回true。
        val list = listOf(1,2,3,4,5)
//        assertTrue(list.any { it % 2 == 0 })
        assertTrue(list.any { it %2 == 0 })
        assertFalse(list.any { it > 10 })

        //2.all
        // 如果所有元素與指定條件相符，則返回true
        assertTrue(list.all { it < 10 })
        assertFalse(list.all { it % 2 == 0 })

        //3.conut
        //返回指定條件相符的元素個數(shù)
        assertEquals(3,list.count { it % 2 == 0 })

        //4.fold
        //將對集合從第一個到最后一個元素的操作結(jié)果進行累加，并加上初始值
        assertEquals(25,list.fold(4){total,next -> total + next})

        //5.foldRight
        //同fold，但是，是從最后一個元素到第一個元素。
        assertEquals(25,list.foldRight(4){total,next -> total + next})
        //6.forEach
        //對每個元素執(zhí)行指定的操作
        list.forEach { println(it) }

        //7.forEachIndexed
        //同forEach，不過同時還獲得元素的索引
        list.forEachIndexed { index, value -> println("position $index contains a $value")  }

        //8.max
        //返回最大元素，如果沒有元素，則返回null
        assertEquals(6,list.max())

        //9.maxBy
        //返回使指定函數(shù)產(chǎn)生最大的第一個元素。如果沒有元素，則返回null
        // The element whose negative is greater
        assertEquals(1,list.maxBy { -it })

        //10.min
        //返回最小元素，如果沒有元素，則返回null
        assertEquals(1,list.min())

        //11.minBy
        //返回使指定函數(shù)產(chǎn)生最小值的第一個元素，如果沒有元素，則返回null
        assertEquals(1,list.minBy { -it })

        //12.none
        //如果沒有元素與指定條件相符，則返回true
        // No elements are divisible by 7
        assertTrue(list.none { it % 7 == 0 })

        //13.同fold，但是不包括初始值，只是講對集合從第一個元素到最后一個元素的操作結(jié)果進行累加
        assertEquals(21,list.reduce { total, next -> total + next })

        //14.reduceRight
        //同reduce，但是，是從最后一個元素到第一個元素
        assertEquals(21,list.reduceRight { total, next -> total + next })

        //15.sumBy
        //返回集合中元素進轉(zhuǎn)換函數(shù)產(chǎn)生之的總和
        assertEquals(3,list.sumBy { it % 2 })

2、 篩選操作

        /**
         * 2、 篩選操作
         */
        //1.drop 返回所有元素列表，但不包括前N個元素。
        assertEquals(listOf(5,6),list.drop(4))

        //2.dropWhile 返回所有元素列表，但是不包括第一個滿足指定條件的元素
        assertEquals(listOf(3,4,5),list.dropWhile { it < 3 })

        //3.dorpLastWhile 返回所有元素列表，但是不包括滿足指定條件的最后一個
        assertEquals(listOf(1,2,3,4),list.dropLastWhile { it > 4 })

        //4.filter 返回所有與指定條件相符的元素列表
        assertEquals(listOf(2,4,6),list.filter { it % 2 == 0})

        //5.filterNot 返回與指定條件不符的所有元素列表
        assertEquals(listOf(1,3,5),list.filterNot { it % 2 == 0 })

        //6. filterNotNull
        assertEquals(listOf(1,2,3,4), list.filterNotNull())

        //7.slice 返回指定索引的元素列表
        assertEquals(listOf(2,4,5),list.slice(listOf(1,3,4)))

        //8.take 返回前N個元素列表
        assertEquals(listOf(2,4,5),list.take(2))

        //9.takeLast 返回最后N個元素列表
        assertEquals(listOf(5,6),list.takeLast(2))

        //10.takeWhile 返回滿足指定條件第一個元素列表
        assertEquals(listOf(1,2),list.takeWhile { it < 3 })

3、生成操作

1.merge
返回一個列表，該列表由兩個集合中有相同索引元素經(jīng)轉(zhuǎn)換函數(shù)轉(zhuǎn)換而組成的。這個列表的長度是最大集合的長度。
val list = listOf(1, 2, 3, 4, 5, 6)
val listRepeated = listOf(2, 2, 3, 4, 5, 5, 6)
assertEquals(listOf(3, 4, 6, 8, 10, 11), list.merge(listRepeated) { it1, it2 -> it1 + it2 })

2.partition
將原始集合拆分一對集合，一個集合包含判斷條件為true的元素，另一個集合包含判斷條件為false的元素。
assertEquals(Pair(listOf(2, 4, 6), listOf(1, 3, 5)), list.partition { it % 2 == 0 })

3.plus
返回一個列表，該列表包含原始集合的所有元素和指定集合的所有元素。由于函數(shù)名稱原因，我們可以使用“+”操作符。
assertEquals(listOf(1, 2, 3, 4, 5, 6, 7, 8), list + listOf(7, 8))

4.zip
返回一個列表，該列表由兩個集合中相同索引元素建立的元素對。這個列表長度為最短集合的長度。
assertEquals(listOf(Pair(1, 7), Pair(2, 8)), list.zip(listOf(7, 8)))

4、 排序操作

1.reverse
返回逆序元素列表。
val unsortedList = listOf(3, 2, 7, 5)
assertEquals(listOf(5, 7, 2, 3), unsortedList.reverse())

2.sort
返回所有元素分類排序列表。
assertEquals(listOf(2, 3, 5, 7), unsortedList.sort())

3.sortBy
返回所有元素列表，其元素通過特定的比較器分類排序。
assertEquals(listOf(3, 7, 2, 5), unsortedList.sortBy { it % 3 })

4.sortDescending
返回所有元素分類排序列表，其順序為降序。
assertEquals(listOf(7, 5, 3, 2), unsortedList.sortDescending())

5.sortDescendingBy
返回所有元素的分類排序列表，其順序為通過特定排序函數(shù)結(jié)果的降序。
assertEquals(listOf(2, 5, 7, 3), unsortedList.sortDescendingBy { it % 3 })

PS

感謝網(wǎng)友的提供，能讓我也一同新的學(xué)習(xí)~~~