集合
1、使用数组
arrayOf ,并使用Array类中的属性与方法来处理他们内部的值
java中：
String [] strings = new String[4];
strings[0] = "an";
strings[1] = "array";
strings[2] = "of";
strings[3] = "strings";
//或者
strings = "an array of strings".split(" ");
kotlin中：
val strings = arrayOf("this","is","an","array","of","strings")
arrayOfNulls创建仅包含空值的数组，必须指定类型
val nullStringArray = arrayOfNulls<String>(5)//一个仅仅包含空值的数组
Array类
val squares = Array(5){i -> (i*i).toString()}
//结果为{"0","1","4","9","16"}的数组
withIndex访问数组
val strings = arrayOf("this","is","an","array","of","strings")
for((index,value) in strings.withIndex()){
pringln("Index $index maps to $value")
}
Index 0 maps to this
Index 1 maps to is
Index 2 maps to an
Index 3 maps to array
Index 4 maps to of
Index 5 maps to strings
2、创建集合
不可变的集合：listOf、setOf、mapOf
可变版本：mutableListOf、mutableSetOf、mutableMapOf
var numList = listOf(3,1,4,1,5,9)
var numSet = setOf(3,1,4,1,5,9)//numSet.size == 5
var map = mapOf(1 to "one",2 to "two",3 to "three")
var numList = mutableListOf(3,1,4,1,5,9)
var numSet = mutableSetOf(3,1,4,1,5,9)
var map = mutableMapOf(1 to "one",2 to "two",3 to "three")
3、为已存在的集合创建只读视图
如何为现有可变list/map/set创建只读版本。
将值赋值给List、Set、Map即可
val muNums = mutableListOf(3,1,4,1,5,9)
val onlyReadNum :List<Int> = muNums .toList()
该方法创建了一个单独的对象，内容相同但不代表是相同对象。
如果想要一个相同对象的只读视图，将可变list赋值给一个List类的引用即可：
val readOnlySameList :List<Int> = muNums
如果指向的list被修改，只读视图也会显示修改后的值。
4、从集合构建map
如何通过每个键生成，键值关联起来的map？
associateWith函数
val keys = 'a'..'f'
val map = key.associateWith{it to it.toString().repeat(5).capitalize()}
println(map)
{a=(a, Aaaaa), b=(b, Bbbbb), c=(c, Ccccc), d=(d, Ddddd), e=(e, Eeeee), f=(f, Fffff)}
//如果是老版本的kotlin输出如下
{a=Aaaaa, b=Bbbbb, c=Ccccc, d=Ddddd, e=Eeeee, f=Fffff}
在kotlin 1.3中的associateWith简化了代码，生成了String值，而不是生成Pair<Char,String>
val keys = 'a'..'f'
val map = key.associateWith{it.toString().repeat(5).capitalize()}
println(map)
{a=Aaaaa, b=Bbbbb, c=Ccccc, d=Ddddd, e=Eeeee, f=Fffff}
5、当集合为空的时候返回默认值
使用ifEmpty 和ifBlank
data class Product(val name:String,
val price:Double,
val onSale:Boolean = false)
// val products = listOf(pA,pB,pC)
val products = listOfNotNull<Product>()
println(nameOfP1(products))
fun nameOfP1(products :List<Product>) =
products.filter{it.onSale}
.map{it.name}
.joinToString(separator = ",")
fun nameOfP2(products :List<Product>) =
products.filter{it.onSale}
.map{it.name}
.ifEmpty{listOf("none")} //默认空集合
.joinToString(separator = ",")
fun nameOfP3(products :List<Product>) =
products.filter{it.onSale}
.map{it.name}
.joinToString(separator = ",")
.ifEmpty{"none"} //默认空字符串
1结果只是换行了
23结果会输出none
6、将变量限制在给定区间
给定一个值，在区间内返回本身，在区间外返回最小值和最大值。
使用coerceIn函数，并传入最小值和最大值。
val range = 3..8
println(5.coerceIn(range)) //5
println(5.coerceIn(3,8)) //5
println(1.coerceIn(range)) //3
println(1.coerceIn(3,8)) //3
7、处理集合中的窗口
chunked：将集合切分为相同部分
windowed：将块沿集合滑动给定间隔的块
chunked，切分集合为一个包含list的list，每个列表都具有给定大小或更小
fun main() {
val range = 0..10
val chunked = range.chunked(3)
println("chunked="+chunked)
//chunked=[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10]]
val chunked2 = range.chunked(3){it.average()}
println("chunked2="+chunked2)
//chunked2=[1.0, 4.0, 7.0, 9.5]
}
chunked函数其实是windowed函数的特殊情况
windowed函数接收3个函数 size（每个窗口的元素数量）、step（每一步向前移动的元素数，默认1）、partialwindows（默认false，如果没有足够数量，是否保留最后一部分）
chunked(size:Int) ->return windowed(size,size,true)
8、解构list
解构是通过将对象的值分配给变量的集合来从中提取值的过程。
val list = listOf("a","b","c","d","e","f","g")
val (a,b,c,d,e) = list
println("$a $b $c $d $e")
//a b c d e
列表创建的前五个元素已经分配给了相同名称变量。之所以可行是因为List类具有名为componentN的标准库中定义的扩展函数，其中N从1到5.
9、将多个属性排序
sortedWith / compareBy
data class Golfer(val score:Int,val first:String,val last:String)
fun main() {
val golfers = listOf(
Golfer(70,"jack","nicklaus"),
Golfer(68,"tom","watson"),
Golfer(68,"bubba","watson"),
Golfer(70,"tiger","woods"),
Golfer(68,"ty","webb"),
)
//score > lastname > first name
val sorted = golfers.sortedWith(
compareBy({it.score},{it.last},{it.first})
)
sorted.forEach{println(it)}
}
->
Golfer(score=68, first=bubba, last=watson)
Golfer(score=68, first=tom, last=watson)
Golfer(score=68, first=ty, last=webb)
Golfer(score=70, first=jack, last=nicklaus)
Golfer(score=70, first=tiger, last=woods)
另一种方式是使用thenBy
val comparator = compareBy<Golfer>(Golfer::score)
.thenBy(Golfer::last)
.thenBy(Golfer::first)
golfers.sortedWith(comparator )
.forEach(::printLn)
10、自定义迭代器
11、根据类型过滤集合
filterIsInstance / filterIsInstanceTo
kotlin集合中包含一个filter的扩展函数，接受一个可以用来提取满足任何布尔条件的元素谓词作为参数
val list = listOf("a",LocalDate.now(),3,1,4,"b")
val strings = list.filter{it is String}
for(s in strings){
s.length//不编译，类型被删除
}
尽管过滤有效，但推定类型为List<Any>因此不会转换为String.
可以添加filterIsInstance
val list = listOf("a",LocalDate.now(),3,1,4,"b")
val all= list.filterIsInstance<Any>()
val strings= list.filterIsInstance<String>()
val ints= list.filterIsInstance<Int>()
val datas= list.filterIsInstance<LocalDate::class.java>()
all -> list
strings ->"a","b"
ints - > 1,3,4
dates -> LocalDate.now()
filterIsInstance 返回类型是List<R>
filterIsInstanceTo返回类型是MutableCollection<inR>
val list = listOf("a",LocalDate.now(),3,1,4,"b")
val all= list.filterIsInstanceTo(mutableListOf())
val strings= list.filterIsInstanceTo(mutableListOf<String>())
val ints= list.filterIsInstanceTo(mutableListOf<Int>())
val datas= list.filterIsInstanceTo(mutableListOf<LocalDate>())
12、在数列中创建区间
kotlin使用双点操作符可以创建区间如1..5,创建一个IntRange。kotlin的区间都是闭区间，即包含两个端点。
import java.time.LocalDate
fun main() {
val started = LocalDate.now()
val mid = started.plusDays(3)
val end = started.plusDays(5)
val dataRange = started..end
println(started in dataRange)//t
println(mid in dataRange)//t
println(end in dataRange)//t
println(started.minusDays(1) in dataRange)//f
}
一旦尝试在区间进行迭代，会有编译错误
for(date in dateRange) println(it)//编译错误
问题在于区间而不在于数列，自定义数列实现了iterable接口
需要自定义Iterator，接口覆盖next和hasNext
