kotlin中，集合分为可变和不可变但可读的集合
可读可边集合，等价于java中的ArrayList。
可读不可变集合，不可添加元素进去。
HashSet集合，元素不可重复，按照hashcode排序。
val setList: HashSet<String> = hashSetOf("B", "A")
val numbers2 = mutableListOf("one", "two", "three", "four")
val stringList = listOf("one", "two", "one")
val numbersMap = mapOf("key1" to 1, "key2" to 2, "key3" to 3, "key4" to 1)
println("All keys: ${numbersMap.keys}")
println("All values: ${numbersMap.values}")
if ("key2" in numbersMap) println("Value by key \"key2\": ${numbersMap["key2"]}")
if (1 in numbersMap.values) println("The value 1 is in the map")
if (numbersMap.containsValue(1)) println("The value 1 is in the map") // 同上
val numbersSet = setOf("one", "two", "three", "four")
val emptySet = mutableSetOf<String>()
//注意，to 符号创建了一个短时存活的 Pair 对象， 缺陷，占用内存
// 为避免过多的内存使用，请使用其他方法。
// 例如，可以创建可写 Map 并使用写入操作填充它。 apply() 函数可以帮助保持初始化流畅。
val numbersMap = mapOf("key1" to 1, "key2" to 2, "key3" to 3, "key4" to 1)
val numbersMap2 = mutableMapOf<String, String>().apply { this["one"] = "1"; this["two"] = "2" }
要创建与现有集合具有相同元素的集合，可以使用复制操作。标准库中的集合复制操作创建了具有相同元素引用的 浅复制集合。 因此，对集合元素所做的更改会反映在其所有副本中。
在特定时刻通过集合复制函数，例如toList()、toMutableList()、toSet() 等等。创建了集合的快照。结果是创建了一个具有相同元素的新集合 如果在源集合中添加或删除元素，则不会影响副本。副本也可以独立于源集合进行更改。
注意：集合和数组引用都是浅拷贝，实际就是一个对象
package day5Set
/*
要创建与现有集合具有相同元素的集合，可以使用复制操作。标准库中的集合复制操作创建了具有相同元素引用的 浅复制集合。 因此，对集合元素所做的更改会反映在其所有副本中。
在特定时刻通过集合复制函数，例如toList()、toMutableList()、toSet() 等等。创建了集合的快照。
结果是创建了一个具有相同元素的新集合 如果在源集合中添加或删除元素，则不会影响副本。副本也可以独立于源集合进行更改。
深拷贝
注意：集合和数组引用都是浅拷贝，实际就是一个对象
调用其他集合函数过滤，有深拷贝，也有浅拷贝，比如filter,深拷贝，map浅拷贝
*/
fun main(args: Array<String>) {
val sourceList = mutableListOf(1, 2, 3)
val copyList = sourceList.toMutableList()
val readOnlyCopyList = sourceList.toList()
sourceList.add(4)
println(sourceList.size)
println("Copy size: ${copyList.size}")
//readOnlyCopyList.add(4) // 编译异常,不具有添加地功能
println("Read-only copy size: ${readOnlyCopyList.size}")
//调用其他集合的函数，深拷贝
val numbers = listOf("one", "two", "three", "four")
val longerThan3 = numbers.filter { it.length > 3 }
println(longerThan3)
//map，浅拷贝
val numbers2 = setOf(1, 2, 3)
println(numbers2.map { it * 3 })
println(numbers2.mapIndexed { idx, value -> value * idx })
val numbers3 = listOf("one", "two", "three", "four")
println(numbers3.associateWith { it.length }) //生成map
}
package day5Set
/*
Kotlin 标准库支持 迭代器 的常用机制——对象可按顺序提供对元素的访问权限，而不会暴露集合的底层结构
调用 next() 函数将返回此元素，并将迭代器指向下一个元素（如果下一个元素存在）
迭代器，底层是采用指针地方式进行地，所以可以增删改查，不过kotlin限制了，不可变迭代，不能增删
*/
fun main(args: Array<String>) {
val numbers = listOf("one", "two", "three", "four")
val numbersIterator = numbers.iterator()
while (numbersIterator.hasNext()) {
println(numbersIterator.next())
}
val numList = numbers.listIterator()
while (numList.hasNext()) {
println(numList.next())
}
//遍历 Iterable 集合的另一种方法是众所周知的 for 循环。在集合中使用 for 循环时，将隐式获取迭代器
//使用for(int i =0;i<size;i++) 则不是
for (item in numbers) {
println(item)
}
numbers.forEach { println(it) }
//ListIterator 它支持列表双向迭代：正向与反向。 反向迭代由 hasPrevious() 和 previous() 函数实现
val numbers3 = listOf("one", "two", "three", "four")
val listIterator = numbers3.listIterator()
while (listIterator.hasNext()) listIterator.next()
println("Iterating backwards:")
while (listIterator.hasPrevious()) {
print("Index: ${listIterator.previousIndex()}")
println(", value: ${listIterator.previous()}")
}
}
package day5Set
/*为了迭代可变集合，于是有了 MutableIterator 来扩展 Iterator 使其具有元素删除函数 remove() 。因此，可以在迭代时从集合中删除元素。*/
fun main(args: Array<String>) {
val numbers = mutableListOf("one", "two", "three", "four")
val mutableIterator = numbers.iterator()
mutableIterator.next()
mutableIterator.remove() //删除
numbers.removeAt(1)
println("After removal: $numbers")
//除了删除元素， MutableListIterator 还可以在迭代列表时插入和替换元素。
val numbers4 = mutableListOf("one", "four", "four")
val mutableListIterator = numbers4.listIterator()
mutableListIterator.next()
mutableListIterator.add("two")
mutableListIterator.next()
mutableListIterator.set("three") //修改
println(numbers4)
}
package day5Set
fun main(args: Array<String>) {
var i = 2
if (i in 1..4) { // 等同于 1 <= i && i <= 4
print(i)
}
//遍历
for (j in 1..4) print(j)
for (k in 4 downTo 1) print(k)
for (m in 1..8 step 2) print(m)
println()
for (m in 8 downTo 1 step 2) print(m)
for (n in 1 until 10) { // i in [1, 10), 10被排除
print(n)
}
println((1..10).filter { it % 2 == 0 })
println((1 until 10).map { it })
}
package day5Set
/*
除了集合之外，Kotlin 标准库还包含另一种容器类型——序列
缺陷：反过来，序列的多步处理在可能的情况下会延迟执行：仅当请求整个处理链的结果时才进行实际计算。会增加开销*/
fun main(args: Array<String>) {
val numbersSequence = sequenceOf("four", "three", "two", "one")
val numbers = listOf("one", "two", "three", "four")
val numbersSequence2 = numbers.asSequence()
}
//1一个过滤操作产生一个新集合，其
val numbers: List<String> = listOf("one", "two", "three", "four", "one")
numbers.filter { it.length > 3 } // `numbers` 没有任何改变，结果丢失
println("numbers are still $numbers")
val longerThan3 = numbers.filter { it.length > 3 } // 结果存储在 `longerThan3` 中
println("numbers longer than 3 chars are $longerThan3")
val numbers2 = listOf("one", "two", "three", "four")
val filterResults = mutableListOf<String>() // 目标对象
numbers2.filterTo(filterResults) { it.length > 3 }
numbers2.filterIndexedTo(filterResults) { index, _ -> index == 0 }
println(filterResults) // 包含两个操作的结果
// 将数字直接过滤到新的哈希集中，
// 从而消除结果中的重复项
val result = numbers.mapTo(HashSet()) { it }
println("$result")
//4排序
// sort() 就地对可变集合进行排序，因此其状态发生了变化； sorted() 创建一个新集合，该集合包含按排序顺序相同的元素。
var nums = mutableListOf("one", "two", "three", "four")
val sortedNumbers = nums.sorted()
println(sortedNumbers)
println(nums == sortedNumbers) // false
nums.sort()
println(nums == sortedNumbers) // true
package day5Set
/**
* map高阶函数
* zip合拢，将两个list集合变成一个list集合，size大小以最小那个为主，简单说，就是封装了一个pair对象，装箱， 全放到list中
*
* associateWith() 关联，生成一个map集合，前一个list集合作为key，方法值作为value
* associateBy 关联，默认前一个list作为value，方法作为key，可以使用具名参数 valueTransform = { it.length })
*
* flatten() 将多个集合变成一个集合，会新创建一个集合
* flatMap() 和map很像，但原理完全不同，map不会创建一个新的集合，而flatMap是创建一个新的集合，深拷贝
*
* joinToString() 根据提供的参数从集合元素构建单个 String
*/
fun main(args: Array<String>) {
//1map操作
val numbers = setOf(1, 2, 3)
println(numbers.map { it * 3 })
println(numbers.mapIndexed { idx, value -> value * idx })
//2mapNotNull() 函数取代 map() 或 mapIndexedNotNull() 取代 mapIndexed() 来从结果集中过滤掉 null 值。
val numbers2 = setOf(1, 2, 3)
println(numbers2.mapNotNull { if (it == 2) null else it * 3 })
println(numbers2.mapIndexedNotNull { idx, value -> if (idx == 0) null else value * idx })
//3.mapKeys() mapValues(),针对map集合
val numbersMap = mapOf("key1" to 1, "key2" to 2, "key3" to 3, "key11" to 11)
println(numbersMap.mapKeys { it.key.toUpperCase() })
println(numbersMap.mapValues { it.value + it.key.length })
//合拢
val colors = listOf("red", "brown", "grey")
val animals = listOf("fox", "bear", "wolf")
println(colors zip animals)
val twoAnimals = listOf("fox", "bear")
println(colors.zip(twoAnimals))
//也可以使用带有两个参数的转换函数来调用 zip()
val colors2 = listOf("red", "brown", "grey")
val animals2 = listOf("fox", "bear", "wolf")
//当个list，不适用pair对象
println(colors2.zip(animals2) { color, animal -> "The ${animal.capitalize()} is $color" })
//关联associateWith
val numbers4 = listOf("one", "two", "three", "four")
println(numbers4.associateWith { it.length })
//associateBy
//为了使用集合元素作为值来构建 Map，有一个函数 associateBy()。
// 它需要一个函数，该函数根据元素的值返回键。如果两个元素相等，则仅最后一个保留在 Map 中。 还可以使用值转换函数来调用 associateBy()。
val numbers5 = listOf("one", "two", "three", "four")
println(numbers5.associateBy { it.first().toUpperCase() })
println(numbers5.associateBy(keySelector = { it.first().toUpperCase() }, valueTransform = { it.length }))
//打平，将多个集合变成一个集合
val numberSets = listOf(setOf(1, 2, 3), setOf(4, 5, 6), setOf(1, 2))
println(numberSets.flatten())
//flatmap 的返回值必须是Iterable
val list = listOf(1, 2, 3, 4, 5)
val list3 = list.flatMap { listOf(it + 1) }
println(list3)
list3.map { println("my value is ${it}") }
//joinToString() 根据提供的参数从集合元素构建单个 String
val numbers6 = listOf("one", "two", "three", "four")
println(numbers6)
println(numbers6.joinToString())
//joinTo 是添加
val listString = StringBuffer("The list of numbers: ")
numbers6.joinTo(listString)
println(listString)
//joinToString样式
val numbers7 = listOf("one", "two", "three", "four")
println(numbers7.joinToString(separator = " | ", prefix = "start: ", postfix = ": end"))
//对于较大的集合，可能需要指定 limit ——将包含在结果中元素的数量。
// 如果集合大小超出 limit，所有其他元素将被 truncated 参数的单个值替换。
val numbers8 = (1..100).toList()
println(numbers8.joinToString(limit = 10, truncated = "<...>"))
//自定义样式
val numbers9 = listOf("one", "two", "three", "four")
println(numbers9.joinToString { "Element: ${it.toUpperCase()}" })
}
package day5Set
/**
* 过滤 深拷贝，创建一个全新的集合
* filter 针对list结合
* filteredMap 针对map集合
* filterIsInstance 过滤类型
* filterNotNull返回所有非空元素
* partition 过滤函数 – partition() 将匹配的和不匹配的都装起来 得到一个 List 的 Pair 作为返回值：第一个列表包含与谓词匹配的元素并且第二个列表包含原始集合中的所有其他元素。
*
* 检验谓词
* 如果至少有一个元素匹配给定谓词，那么 any() 返回 true。
如果没有元素与给定谓词匹配，那么 none() 返回 true。
如果所有元素都匹配给定谓词，那么 all() 返回 true。注意，在一个空集合上使用任何有效的谓词去调用 all() 都会返回 true 。这种行为在逻辑上被称为 vacuous truth。
*/
fun main(args: Array<String>) {
val numbers = listOf("one", "two", "three", "four")
val longerThan3 = numbers.filter { it.length > 3 }
println(longerThan3)
val numbersMap = mapOf("key1" to 1, "key2" to 2, "key3" to 3, "key11" to 11)
val filteredMap = numbersMap.filter { (key, value) -> key.endsWith("1") && value > 10 }
println(filteredMap)
val numbers2 = listOf(null, 1, "two", 3.0, "four")
println("All String elements in upper case:")
numbers2.filterIsInstance<String>().forEach {
println(it.toUpperCase())
}
val numbers3 = listOf(null, "one", "two", null)
numbers3.filterNotNull().forEach {
println(it.length) // 对可空的 String 来说长度不可用
}
val numbers4 = listOf("one", "two", "three", "four")
val (match, rest) = numbers4.partition { it.length > 3 }
println(match)
println(rest)
val numbers5 = listOf("one", "two", "three", "four")
println(numbers5.any { it.endsWith("e") }) //一个满足，true，否则false
println(numbers5.none { it.endsWith("a") }) //都不满足，true，否则false
println(numbers5.all { it.endsWith("e") }) //全都满足，true，否则false
println(emptyList<Int>().all { it > 5 }) // vacuous truth
}
package day5Set
/**
* 为集合定义了 plus (+) 和 minus (-) 操作符。
* 它们把一个集合作为第一个操作数；第二个操作数可以是一个元素或者是另一个集合。 返回值是一个新的只读集合：
* plus 的结果包含原始集合 和 第二个操作数中的元素。minus 的结果包含原始集合中的元素，
* 但第二个操作数中的元素 除外。 如果第二个操作数是一个元素，那么 minus 移除其在原始集合中的 第一次 出现；如果是一个集合，那么移除其元素在原始集合中的 所有 出现。
* minus，如果不是集合，只减掉第一个出现的元素，如果是集合，减除掉所有出现的元素
*/
fun main(args: Array<String>) {
val numbers = listOf("one", "two", "three", "three", "four")
val plusList = numbers + "five"
val minusList = numbers - listOf("three", "four")
println(plusList)
println(minusList)
}
package day5Set
/**
* 分组 groupBy，list结合变成map集合
* eachCount() 计算每个组中的元素数量。
*/
fun main(args: Array<String>) {
val numbers = listOf("one", "two", "one", "three", "four", "five")
println(numbers.groupBy { it.first().toUpperCase() })
//如果第一个符合，则调用第二个函数
println(numbers.groupBy(keySelector = { it.first() }, valueTransform = { it.toUpperCase() }))
val numbers2= listOf("one", "two", "three", "four", "five", "six")
println(numbers2.groupingBy { it.first() }.eachCount())
}
val numbers = listOf("one", "two", "three", "four", "five", "six")
println(numbers.slice(1..3))
println(numbers.slice(0..4 step 2))
println(numbers.slice(setOf(3, 5, 0)))
从头开始获取指定数量的元素，请使用 take() 函数
val numbers2 = listOf("one", "two", "three", "four", "five", "six")
println(numbers2.take(3))
println(numbers2.takeLast(3))
println(numbers2.drop(1))
println(numbers2.dropLast(5))
要从头或从尾去除给定数量的元素，请调用 drop() 或 dropLast() 函数
takeWhile() 是带有谓词的 take()：它将不停获取元素直到排除与谓词匹配的首个元素。如果首个集合元素与谓词匹配，则结果为空。
val numbers3 = listOf("one", "two", "three", "four", "five", "six")
println(numbers3.takeWhile { !it.startsWith('f') }) //符合的，为true，找到停止
println(numbers3.takeLastWhile { it != "three" })
println(numbers3.dropWhile { it.length == 3 }) //true的不要，直到false为止，后面的全要
println(numbers3.dropLastWhile { it.contains('i') })
与takeWhile相反查找，从后往前
与具有相同谓词的 takeWhile() 相反：它将首个与谓词不匹配的元素返回到末尾。
println(numbers3.dropWhile { it.length == 3 }) //true的不要，直到false为止，后面的全要
println(numbers3.dropLastWhile { it.contains('i') })
//chunked将集合分解为给定大小的“块”[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11], [12, 13]]
val numbers4 = (0..13).toList()
println(numbers4.chunked(3))
val numbers5 = listOf("one", "two", "three", "four", "five")
println(numbers5.windowed(3))
[[one, two, three], [two, three, four], [three, four, five]]
val numbers6 = listOf("one", "two", "three", "four", "five")
println(numbers6.zipWithNext())
println(numbers6.zipWithNext { s1, s2 -> s1.length > s2.length})
[(one, two), (two, three), (three, four), (four, five)]
[false, true, false, false]
val numbers = linkedSetOf("one", "two", "three", "four", "five")
println(numbers.elementAt(3))
val numbersSortedSet = sortedSetOf("one", "two", "three", "four")
println(numbersSortedSet.elementAt(0)) // 元素以升序存储
elementAtOrNull:没有找到， 则返回一个null
没找到，会抛出异常
val numbers3 = listOf("one", "two", "three", "four", "five", "six")
println(numbers3.first { it.length > 3 })
println(numbers3.last { it.startsWith("f") })
//如果没有元素与谓词匹配，两个函数都会抛异常。 为了避免它们，请改用 firstOrNull() 和 lastOrNull()：如果找不到匹配的元素，它们将返回 null。
val numbers4 = listOf("one", "two", "three", "four", "five", "six")
println(numbers4.firstOrNull { it.length > 6 })
val numbers5 = listOf(1, 2, 3, 4)
println(numbers5.find { it % 2 == 0 })
println(numbers5.findLast { it % 2 == 0 })
val numbers6 = listOf(1, 2, 3, 4)
println(numbers6.random())
val numbers7 = listOf("one", "two", "three", "four", "five", "six")
println(numbers7.contains("four"))
println("zero" in numbers7)
println(numbers7.containsAll(listOf("four", "two")))
println(numbers7.containsAll(listOf("one", "zero")))
//你可以通过调用 isEmpty() 和 isNotEmpty() 来检查集合中是否包含任何元素。
val numbers8 = listOf("one", "two", "three", "four", "five", "six")
println(numbers8.isEmpty())
println(numbers8.isNotEmpty())
val empty = emptyList<String>()
println(empty.isEmpty())
println(empty.isNotEmpty())
升序
val numbers = listOf("one", "two", "three", "four")
println("Sorted ascending: ${numbers.sorted()}")
println("Sorted descending: ${numbers.sortedDescending()}")
val numbers2 = listOf("one", "two", "three", "four")
val sortedNumbers = numbers2.sortedBy { it.length }
println("Sorted by length ascending: $sortedNumbers")
val sortedByLast = numbers2.sortedByDescending { it.last() }
println("Sorted by the last letter descending: $sortedByLast")
val numbers3 = listOf("one", "two", "three", "four")
println(numbers3.reversed())
val numbers4 = mutableListOf("one", "two", "three", "four")
val reversedNumbers = numbers4.asReversed() //如果原始列表不会发生变化，那么它会比 reversed() 更轻量，更合适,原数据会影响到asReversed之后的数据
println(reversedNumbers)
val numbers = listOf(6, 42, 10, 4)
println("Count: ${numbers.count()}")
println("Max: ${numbers.max()}")
println("Min: ${numbers.min()}")
println("Average: ${numbers.average()}")
println("Sum: ${numbers.sum()}")
val numbers2 = listOf(5, 42, 10, 4)
val min3Remainder = numbers2.minBy { it % 3 }
println(min3Remainder)
val strings = listOf("one", "two", "three", "four")
val longestString = strings.maxWith(compareBy { it.length })
println(longestString)
val numbers3 = listOf(5, 42, 10, 4)
println(numbers3.sumBy { it * 2 })
println(numbers3.sumByDouble { it.toDouble() / 2 })
reduce() 的第一步则将第一个和第二个元素作为第一步的操作参数。
val numbers4 = listOf(5, 2, 10, 4)
val sum = numbers4.reduce { sum, element ->
println(sum)
sum + element
}
5
7
17
21
val numbers4 = listOf(5, 2, 10, 4)
val sumDoubled = numbers4.fold(0) { sum, element ->
println(sum)
sum + element }
println(sumDoubled)
package day5Set
/**
* add
* addAll
* plus 运算符 - plusAssign (+=) 添加元素
* 请使用 remove() 函数。 remove() 接受元素值，
* 要一次删除多个元素，有以下函数：
removeAll() 移除参数集合中存在的所有元素。 或者，你可以用谓词作为参数来调用它；在这种情况下，函数移除谓词产生 true 的所有元素。
retainAll() 与 removeAll() 相反：它移除除参数集合中的元素之外的所有元素。 当与谓词一起使用时，它只留下与之匹配的元素。
clear() 从列表中移除所有元素并将其置空
*/
fun main(args: Array<String>) {
val numbers = mutableListOf(1, 2, 3, 4)
numbers.add(5)
println(numbers)
val numbers2 = mutableListOf(1, 2, 5, 6)
numbers2.addAll(arrayOf(7, 8))
println(numbers2)
numbers.addAll(2, setOf(3, 4))
println(numbers)
val numbers3 = mutableListOf("one", "two")
numbers3 += "three"
println(numbers3)
numbers3 += listOf("four", "five")
println(numbers3)
val numbers4 = mutableListOf(1, 2, 3, 4, 3)
numbers4.remove(3) // 删除了第一个 `3`
println(numbers4)
numbers4.remove(5) // 什么都没删除
println(numbers4)
val numbers5 = mutableListOf(1, 2, 3, 4)
println(numbers5)
numbers5.retainAll { it >= 3 }
println(numbers5)
numbers5.clear()
println(numbers5)
val numbersSet = mutableSetOf("one", "two", "three", "four")
numbersSet.removeAll(setOf("one", "two"))
println(numbersSet)
val numbers6 = mutableListOf("one", "two", "three", "three", "four", "four", "four")
numbers6 -= "three" //移除第一个出现的元素
println(numbers6)
numbers6 -= listOf("four", "five") //移除所有four和five
//numbers -= listOf("four") // 与上述相同
println(numbers6)
//更新
val numbers7 = mutableListOf("one", "five", "three")
numbers7[1] = "two"
numbers7.set(2,"five")
println(numbers7)
}
package day5Set
import kotlin.math.sign
/**
* 按索引取元素
* elementAt() 、 first() 、 last()
* 如果 List 长度小于指定的索引，则抛出异常。 另外，还有两个函数能避免此类异常：
getOrElse() 提供用于计算默认值的函数，如果集合中不存在索引，则返回默认值。
getOrNull() 返回 null 作为默认值。
取列表的一部分 List 还提供 subList() 该函数将指定元素范围的视图作为列表返回
查找元素 类似String
都可以使用 indexOf() 或 lastIndexOf() 函数找到元素的位置。 它们返回与列表中给定参数相等的元素的第一个或最后一个位置。 如果没有这样的元素，则两个函数均返回 -1
还有一对函数接受谓词并搜索与之匹配的元素：
indexOfFirst() 返回与谓词匹配的第一个元素的索引，如果没有此类元素，则返回 -1。
indexOfLast() 返回与谓词匹配的最后一个元素的索引，如果没有此类元素，则返回 -1。
二分法查找：它的工作速度明显快于其他内置搜索功能，但要求该列表按照一定的顺序（自然排序或函数参数中提供的另一种排序）按升序排序过。 否则，结果是不确定的
请调用 binarySearch() 函数，并将该值作为参数传递。 如果存在这样的元素，则函数返回其索引；否则，将返回 (-insertionPoint - 1)，其中 insertionPoint 为应插入此元素的索引，以便列表保持排序。 如果有多个具有给定值的元素，搜索则可以返回其任何索引。
Comparator 二分搜索
*/
fun main(args: Array<String>) {
val numbers = listOf(1, 2, 3, 4)
println(numbers.get(0))
println(numbers[0])
//numbers.get(5) // exception!
println(numbers.getOrNull(5)) // null
println(numbers.getOrElse(5) { it }) // 5
val numbers2 = (0..13).toList()
println(numbers2.subList(3, 6))
val numbers3 = listOf(1, 2, 3, 4, 2, 5)
println(numbers3.indexOf(2))
println(numbers3.lastIndexOf(2))
val numbers4 = mutableListOf(1, 2, 3, 4)
println(numbers4.indexOfFirst { it > 2 })
println(numbers4.indexOfLast { it % 2 == 1 })
//binarySearch应该插入的位置，查找不到，就在索引后面一位
val numbers5 = mutableListOf("one", "two", "three", "four")
numbers5.sort()
println(numbers5)
println(numbers5.binarySearch("two")) // 3
println(numbers5.binarySearch("z")) // -5
println(numbers5.binarySearch("two", 0, 2)) // -3
val productList = listOf(
Product("WebStorm", 49.0),
Product("AppCode", 99.0),
Product("DotTrace", 129.0),
Product("ReSharper", 149.0))
println(productList.binarySearch(Product("AppCode", 99.0), compareBy<Product> { it.price }.thenBy { it.name }))
println(productList.binarySearch { priceComparison(it, 99.0) })
val colors = listOf("Blue", "green", "ORANGE", "Red", "yellow")
println(colors.binarySearch("RED", String.CASE_INSENSITIVE_ORDER)) // 3
//更新
val numbers7 = mutableListOf("one", "five", "three")
numbers7[1] = "two"
numbers7.set(2,"five")
println(numbers7)
// fill() 简单地将所有集合元素的值替换为指定值。
val numbers8 = mutableListOf(1, 2, 3, 4)
numbers8.fill(3)
println(numbers8)
//删除请使用 removeAt() 函数，并将位置作为参数。 在元素被删除之后出现的所有元素索引将减 1。
val numbers9 = mutableListOf(1, 2, 3, 4, 3)
numbers9.removeAt(1)
println(numbers9)
val numbers10 = mutableListOf(1, 2, 3, 4, 3)
numbers10.removeFirst()
numbers10.removeLast()
println(numbers)
val empty = mutableListOf<Int>()
// empty.removeFirst() // NoSuchElementException: List is empty.
empty.removeFirstOrNull() //null
}
fun priceComparison(product: Product, price: Double) = sign(product.price - price).toInt()
class Product(var name: String, var price: Double);
package day5Set
/**
* getOrDefault
* getOrElse
* keys
* values
* filter
* filterKeys() 和 filterValues() 。 两者都将返回一个新 Map ，其中包含与给定谓词相匹配的条目。 filterKeys() 的谓词仅检查元素键， filterValues() 的谓词仅检查值。
*
* plus 与 minus 操作
*
* 默认使用LinkedHashMap
*
* putAll() 。它的参数可以是 Map 或一组 Pair ： Iterable 、 Sequence 或 Array 。
*
* 删除条目
*/
fun main(args: Array<String>) {
val numbersMap = mapOf("one" to 1, "two" to 2, "three" to 3)
println(numbersMap.get("one"))
println(numbersMap["one"])
println(numbersMap.getOrDefault("four", 10))
println(numbersMap["five"]) // null
val numbersMap2 = mapOf("one" to 1, "two" to 2, "three" to 3)
println(numbersMap2.keys)
println(numbersMap2.values)
val numbersMap3 = mapOf("key1" to 1, "key2" to 2, "key3" to 3, "key11" to 11)
val filteredMap = numbersMap3.filter { (key, value) -> key.endsWith("1") && value > 10}
println(filteredMap)
val numbersMap4 = mapOf("key1" to 1, "key2" to 2, "key3" to 3, "key11" to 11)
val filteredKeysMap = numbersMap4.filterKeys { it.endsWith("1") }
val filteredValuesMap = numbersMap4.filterValues { it < 10 }
println(filteredKeysMap)
println(filteredValuesMap)
val numbersMap5 = mapOf("one" to 1, "two" to 2, "three" to 3)
println(numbersMap5 + Pair("four", 4))
println(numbersMap5 + Pair("one", 10))
println(numbersMap5 + mapOf("five" to 5, "one" to 11))
val numbersMap6 = mapOf("one" to 1, "two" to 2, "three" to 3)
println(numbersMap6 - "one")
println(numbersMap6 - listOf("two", "four"))
val numbersMap7 = mutableMapOf("one" to 1, "two" to 2)
numbersMap7.put("three", 3)
println(numbersMap7)
val numbersMap8 = mutableMapOf("one" to 1, "two" to 2, "three" to 3)
numbersMap8.putAll(setOf("four" to 4, "five" to 5))
println(numbersMap8)
val numbersMap9 = mutableMapOf("one" to 1, "two" to 2)
numbersMap9["three"] = 3 // 调用 numbersMap.set("three", 3)
numbersMap9 += mapOf("four" to 4, "five" to 5)
println(numbersMap9)
val numbersMap10 = mutableMapOf("one" to 1, "two" to 2, "three" to 3)
numbersMap10.remove("one")
println(numbersMap10)
numbersMap10.remove("three", 4) //不会删除任何条目
println(numbersMap10)
//还可以通过键或值从可变 Map 中删除条目。 在 Map 的 .keys 或 .values 中调用 remove() 并提供键或值来删除条目。 在 .values 中调用时， remove() 仅删除给定值匹配到的的第一个条目
val numbersMap11 = mutableMapOf("one" to 1, "two" to 2, "three" to 3, "threeAgain" to 3)
numbersMap11.keys.remove("one")
println(numbersMap11)
numbersMap11.values.remove(3)
println(numbersMap11)
//minusAssign （-=） 操作符也可用于可变 Map
val numbersMap12 = mutableMapOf("one" to 1, "two" to 2, "three" to 3)
numbersMap12 -= "two"
println(numbersMap12)
numbersMap12 -= "five" //不会删除任何条目
println(numbersMap12)
}
let:内部含有it，返回最后数据，适用于判空后处理
var family: Family = Family("zhagnsan", 3)
family?.eatSomething()
var x = family?.let {
it.toDoSomething()
1
}
with:适用于调用同一个类的多个方法时
with(family) {
toDoSomething()
eatSomething()
}
run:弥补let和run:run函数是以闭包形式返回最后一行代码的值
family?.run {
toDoSomething()
eatSomething()
}
apply:返回自身this，适合链式编程
var family2: Family = Family("zhagnsan", 3)?.apply {
name = "lisi"
num = 5
}
println(family2)
also:适合链式编程
Family("zhagnsan", 3).also {
it.toDoSomething()
}.let {
it.eatSomething()
}
Family("lisi",20).apply {
toDoSomething();
}.apply {
}
/**
* Java 中的异常分为两类，受检查异常 和 运行时异常，受检查异常要用try-catch 捕获，要么抛出，否则会发生编译错误
*
* kotlin：而 kotlin 中没有受检查异常，所有异常都是运行时异常，即便是原本在 Java 中的受检查异常，
* 在 kotlin 中也是运行时异常，例如：IOException 在 Java 中是受检查异常，在 kotlin 中是运行时异常
*
* throw关键字的语法:用于抛出显式异常。它用于抛出自定义异常。要抛出异常对象，将使用throw-expression。
*/
package day5Set
/**
* Java 中的异常分为两类，受检查异常 和 运行时异常，受检查异常要用try-catch 捕获，要么抛出，否则会发生编译错误
*
* kotlin：而 kotlin 中没有受检查异常，所有异常都是运行时异常，即便是原本在 Java 中的受检查异常，
* 在 kotlin 中也是运行时异常，例如：IOException 在 Java 中是受检查异常，在 kotlin 中是运行时异常
*
* throw关键字的语法:用于抛出显式异常。它用于抛出自定义异常。要抛出异常对象，将使用throw-expression。
*/
fun main(args: Array<String>) {
val name:String? = null
try {
println(name!!.length)//name一定不能为空，否则抛出异常
} catch (e: Exception) {
e.printStackTrace()
} finally {
println("结束")
}
// 1、kotlin中的异常处理和java处理相似，除了Kotlin不要求你声明函数可以抛出的异常。
// 2、如果一个try代码块执行一切正常，代码块中最后一个表达式就是结果。
// 3、如果捕获到一个异常，那么cache代码块中最后一个表达式就是结果。
var result= try {
var list:Array<String> = arrayOf("jingwen","zhulina","chengcheng")
println(list[4])
0
} catch(e: Exception) {
e.printStackTrace()
1
} finally {
println("safs")
}
println(result)
var age: Int = (0..50).random()
validate(age)//在java中，一定需要声明抛出的异常
}
fun validate(age: Int) { //不必显式地指定这个函数可能抛出的异常
println("age = $age")
if (age < 18)
throw ArithmeticException("小学生不能玩吃鸡")
else
println("不错，你满18岁了，可以玩吃鸡")
}
fun main(args: Array) {
val name:String? = null
try {
println(name!!.length)//name一定不能为空，否则抛出异常
} catch (e: Exception) {
e.printStackTrace()
} finally {
println(“结束”)
}
// 1、kotlin中的异常处理和java处理相似，除了Kotlin不要求你声明函数可以抛出的异常。
// 2、如果一个try代码块执行一切正常，代码块中最后一个表达式就是结果。
// 3、如果捕获到一个异常，那么cache代码块中最后一个表达式就是结果。
var result= try {
var list:Array = arrayOf(“jingwen”,“zhulina”,“chengcheng”)
println(list[4])
0
} catch(e: Exception) {
e.printStackTrace()
1
} finally {
println(“safs”)
}
println(result)
var age: Int = (0..50).random()
validate(age)//在java中，一定需要声明抛出的异常
}
fun validate(age: Int) { //不必显式地指定这个函数可能抛出的异常
println(“age = $age”)
if (age < 18)
throw ArithmeticException(“小学生不能玩吃鸡”)
else
println(“不错，你满18岁了，可以玩吃鸡”)
}