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
}