/**
* 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
}