android开发之&android中的swift，kotlin集合（七）

/** 
* Array数组 
*
/fun main(args: Array<String>) {    
    var nollstations = arrayOf("嘉定北","徐家汇","南翔","桃浦新村","徐家汇","上海西站","罗山路","迪士尼","嘉定新城","徐家汇","桃浦新村")     
    /**     
    * 数组可以使用count()方法或size属性获取元素个数     
    */    
    println(nollstations.count())    
    println(nollstations.size)    
    /**     
    * 获取车站名中首个、第二个、第三个以及最后一个名字     
    * 第六个元素怎么获取nollstations[6]     
    */    
    println(nollstations.first())    
    println(nollstations.component1())    
    println(nollstations.component2())    
    println(nollstations.component3())    
    println(nollstations.component4())    
    println(nollstations.component5())    
    println(nollstations.last())    
    /**     
    * 检查是否包含某个元素，contains方法     
    */    
    println(nollstations.contains("嘉定北"))//true    
    /**     
    * 丢弃元素系列：drop、dropWhile和dropLast、dropLastWhile     
    */    
    println(nollstations.drop(1))    
    println(nollstations.dropWhile { it.isEmpty() })    
    println(nollstations.dropLast(1))    
    println(nollstations.dropLastWhile { it.isEmpty() })    
    /**     
    * 查找模式：find     
    */    
    //找到车站名中包含"迪"的首个元素（可能不止一个匹配项）    
    println(nollstations.find { it.contains("迪") })//迪士尼    
    //查找最后一个匹配项    
    println(nollstations.findLast { it.contains("嘉") })//嘉定新城    
    /**     
    * 把整个数组输出一个元素逗号分割形式的字符串     
    */    
    println(nollstations.joinToString())//嘉定北,徐家汇,南翔,桃浦新村,徐家汇,上海西站,罗山路,迪士尼 ,嘉定新城,徐家汇,桃浦新村    
    //在每一个站名后加"站"    
    println(nollstations.joinToString { it + "站" })//嘉定北站,徐家汇站,南翔站,桃浦新村站,徐家汇站,上海西站站,罗山路站,迪士尼站 ,嘉定新城站,徐家汇站,桃浦新村站    
    //test    
    println(nollstations.joinToString(separator = ",",prefix = "地铁11号线",limit = 4))//地铁11号线：嘉定北,徐家汇......    
    /**     
    * 取出元素系列，丢掉元素系列     
    */    
    println(nollstations.take(2))//[嘉定北，徐家汇]    
    println(nollstations.takeLast(3))//[嘉定新城，徐家汇，桃浦新村]    
    println(nollstations.drop(4))//[徐家汇，上海西站，罗山路，迪士尼，嘉定新城，徐家汇，桃浦新村]    
    println(nollstations.dropLast(5))//[嘉定北，徐家汇，南翔，桃浦新村，徐家汇，上海西站]    
    /**     
    * 切割数组sliceArray方法，把指定索引范围内的元素取出     
    */    
    println(nollstations.sliceArray(2..5).joinToString())//南翔，桃浦新村，徐家汇，上海西站    
    /**     
    * 反转数组：reverse()将自身元素首尾顺序颠倒     
    * reversed和reversedArray返回一个倒序后的新List和数组，原数组顺序不变     
    */    
    println(nollstations.reversed().joinToString())//"桃浦新村","徐家汇","嘉定新城","迪士尼","罗山路","上海西站","徐家汇","桃浦新村","南翔","徐家汇","嘉定北"    
    println(nollstations.reversedArray().joinToString())//"桃浦新村","徐家汇","嘉定新城","迪士尼","罗山路","上海西站","徐家汇","桃浦新村","南翔","徐家汇","嘉定北"    
    /**     
    * 数组排序：sortedArray和sortedDescending方法     
    * 对文本类型的数组排序意义不大，适合数字型数组     
    */    
    val numbers = arrayOf(0,-999,100,33,-2,3000)    
    println(numbers.sortedArray().joinToString())//-999，-2，0，33，100，3000    
    println(numbers.sortedArrayDescending().joinToString())//3000，100，33，0，-2，-999    
    /**     
    * 加强版排序：sortedBy和sortedByDescending方法     
    */    
    //地铁名按长度升序或降序排列    
    println(nollstations.sortedBy { it.length })    
    println(nollstations.sortedByDescending { it.length })//[]    
    /**     
    * 数组变形：map方法，可以把一种数组转换成另一种类型     
    * 把数字型数组转换成字符串类型，并加前缀     
    */    
    println(numbers.map { it -> "数字：" +it })//数字0，数字-999  ......    
    /**     
    * 筛选器：filter方法，根据条件把匹配的元素抽出来。如抽出数组中的偶数元素     
    */    
    println(numbers.filter { it % 2 == 0 })//0，100，-2，3000    
    /**     
    * 最大值和最小值     
    */    
    println(numbers.max())//3000    
    println(numbers.min())//-999    //地铁11号线站名里最长的一个    
    println(nollstations.maxBy { s -> s.length })//桃浦新村    
    /**     
    * 唯一化：distinct方法，跟Set的特性有异曲同工之妙     
    */    
    //返回一个删除了重复元素的新数组：    
    println(nollstations.distinct())    
    //加强版：distinctBy方法：只返回长度不同的字符串，其余的忽略    
    println(nollstations.distinctBy { s -> s.length })    
    /**     
    * 判定系列     
    */    
    //（1）all方法，给一个条件，检查全体元素是否满足，满足返回true    
    //数组中所有数字是否大于0    
    println(numbers.all { it > 0 }) //false    
    //（2）与all相对应的是any方法，只要有一个元素满足条件，即返回true    
    println(numbers.any { it < 0})//true    
    //(3)所有元素都不满足条件返回true    
    println(numbers.none { it == 0 })//false    
    /**     
    * 计算系列     
    * Sum、sumBy、average、求和、增强求和、求平均值     
    */    
    println(numbers.sum())//2132    
    println(numbers.sumBy { 10_000 + it })//62132    
    println(numbers.average())//355.3333333333    
    /**     
    * 集成系列     
    */    
    //（1）reduce方法，把所有元素集成为一个值，可以视为针对String型数组的sum方法    
    println(nollstations.reduce{ s1,s2 -> s1 + "," + s2 })
    //s1,s2分别代表数组找那个的一个元素和其下一个元素    
    //打印：嘉定北，徐家汇，南翔，桃浦新村，徐家汇，上海西站，罗山路，迪士尼，嘉定新城，徐家汇，桃浦新村     
    //(2)reduce方法的姊妹reduceRight方法，这个妹妹是个右撇子，从右开始算，功能都一样    
    println(nollstations.reduceRight{ s1,s2 -> s2 + "," + s1 })    //打印：桃浦新村，徐家汇，嘉定新城，迪士尼，罗山路，上海西站，徐家汇，桃浦新村，南翔，徐家汇，嘉定北     
    //(3)fold和flodRight方法，加前缀的reduce和加后缀的reduceRight    
    println(nollstations.fold("地铁11号线站点"){ s1,s2 -> s1 + "," + s2 })    
    println(nollstations.foldRight("是地铁11号线的站点。"){ s1,s2 -> s1 +"," + s2 })      
    /**     
    * 合成系列，主要处理两个数组间的合成     
    */    
    //（1）plus方法    
    val numbers2 = arrayOf(2,3,4,5,9,-988,-20)    
    val newStations = arrayOf("嘉定北","嘉定新城","花桥")    
    val twoNumbersArray = numbers.plus(numbers2)    
    val nolltotalStations= nollstations.plus(newStations)    
    println(twoNumbersArray.joinToString())//0,-999,100,33,-2,3000,2,3,4,5,9,-988,-20    
    println(nolltotalStations.joinToString())    
    //(2)使用+运算符，与plus方法完全等价    
    println((numbers + numbers2).joinToString())//0,-999,100,33,-2,3000,2,3,4,5,9,-988,-20    
    println((nollstations + newStations).joinToString())    
    //(3)zip方法，配对，把两个数组的元素配对组成一个新数组，不能配对的(一方数组长度较大，另一方较小，较大数组多余的元素不能配对)被舍弃    
    println(twoNumbersArray.zip(nolltotalStations))    //打印：[（0，嘉定北），（-999，徐家汇），（100，南翔），（33，桃浦新村），（-2，徐家汇），（3000，上海西站），    // （2，罗山路），（3，迪士尼），（4，嘉定新城），（5，徐家汇），（9，桃浦新村），（-988，嘉定北），（-20，嘉定新城）]     
    //加强版zip配对    
    println(twoNumbersArray.zip(nolltotalStations){ s1,s2 -> "$s1" + ":" + s2 })    //[0:嘉定北，-999：徐家汇，100：南翔，33：桃浦新村，-2：徐家汇，3000：上海西站，2：罗山路，3：迪士尼，4：嘉定新城，5：徐家汇，9：桃浦新村，-988：嘉定北，-20：嘉定新城]}

/** 
* Mutable可变列表 
*/
fun main(args: Array<String>) {    
    val nollNewsStations = mutableListOf("嘉定北","徐家汇","南翔","桃浦新村","徐家汇","上海西站","罗山路","迪士尼","徐家汇","桃浦新村")    
    /**     
    * 往末尾增加新元素：add方法     
    */    
    nollNewsStations.add("嘉定新城")    
    println(nollNewsStations)//打印："嘉定北","徐家汇","南翔","桃浦新村","徐家汇","上海西站","罗山路", "迪士尼","徐家汇","桃浦新村","嘉定新城"    
    /**     
    * 可以添加另一个List，Array，Set等只要看起来是序列的：addAll方法     
    */    
    nollNewsStations.addAll(nollNewsStations)    
    println(nollNewsStations)    
    /**     
    * 移除一个元素：remove元素     
    */    
    //把第一个匹配的元素从list中移除，如果指定元素不存在，也不会报错    
    nollNewsStations.remove("嘉定北")    
    println(nollNewsStations)    
    /**     
    * 移除指定位置的元素：removeAt方法     
    */    
    nollNewsStations.removeAt(1)    
    println(nollNewsStations)    
    /**     
    * 替换指定位置的元素：set或下标方法     
    */    
    nollNewsStations.set(0,"南翔")    
    nollNewsStations[2] = "祁连山路"    
    println(nollNewsStations)    
    /**     
    * 取子列表类似Array的sliceArray方法：subList方法：例如：去第4个~第10个元素     
    */    
    val subStations = nollNewsStations.subList(3,9)    
    println(subStations)    
    /**     
    * 丢弃系列：drop、dropLast、dropLastWhile、dropWhile。用法参考数组     
    * 不同于remove方法，drop系列方法不会对MutableList本身产生任何影响     
    */     
    /**     
    * 清空：可以用clear或者removeAll方法     
    */    
    nollNewsStations.clear()    
    println(nollNewsStations)    
    nollNewsStations.removeAll(nollNewsStations)    
    println(nollNewsStations) 
}

/** 
* Set 
*/
fun main(args: Array<String>) {    
    val mainLine = setOf("迪士尼","徐家汇","桃浦新村","南翔","马陆","嘉定新城")    
    val sublineJd = setOf("嘉定新城","嘉定西","嘉定北")    
    val sublineKs = setOf("嘉定新城","上海赛车场","安亭","花桥")     //size或count()，isEmpty()、检查是否包含某个元素，contains、转换为数组，toTypedArray()    
    /**     
    * Set两大特性：包含关系和Set间的运算关系     
    * 子集和父集：如果一个集合中所有的元素在另一个集合B中，那么可以称A是B的子集，也就是说B包含A或A包含于B。可以用containsAll方法检查     
    */    
    println(mainLine.containsAll(sublineJd))//false    
    //两个Set可以用"+"融合成一个    
    println((mainLine + sublineJd).containsAll(sublineJd))//true    
    println((mainLine + sublineJd).containsAll(mainLine))//true     
    /**     
    * 两个集合间的运算：交集、差集、并集、补集     
    */    
    //交集：在2个集合都包含的元素    
    println(mainLine.intersect(sublineJd)) //嘉定新城    
    println(mainLine.intersect(sublineKs)) //嘉定新城    
    println(sublineJd.intersect(sublineKs))//嘉定新城    
    //差集：从一个集合中排除与另一个集合交集的部分    
    println(mainLine.subtract(sublineJd))//[迪士尼，徐家汇，桃浦新村，南翔，马陆]    
    println(mainLine.subtract(sublineKs))//[迪士尼，徐家汇，桃浦新村，南翔，马陆]    
    println(mainLine.subtract(sublineKs))//[嘉定西，嘉定北]    
    //并集：2个集合合并成一个新集合，重复的元素只会留下一份    
    println(mainLine.union(sublineJd).union(sublineKs))//[迪士尼，徐家汇，桃浦新村，南翔，马陆，嘉定新城，嘉定西，嘉定北，上海赛车场，安亭，花桥]    
    //补集：并集去除交集后的部分    
    println(mainLine.union(sublineJd) - mainLine.intersect(sublineJd))//[迪士尼，徐家汇，桃浦新村，南翔，马陆，嘉定西，嘉定北]    
    println(mainLine.union(sublineKs) - mainLine.intersect(sublineKs))//[迪士尼，徐家汇，桃浦新村，南翔，马陆，上海赛车场，安亭，花桥]
}

/** 
* MutableSet * 与MutableList非常相似，特点是大小可变，类型不可变 
*/
fun main(args: Array<String>) {    
    val mainLine = setOf("迪士尼","徐家汇","桃浦新村","南翔","马陆","嘉定新城")    
    val sublineJd = setOf("嘉定新城","嘉定西","嘉定北")    
    val sublineKs = setOf("嘉定新城","上海赛车场","安亭","花桥")    
    val mutableMainline = mainLine.union(sublineJd).union(sublineKs).toMutableSet()    
    /**     
    * 在末尾增加元素：add方法     
    */    
    mutableMainline.add("光明路")    
    println(mutableMainline)    
    /**     
    * 添加另一个集合：addAll方法     
    */    
    val newsLines = setOf("昌吉东路","上海汽车城")    
    mutableMainline.addAll(newsLines)    
    println(mutableMainline)    
    /**     
    * 移除一个元素：remove方法     
    */    
    mutableMainline.remove("光明路")    
    println(mutableMainline)    
    /**     
    * 移除另一个集合：removeAll方法     
    */    
    mutableMainline.removeAll(newsLines)    
    println(mutableMainline)
}

/** 
* Map 
*/
fun main(args: Array<String>) {    
    var airports = mapOf<String,String>(Pair("PVG","上海浦东国际机场"),
                Pair("DXB","asdfsdfs"),
                Pair("CDG","Aeroport de Paris-Charles-de-Gaulle"),Pair("LAX","Los Angeles International Airport"),
                Pair("MUC","FlughafenMunchen"),
                Pair("CGH","Aeroporto de Sao Paulo"),
                Pair("LHR","London Heathrow Airport"),
                Pair("MAD","Aeropuerto Adolfo Suarez,Madrid-Barajas"),
                Pair("TPE","桃园国际机场"),
                Pair("ICN","思密达"),
                Pair("HND","羽田空港"))    
    /**     
    * 获取某个key对应的value：get、getOrDefault，或者下标方法     
    */    
    println(airports.get("PVG"))//上海浦东国际机场    
    println(airports.getOrDefault("PVg","不存在此机场代码或未添加！请检查！"))//不存在此机场    
    println(airports["LAX"])//Los Angeles International Airport    
    println(airports["DXB"])//asdfsdfs    
    /**     
    * 获取所有的key：keys属性     
    */    
    println(airports.keys)//[PVG,DEB,CDG,LAX,MUC,CGH,LHR,MAD,TPE,ICN,HND]    
    /**     
    * 获取所有的value：values属性     
    */    
    println(airports.values)    
    /**     
    * 获取所有的条目：entries属性     
    */    
    println(airports.entries)    
    /**     
    * 检查key和value存在情况：containsKey和containsValue方法     
    */    
    println(airports.containsKey("PVG"))        //true    
    println(airports.containsValue("Los Angeles Airport"))//false    
    /**     
    * 筛选器，filter方法     
    */    
    //筛选机场名中含"Airport"字段的，以筛选出英文国家的机场    
    println(airports.filter { it.value.contains("Airport") })    
    //更方便的key、value筛选器：filterKeys、filterValues方法    
    println(airports.filterValues { it.contains("机场") })    
    println(airports.filterKeys { it.contains("C") })    
    /**     
    * filterNot是filter的变种，把不符合条件的筛选出来     
    * 变形函数，map方法     
    * Map的map，听起来有点绕     
    */    
    val newAirportsDescriptionInChinese = airports.map { "机场代码："+it.key + ",机场全称："+it.value }    
    println(newAirportsDescriptionInChinese)    
    //只对key变形，mapKeys    
    val newKeyAirports = airports.mapKeys { "机场代码："+ it.key }    
    println(newKeyAirports)    
    //只对value变形，mapValues    
    val newAirportsNameDescription = airports.mapValues { "机场全称："+it.value }    
    println(newAirportsNameDescription)    
    /**     
    * 极值函数     
    */    
    //最大值依据，maxBy方法。如求机场全称最长的    
    println(airports.maxBy { it.value.length })    
    //最小值依据，minBy方法 如：在现有机场的基础上加上外星传送站    
    val airportsInfutrue = airports + mapOf<String,String>(Pair("M","月球静海传送站"), Pair("P","冥王星史普尼克爱心区"))    
    println(airportsInfutrue.minBy { it.key.length })    
    /**     
    * 排序：toSortedMap方法，默认按Key来排序     
    * 按机场代码的字母来升序来排列     
    */    
    println(airportsInfutrue.toSortedMap())    
    /**     
    * 转换成其他类型的集合     
    */    
    //toList转换成普通键值对的List    
    println(airportsInfutrue.toList())    
    //转换成可变Map、toMutableMap方法    
    val airports2 = airportsInfutrue.toMutableMap()    
    println(airports2)
}

/** 
* MutableMap 
*/
fun main(args: Array<String>) {    
    var airports = mapOf<String,String>(Pair("PVG","上海浦东国际机场"),
            Pair("DXB","asdfsdfs"),            
            Pair("CDG","Aeroport de Paris-Charles-de-Gaulle"),            
            Pair("LAX","Los Angeles International Airport"),            
            Pair("MUC","FlughafenMunchen"),            
            Pair("CGH","Aeroporto de Sao Paulo"),            
            Pair("LHR","London Heathrow Airport"),            
            Pair("MAD","Aeropuerto Adolfo Suarez,Madrid-Barajas"),            
            Pair("TPE","桃园国际机场"),            
            Pair("ICN","思密达"),            
            Pair("HND","羽田空港"))    
    val airportsInfutrue = airports + mapOf<String,String>(Pair("M","月球静海传送站"), 
            Pair("P","冥王星史普尼克爱心区"))    
    val airports2 = airportsInfutrue.toMutableMap()    
    /**     
    * 添加或更新     
    */    
    airports2["PVG"] = "上海市浦东国际机场"    
    airports2["DLC"] = "大连周水子机场"//    
    airports2.putIfAbsent("MARS","火星奥林匹斯山山麓传送站")    
    airports2.put("PVG","浦东机场")    
    /**     
    * 添加其他Map     
    * putAll或+=操作符，两者是等价的     
    */    
    val airportsInfuture3 = mapOf<String,String>(Pair("M31","仙女座星系"),
            Pair("PROXIMA","比邻星a-1"))    
    airports2 += airportsInfuture3    
    println(airports2)    
    /**     
    * 移除键值对     
    * remove方法     
    */    
    airports2.remove("PVG")    
    println(airports2)    
    /**     
    * 清空Map     
    */    
    airports2.clear()    
    println(airports2)
}

/** 
* 集合类型共性详解 
*/
fun main(args: Array<String>) {    
    /**     
    * 1、集合类型Collection     
    * (1)Iterable:这是父类，意思是可迭代的、可被重复操作的。任何继承了此接口的类，都意味着实现了一个其中元素可以被迭代的序列     
    * (2)MutableIterable:支持在迭代过程中移除自身元素的Iterable
    * (3)Collection:此类代表了一组元素的通用集合。我们可以通过各种函数来访问集合，如返回集合大小、是否为空、是否包含某个元素或一组元素。所有这些对集合的操作仅仅是请求数据。因为集合类型是不可变的
    * (4)MutableCollection:一个支持添加和移除自身元素的Collection，他提供了额外的功能，如：add、remove或clear     
    * (5)List:代表了一组有序元素的集合，因为有序，可以通过为止请求对应的元素，使用get函数或快捷的下表中括号方法
    * (6)MutableList：是一个支持添加和移除元素的list
    * (7)Set：一个无序的，但其中元素并不重复的集合
    * (8)MutableSet:一个支持添加和删除元素的Set
    * (9)Map：键值对的集合。其中的键具有唯一性，也就是说一个map里不能有两个一样的键     
    * (10)MutableMap:一个支持添加和移除元素的Map     
    */     

    /**     
    * 2、集合类型的操作     
    * (1)聚合系     
    */    
    //any:返回true，只要其中一个元素满足判定条件    
    val list = listOf(1,2,3,4,5,6)    
    println(list.any { it % 2 == 0 })//true    
    println(list.any { it > 8 })//false    
    //all:返回true，如果所有元素满足条件    
    println(list.all { it < 8 })//true    
    println(list.all { it % 2 == 0 })//false    
    //count：返回匹配条件的元素数目    
    println(list.count { it % 2 == 0 })//3    
    //fold：提供一个初始值，并描述从第一个到最后一个元素如何依次与这个初始值计算的操作，从而实现累计    
    println(list.fold(0){total,next -> total + next})//21    
    println(list.fold(0){total,next -> total * next})//1440    
    //foldRight:与fold一样，但顺序是从最后一个元素到第一个    
    println(list.foldRight(2){total,next -> total *next})//1440    
    //forEach:对每个元素执行指定的操作    
    list.forEach { print(it) }//123456    
    //forEachIndexed：与forEach相似，但是可以获取元素的索引    
    list.forEachIndexed { index, value ->  println("位置${index}的值是${value}")}    
    //max：获取最大的元素，如果没有元素则返回null    
    println(list.max())//6    
    //maxBy：给定函数操作后产生最大值的那个元素，没有元素则返回null    
    println(list.maxBy { -it })//1    
    //min：返回最小的元素，没有元素则返回null    
    println(list.min())//1    
    //minBy：给定函数操作后产生最小值的那个元素，没有元素则返回null    
    println(list.minBy { -it })//6    
    //none：返回true，如果没有元素满足条件    
    println(list.none { it % 8 == 0 })//true    
    //reduce：与flod相似，但不需要初始值。描述从第一个到最后一个元素如何依次计算的操作，从而实现累计    
    println(list.reduce { total, next -> total + next })//21    
    //reduceRight：与reduce类似，但顺序是从最后一个元素开始    
    println(list.reduceRight { total, next -> total + next })//21    
    //sumBy：返回经过处理过的元素的和    
    println(list.sumBy { it % 2 })//所有元素取余数后的和     
    /**     
    * (2)筛选系     
    */    
    //drop：把头n个元素丢弃后的所有元素返回    
    println(list.drop(3))//4，5，6    
    //dropWhile：把头几个满足条件的元素丢弃后返回    
    println(list.dropWhile { it < 3 })//3，4，5，6    
    //dropLast：把从尾倒数n个元素丢弃后返回    
    println(list.dropLast(3))//1,2,3    
    //dropLastWhile:把最后几个满足条件的元素丢弃后返回    
    println(list.dropLastWhile { it > 3 })//1,2,3    
    //filter：返回满足条件的所有元素    
    println(list.filter { it % 2 == 0 })//2,4,6    
    //filterNot：返回不满足条件的所有元素    
    println(list.filterNot { it % 2 == 0 })//1,3,5    
    //filterNotNull:返回所有非null元素，array不存在null在其中，几乎没机会用到此方法     
    //slice：切割，按指定索引或索引范围内的元素    
    println(list.slice(listOf(0,2,4)))//1,3,5    
    println(list.slice(0..2))//1,2,3    
    //take:返回n个元素。与drop相对    
    println(list.take(3))//1,2,3    
    //takeLast：返回从尾倒数n个元素，与dropLast相对    
    println(list.takeLast(3))//4,5,6    
    //takeWhile:返回满足条件的头n个元素    
    println(list.takeWhile { it < 3 })//1,2      
    /**     
    * (3)映射系或称变型系列     
    */    
    //flatMap：迭代集合的所有元素，为每一个元素生成一个新的集合，最后把所有集合摊平合并到一个集合里    
    println(list.flatMap { listOf(it,it + 1) })//1,2,2,3,3,4,4,5,5,6,6,7    
    //groupBy：分组，返回一个原集合按条件判断函数分组后的map    
    println(list.groupBy { if (it % 2 == 0) "偶数" else "奇数" })//奇数=[1，3，5]，偶数=[2，4，6]    
    //map：返回一个对每个元素变换后的新集合    
    println(list.map { it * 3 })//3,6,9,12,15,18    
    //mapIndexed:在map的基础上，引入集合的索引供变换使用        
    println(list.mapIndexed { index, i -> index * i })//0,2,6,12,20,30    
    //mapNotNull:对所有非null元素进行变换，使用机会比较少      
    /**     
    * (4)元素操作     
    */    
    //contains:如果找到此元素返回true    
    println(list.contains(3))//true    
    //elementAt：返回指定索引处的元素，如果索引不再集合的索引范围内，则抛出IndexOutOfBoundsException，即索引越界异常错误    
    println(list.elementAt(2))//3    //ecementAtOrElse:如果索引越界则调用函数的结果    
    println(list.elementAtOrElse(8){it * 2})//16    
    //elementAtOrNull：如果索引越界则返回null    
    println(list.elementAtOrNull(8))//null    
    //first：返回第一个满足条件的元素    
    println(list.first { it % 2 == 0 })//2    
    //firstOrNull:找不到满足条件的元素则返回null    
    println(list.firstOrNull { it % 8 == 0 })//null    
    //indexOf：返回元素的首个索引，如果元素不存在返回-1    
    println(list.indexOf(5))//4    
    //indexOfFirst:返回满足条件的元素的首个索引，如果元素不存在返回-1    
    println(list.indexOfFirst { it % 2 == 0 })//1    
    //indexOfLast：返回满足调剂那的元素的最后索引，如果元素不存在返回-1    
    println(list.indexOfLast { it % 2 == 0 })//5    
    //last:返回最后一个满足条件的元素    
    println(list.last { it % 2 == 0 })//6    
    //lastIndexOf:返回元素的最后索引，如果元素不存在返回-1    
    val list2 = listOf(1,1,2,2,3,3,3,4)    
    println(list2.lastIndexOf(3))//6    
    //lastOrNull：返回最后一个满足条件的元素，如果元素不存在返回-1    
    println(list.lastOrNull { it %8 == 0 })//null    
    //single:返回满足条件的单元素，如果没找到或者多个元素满足条件则抛出异常错误    
    println(list.single { it % 5 == 0 })//5    
    //singleOrNull:返回满足条件的单元素，如果没找到或者多个元素满足条件则返回null    
    println(list.singleOrNull{ it % 2 == 0 })//null      
    /**     
    * 生成系     
    */    
    //partition:把集合拆开分成1对集合，第一个集合满足条件，另一个集合是不满足条件的    
    println(list.partition { it % 2 == 0 })//[2,4,6],[1,3,5]    
    //zip：把两个集合已相同索引顺序进行配对，组成一个新集合。新集合以最短的那个集合索引为准    
    println(list.zip(listOf(100,101,102)))//[(1,100),(2,101),(3,102)]      
    /**     
    * 排序系     
    */    
    //reversed：返回逆转顺序后的所有元素    
    println(list.reversed())//6,5,4,3,2,1    
    //sorted:返回（升序）排序后的所有元素    
    val list3 = listOf(3,4,1,0,2)    
    println(list3.sorted())//0,1,2,3,4    
    //sortedBy：返回按特定比较器（升序）排序后的所有元素    
    println(list.sortedBy { it % 3 })//3,6,1,4,2,5    按除3取余数后的大小排列    
    //sortedDescending：返回（降序）排序后的所有元素    
    println(list3.sorted())//4,3,2,1,0    
    //sortedByDescending：返回按特定比较器（降序）排序后的所有元素    
    println(list.sortedBy { it % 3})//2，5，1，4，3，6
}