摘要：可能是最流行的集合類型。它是一個范性有序的集合。一個無序并不支持重復的集合。接口繼承接口，集合中可以存放重復對象。集合類提供了，等高階函數去處理。我們聲明一個集合或者數組，可以轉換成相應類型的集合。調用轉換為可變集合。

不積跬步無以至千里,不積小流無以成江海

先看看Kotlin中for循環的遍歷

 fun  testList(){
        var StringVal = "12_12_13_15_a_b_c_d_yu_er"
        var ssArray = StringVal.split("_")
        var ss01 = ssArray[0]
        var ss02 = ssArray[1]
        var size =  ssArray.size
        println("ss01:   $ss01")
        println("ss02:   $ss02")
        println("size:$size")
        val items = listOf("apple", "banana", "kiwi")
        //迭代for循環
        for (item in ssArray){
            println("item:  $item")
        }

        for (item in ssArray)  println("item:  $item")


        //循環體可以是一個代碼塊:
        for (item : String in ssArray ){
            println("item:  $item")
        }

        //通過索引進行遍歷,for 可以循環遍歷任何提供了迭代器的對象。
        //如果你想要通過索引遍歷一個數組或者一個 list
        //注意這種"在區間上遍歷"會編譯成優化的實現而不會創建額外對象。
        for (i in ssArray.indices) {
            print(ssArray[i])
        }


        //這種"在區間上遍歷"會編譯成優化的實現而不會創建額外對象。或者你可以用庫函數 withIndex：
        fun forbetween(index :Int,value : Objects){
            for ((index,value) in ssArray.withIndex()){
                println("the element at $index is $value")
            }
        }
    }

，Kotlin針對集合進行了更加簡潔和有效的封裝

Iterable：父類。所有我們可以遍歷一系列的都是實現這個接口。

MutableIterable：一個支持遍歷的同時可以執行刪除的Iterables。

Collection：這個類相是一個范性集合。我們通過函數訪問可以返回集合的size、是否為空、是否包含一個或者一些item。這個集合的所有方法提供查詢，因為connections是不可修改的。

MutableCollection：一個支持增加和刪除item的Collection。它提供了額外的函數，比如add 、remove、clear等等。

List：可能是最流行的集合類型。它是一個范性有序的集合。因為它的有序，我們可以使用get函數通過position來訪問。

MutableList：一個支持增加和刪除item的List。

Set：一個無序并不支持重復item的集合。

MutableSet：一個支持增加和刪除item的Set。

Map：一個key-value對的collection。key在map中是唯一的，也就是說不能有兩對key是一樣的鍵值對存在于一個map中。

MutableMap：一個支持增加和刪除item的map。

比如： List是以線性方式管理物件集合，其可以很快的在任何地方進行增加和刪除元素。List接口繼承Collection接口，集合中可以存放重復對象。

對于接口的實現

Kotlin中可以這樣寫：

而在Java 中卻不能這樣寫：

        
        val list1 = listOf()           //返回的是kotlin的List，只讀
        val list2 = mutableListOf()    //返回的是kotlin的MutableList，可讀寫
        val list3 = arrayListOf()      //返回的是java的ArrayList，java的ArrayList是可讀寫的


        var setList = setOf()         //返回的是kotlin的set集合，一個無序并不支持重復item的集合 只讀
        var setMutableList   = mutableSetOf() //返回的是kotlin的set集合 MutableSet  可讀寫
        var hashSet = hashSetOf()   //返回的是java的set集合 hashSet  可讀寫

        var map = mapOf() //返回kotlin中的map，只讀
        mutableMapOf() // 返回的是kotlin中的hashmap集合，可讀可寫
        hashMapOf() //返回java中的hashmap 可讀可寫

        //eg:怎么取用
        list2.add(1)
        var first : Int = list2.first()
        list3.add(1)
        var first2 : Int = list3.first()

集合set:

set集合中的元素是不會有重復的，并且是亂序的。創建set需要使用setOf()，mutableSetOf()：

val set= setOf(
        "祖安",
        "皮爾特沃夫"
)
val mutableSet= mutableSetOf(
        "阿利斯塔",
        "希維爾"
)

Map:
Map是一個存放鍵和值的集合，每一個元素都包含鍵和值。Kotlin中Map和list一樣，也分為只讀和可變兩種Map。

創建Map時需要調用mapOf()，mutableMapOf()：

val map= mapOf(
        1 to "伊澤瑞爾", 2 to "雷克頓", 3 to "古拉加斯", 4 to "泰達米爾"
)
val hashMap= hashMapOf(
        1 to "伊澤瑞爾", 2 to "雷克頓", 3 to "古拉加斯", 4 to "泰達米爾"
)

map和hashMap的區別，這里就不說了，Java的基礎

val count=map.size  //獲取元素數量
val keys=map.keys   //返回map中key的集合
keys.forEach(::print)   //輸出Log：1,2,3,4
val values=map.values    //返回map中key的集合
values.forEach(::print)     //輸出Log：伊澤瑞爾,雷克頓,古拉加斯,泰達米爾
val entry=map.entries   //返回鍵/值對集合
entry.forEach{
    println("key: ${it.key} , value: ${it.value}")
}       //輸出key:1 , value:伊澤瑞爾  key:2...

val isEmpty=map.isEmpty()   //判斷集合是否為空 Boolean
val isContainsKey=map.containsKey(3)    //判斷集合中是否包含某個key
val isContainsValue=map.containsValue("雷克頓")    //判斷集合中是否包含某個value
val valueStr=map.get(2) //獲取指定key的元素值，沒有則返回null

上面說了map和list一樣是只讀的，可變的map需要使用mutableMap：

var mutableMapOf= mutableMapOf()
mutableMapOf.putAll(map)    //添加整個map
mutableMapOf.put(5,"拉克絲")   //添加指定key的value
mutableMapOf.remove(2)  //移除元素
mutableMapOf.clear()    //清空集合

很多情況下，函數和方法的名字和list的都是一樣的。

val list = listOf(1, 2, 3, 4, 5, 6)

list.any {//只要集合中的任何一個元素滿足條件(使得lambda表達式返回true)，any函數就返回true
    it >= 0
}
list.all {//集合中的全部元素都滿足條件(使得lambda表達式返回true)，all函數才返回true
    it >= 0
}
list.none {//若集合中沒有元素滿足條件（使lambda表達式返回true），則none函數返回true
    it < 0
}
list.count {//count函數的返回值為：集合中滿足條件的元素的總數
    it >= 0
}

//對所有元素求和
kotlinList.sum()

//將集合中的每一個元素代入lambda表達式，然后對lambda表達式的返回值求和
kotlinList.sumBy {
    it % 2
}

//在一個初始值的基礎上,從第一項到最后一項通過一個函數累計所有的元素
//accumulator的初始值為100，element從集合的第一個元素開始，lambda表達式的返回值就是accumulator的新值
kotlinList.fold(100) { accumulator, element ->
    accumulator + element / 2
}

//同fold，只是迭代的方向相反
kotlinList.foldRight(100) { accumulator, element ->
    accumulator + element / 2
}

//同fold，只是accumulator的初始值就是集合的第一個元素，element從第二個元素開始
kotlinList.reduce { accumulator, element ->
    accumulator + element / 2
}

//同reduce但方向相反：accumulator的初始值就是集合的最后一個元素，element從倒數第二個元素開始往前迭代
kotlinList.reduceRight { accumulator, element ->
    accumulator + element / 2
}

//遍歷所有元素
kotlinList.forEach {
    print(it)
}

//同forEach，只是可以同時拿到元素的索引
kotlinList.forEachIndexed { index, value ->
    println("position $index contains a $value")
}

//返回集合中最大的元素，集合為空(empty)則返回null
kotlinList.max()

//返回集合中使得lambda表達式返回值最大的元素，集合為空(empty)則返回null
kotlinList.maxBy { it }

//返回集合中最小的元素，集合為空(empty)則返回null
kotlinList.min()

//返回集合中使得lambda表達式返回值最小的元素，集合為空(empty)則返回null
kotlinList.minBy { it }

//返回一個新List，去除集合的前n個元素
kotlinList.drop(2)
//返回一個新List，去除集合的后n個元素
kotlinList.dropLast(2)
//返回一個新List，去除集合中滿足條件(lambda返回true)的第一個元素
list.dropWhile {
    it > 3
}
//返回一個新List，去除集合中滿足條件(lambda返回true)的最后一個元素
kotlinList.dropLastWhile {
    it > 3
}

val list = listOf(1, 2, 3, 4, 5, 6)
list.reversed() //返回一個顛倒元素順序的新集合
list.sorted() //返回一個升序排序后的新集合
list.sortedBy {//將每個元素代入lambda表達式，根據lambda表達式返回值的大小來對集合進行排序
    it*2
}

list.sortedDescending()//返回一個降序排序后的新集合
list.sortedByDescending {
    it*2
}

val list = listOf(1, 2, 3, 4, 5, 6)
val list2 = listOf(5, 6, 7, 8, 9, 0)

//拼接兩個集合，返回一個新集合
//本質是調用list.plus(list2)
list + list2

//把一個給定的集合分割成兩個list，一個list中是代入lambda表達式后返回true的元素，另一個list中是代入后返回false的元素
val (list3, list4) = list.partition {
    it % 2 == 0
}

//返回一個由pair組成的list，每一個pair由兩個集合中相同index的元素組成
val pairList: List> = list.zip(list2)

//unzip與zip的功能相反，將一個由pair組成的list分解成兩個list
val (list5, list6) = pairList.unzip()

當我們聲明一個集合，可以把這個集合根據調用集合類相應的高階函數來轉換成相應的數組。集合類提供了toIntArray()、toDoubleArray()、toFloatArray()、toBetArray()，toTypedArray等高階函數去處理。

Kotlin中，集合可分為不可變集合與可變集合。我們聲明一個集合或者數組，可以轉換成相應類型的集合。調用toXXX()轉換成不可變集合。調用toMutableXXX()轉換為可變集合。集合類提供了toList()、toMutableList()、toSet()、toMutableSet()、toHashSet()、toMap()等高階函數去處理

例如：

嗯，今天就提到這里，學習Kotlin還有很長的一段路走，一門新的語言需要一顆耐心，摒棄雜念，向前出發吧

推薦幾個學習的地址：

官網文檔：
http://kotlinlang.org/
runoob中文文檔
http://www.runoob.com/kotlin/...

Kotlin開發之旅《一》— 初學者Kotlin基礎必備

我的Android重構之旅：插件化篇

20+個很棒的Android開源項目

Kotlin已成為Android開發一級語言——這次你絕對不能錯過

在這里獲得的不僅僅是技術！