kotlin生成随机数,keil生成随机数
Kotlin介绍系列（三）高级用法之DataClass
经常会需要创建一些类除了保存数据不干其他事情，比如我们解析网络请求下来的数据。Kotlin就提供了一个非常方便的class—— data class
我们知道在Kotlin中，声明类的同时可以方便的直接声明构造方法等参数，鉴于data class只是存放数据，那么只一个构造方法足矣，所以连类的body也就不需要了。是不是很清爽？
编译器会根据我们在构造函数里声明的属性自动导出下列成员：
经常会遇到我们只需要替换一个对象的个别属性，而其他属性保留的情况。这就是data class中生成的copy函数的作用了。
本文已开始的例子类，它的生成的默认copy函数是下面这样的：
fun copy(name: String = this.name, age: Int = this.age) = User(name, age)
这就运训我们这样写：
data class的生成的component方法给我们的结构化声明及使用提供了可能
Kotlin介绍系列（三）高级用法之object
Kotlin介绍系列（三）高级用法之Delegation
kotlin集合高效使用
1、来了老弟？
2、映射为List: map{},mapIndexed{},mapNotNull{},mapIndexedNotNull{}
val numbers = setOf(1, 2, 3)
println(numbers.map { it * 3 })
//[3, 6, 9]
println(numbers.mapIndexed { idx, value - value * idx })
//[0, 2, 6]
3、双路合并
(1)zip()将两个集合中具有相同位置的元素构建配对。
val list1 = listOf(1, 2, 3)
val list2 = listOf("a", "b", "c")
val list = list1.zip(list2)
println(list)
//[(1, a), (2, b), (3, c)]
val list3 = list1.zip(list2) { l1, l2 - "${l1}----${l2}" }
println(list3)
//[1----a, 2----b, 3----c]
(2)反向转换unzip()，list.unzip()得到一个Pair对象
val numberPairs = listOf("one" to 1, "two" to 2, "three" to 3, "four" to 4)
println(numberPairs.unzip())
//([one, two, three, four], [1, 2, 3, 4])
4、关联
根据集合元素和与其关联的某些值构建 Map。
(1) Map associateWith() 。其中原始集合的元素是键，值来自给定的转换函数。 如果两个元素相等，则仅保留最后一个。
val numbers = listOf("one", "two", "three", "four")
val map = numbers.associateWith { it.length }
println(map)
//{one=3, two=3, three=5, four=4}
(2) associateBy()。 键来自给定的转换函数，原始集合中的元素是值。也可以使用keySelector和valueTransform设置键和值。两个元素相等，则仅保留最后一个。
val numbers = listOf("one", "two", "three", "four")
println(numbers.associateBy { it.first().toUpperCase() })
//{O=one, T=three, F=four}
println(numbers.associateBy(keySelector = { it.first().toUpperCase() }, valueTransform = { it.length }))
//{O=3, T=5, F=4}
(3)associate()。键和值都是根据集合元素生成的。associate() 会生成临时的 Pair 对象，这可能会影响性能。
data class FullName(val firstName: String, val lastName: String)
fun parseFullName(fullName: String): FullName {
? ? val nameParts = fullName.split(" ")
? ? if (nameParts.size == 2) {
? ? ? ? return FullName(nameParts[0], nameParts[1])
? ? } else throw Exception("Wrong name format")
}
val names = listOf("Alice Adams", "Brian Brown", "Clara Campbell")
println(names.associate { name - parseFullName(name).let { it.lastName to it.firstName } })
//{Adams=Alice, Brown=Brian, Campbell=Clara}
5、打平
flatMap()可以打平集合中对象的某个类型为list的字段的值。
data class StringContainer(val values: ListString)
val containers = listOf(
? ? ? ? StringContainer(listOf("one", "two", "three")),
? ? ? ? StringContainer(listOf("four", "five", "six")),
? ? ? ? StringContainer(listOf("seven", "eight"))
)
println(containers)
//[StringContainer(values=[one, two, three]), StringContainer(values=[four, five, six]), StringContainer(values=[seven, eight])]
println(containers.flatMap { it.values })
//[one, two, three, four, five, six, seven, eight]
//即可以打平集合中对象的某个类型为list的字段的值
6、字符串表示
（1）joinToString() 根据提供的参数从集合元素构建单个 String。
val numbers = listOf("one", "two", "three", "four")
println(numbers)
//[one, two, three, four]
println(numbers.joinToString())
//one, two, three, four
println(numbers.joinToString("-", "开始", "结束"))
//开始one-two-three-four结束
println(numbers.joinToString("-", "开始", "结束", 3))
//开始one-two-three-...结束
println(numbers.joinToString("-", "开始", "结束", 3, "等等"))
//开始one-two-three-等等结束
println(numbers.joinToString("-", "开始", "结束", 3, "等等", { it - it.toUpperCase() }))
//开始ONE-TWO-THREE-等等结束
（2）joinTo() 执行相同的操作，但将结果附加到给定的 Appendable (可追加的)对象。
val numbers = listOf("one", "two", "three", "four")
val listString = StringBuffer("The list of numbers: ")
numbers.joinTo(listString, "-", "开始", "结束", 3, "等等", { it - it.toUpperCase() })
println(listString)
//The list of numbers: 开始ONE-TWO-THREE-等等结束
7、过滤
(1)filter()。只能检查集合中元素的值。
val numbers = listOf("one", "two", "three", "four")
val longerThan3 = numbers.filter { it.length 3 }
println(longerThan3)
//[three, four]
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)
//{key11=11}
(2)filterIndexed()。可以检查元素的索引和元素的值。
val numbers = listOf("one", "two", "three", "four")
val filteredIdx = numbers.filterIndexed { index, value - (index != 0) (value.length 5) }
println(filteredIdx)
//[two, four]
(3) filterNot()。使用否定条件来过滤集合。
val numbers = listOf("one", "two", "three", "four")
val filteredNot = numbers.filterNot { it.length = 3 }
println(filteredNot)
//[three, four]
(4)filterIsInstanceT() 返回给定类型的集合元素。
val numbers = listOf(null, 1, "two", 3.0, "four")
println(numbers.filterIsInstanceString())
//[two, four]
(5)filterNotNull() 返回所有的非空元素。在一个 ListT? 上被调用时，filterNotNull() 返回一个 ListT: Any。
val numbers = listOf(null, "one", "two", null)
println(numbers.filterNotNull())
//[one, two]
8、划分
partition() – 根据集合中元素的值进行过滤，并且返回一个PairList,List。第一个list表示符合条件的集合；第二个list表示不符合条件的集合。
val numbers = listOf("one", "two", "three", "four")
val (match, rest) = numbers.partition { it.length 3 }
println(match)
//[three, four]
println(rest)
//[one, two]
9、集合元素检查
(1)
如果至少有一个元素匹配给定谓词，那么 any() 返回 true。
如果没有元素与给定谓词匹配，那么 none() 返回 true。
如果所有元素都匹配给定谓词，那么 all() 返回 true。注意，在一个空集合上调用 all() 始终都会返回 true 。
val numbers = listOf("one", "two", "three", "four")
println(numbers.any { it.endsWith("e") })
//true
println(numbers.none { it.endsWith("a") })
//true
println(numbers.all { it.endsWith("e") })
//false
println(emptyListInt().all { it 5 })
//true
(2)当any() 和 none()不设置条件时， 它们只是用来检查集合是否为空。 如果集合中有元素(即使是null)，any() 返回 true，否则返回 false；none() 则相反
10、集合加减：plus与minus
val numbers = listOf("one", "two", "three", "three", "four")
//集合加和，第二个操作数可以是集合，也可以是元素
val plusList = numbers + "five"
println(plusList)
//[one, two, three, three, four, five]
//如果第二个操作数是一个集合，那么移除其元素在原始集合中的 所有 出现。
val minusList1 = numbers - listOf("three")
println(minusList1)
//[one, two, four]
//如果第二个操作数是一个元素，那么 minus 移除其在原始集合中的 第一次 出现
val minusList2 = numbers - "three"
println(minusList2)
//[one, two, three, four]
11、分组
(1) groupBy()
val numbers = listOf("one", "two", "three", "four", "five")
//根据转换函数得到key，value来自于集合的元素
println(numbers.groupBy { it.first().toUpperCase() })
//{O=[one], T=[two, three], F=[four, five]}
//根据转换函数得到key，value来自于对原有集合元素的转换结果
println(numbers.groupBy(keySelector = { it.first() }, valueTransform = { it.toUpperCase() }))
//{O=[one], T=[two, three], F=[four, five]}
(2) grouping()
在分组后，对所有的分组进行一次操作。eachCount() 计算每个组中的元素。还有fold()、reduce()、aggregate()等。
val numbers = listOf("one", "two", "three", "four", "five", "six")
println(numbers.groupingBy { it.first() }.eachCount())
//{o=1, t=2, f=2, s=1}
12、取集合的一部分
(1)slice() 返回给定索引处的集合元素列表。
val numbers = listOf("one", "two", "three", "four", "five", "six")
println(numbers.slice(1..3))
//[two, three, four]
println(numbers.slice(0..4 step 2))
//[one, three, five]
println(numbers.slice(setOf(3, 5, 0)))
//[four, six, one]
(2)take和drop
val numbers = listOf("one", "two", "three", "four", "five", "six")
//从头开始获取指定数量的元素
println(numbers.take(3))
//[one, two, three]
//从尾部开始获取指定数量的元素
println(numbers.takeLast(3))
//[four, five, six]
//从头开始去除给定数量的元素
println(numbers.drop(1))
//[two, three, four, five, six]
//从尾部开始去除给定数量的元素
println(numbers.dropLast(5))
//[one]
(3)takeWhile()和dropWhile()
val numbers = listOf("one", "two", "three", "four", "five", "six")
//不停地获取元素，直到遇到使表达式为false的首个元素。如果首个集合元素便使表达式为false，则结果为空。
println(numbers.takeWhile { !it.startsWith('f') })
//[one, two, three]
//从尾部开始，如上
println(numbers.takeLastWhile { it != "three" })
//[four, five, six]
//不停地删除元素，直到遇到使表达式为false的首个元素，然后返回剩余的元素。如果首个集合元素便使表达式为false，则返回集合所有的元素。
println(numbers.dropWhile { it.length == 3 })
//[three, four, five, six]
//从尾部开始，如上
println(numbers.dropLastWhile { it.contains('i') })
//[one, two, three, four]
(4)chunked()
将集合分为指定大小的子集
val numbers = (0..13).toList()
println(numbers.chunked(3))
//[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11], [12, 13]]
val numbers = (0..13).toList()
//将集合切割成指定大小的子集后，对子集元素进行转换
println(numbers.chunked(3) { it.sum() })
//[3, 12, 21, 30, 25]
(5)windowed()
val numbers = listOf("one", "two", "three", "four", "five")
//检索指定大小的所有可能子集
println(numbers.windowed(3))
//[[one, two, three], [two, three, four], [three, four, five]]
//设置步长
println(numbers.windowed(3, 2))
//[[one, two, three], [three, four, five]]
//partialWindows为true时，即使剩余的元素数量小于窗口长度，也会返回结果
println(numbers.windowed(3, 2, true))
//[[one, two, three], [three, four, five], [five]]
//对得到的所有子集进行转换
println(numbers.windowed(3, 2, true, { list - list.map { it.toUpperCase() } }))
//[[ONE, TWO, THREE], [THREE, FOUR, FIVE], [FIVE]]
(6)zipWithNext()
val numbers = listOf("one", "two", "three", "four", "five")
//从头开始，返回所有的相邻元素对(Pair)
println(numbers.zipWithNext())
//[(one, two), (two, three), (three, four), (four, five)]
//s1,s2即相邻元素对
println(numbers.zipWithNext { s1, s2 - s1.length s2.length })
13、取单个元素
(1)elementAt()获取指定索引处的元素
val str = linkedSetOf("one", "two", "three", "four", "five").elementAt(3)
(2)elementAtOrNull()
val numbers = listOf("one", "two", "three", "four", "five")
//越界后返回null
println(numbers.elementAtOrNull(5))
//null
(3)elementAtOrElse()
val numbers = listOf("one", "two", "three", "four", "five")
//越界后返回lambda表达式的结果
println(numbers.elementAtOrElse(5) { index - "The value for index $index is undefined" })
//The value for index 5 is undefined
(4)first()和last()
first()和last()也可以根据表达式查找。但是如果没有查找到目标元素，将会抛出异常。用 firstOrNull() 和 lastOrNull()替代，如果没有找到，会返回null。
可以使用find() 代替 firstOrNull()；使用 findLast() 代替 lastOrNull()
val numbers = listOf("one", "two", "three", "four", "five", "six")
println(numbers.first { it.length 3 })
//three
println(numbers.last { it.startsWith("f") })
//five
(5) random()
随机返回一个元素。对于空集合会抛出异常。可以使用randomOrNull()替代，会返回null。
14、排序
(1)sortedWith(comparator: Comparatorin T)
//compareBy()可根据给定的lambda表达式返回Comparator
println(listOf("aaa", "bb", "c").sortedWith(compareBy { it.length }))
//[c, bb, aaa]
(2) sorted() 和 sortedDescending()
val numbers = listOf("one", "two", "three", "four")
//自然升序
println(numbers.sorted())
//[four, one, three, two]
//自然降序
println(numbers.sortedDescending())
//[two, three, one, four]
(3) sortedBy(lambda表达式) 和 sortedByDescending(lambda表达式)
val numbers = listOf("one", "two", "three", "four")
val sortedNumbers = numbers.sortedBy { it.length }
println(sortedNumbers)
//[one, two, four, three]
val sortedByLast = numbers.sortedByDescending { it.last() }
println(sortedByLast)
//[four, two, one, three]
(4)reversed()和asReversed()
var numbers = mutableListOf("one", "two", "three", "four")
//返回原有集合的倒序副本，且和原有集合没有关联
println(numbers.reversed())
//[four, three, two, one]
//返回原有集合的倒序视图，且和原有集合相关联。即改变原有的集合，已得到的倒序视图会发生改变。
val reversedNumbers = numbers.asReversed()
println(reversedNumbers)
//[four, three, two, one]
numbers.add("five")
println(reversedNumbers)
//[five, four, three, two, one]
(5)shuffled()
返回一个以随机顺序排列的含有原有集合元素的新list
val numbers = listOf("one", "two", "three", "four")
println(numbers.shuffled())
15、聚合
(1)聚合操作如min()、max()、average()、sum()这些都只是对于数字类型的集合可用。count()计算集合中元素数量。
minBy{}、maxBy{}接收一个表达式；minWith{}、maxWith{}接收一个Comparator对象，可以由compareBy{}产生。
sumBy{}、sumByDouble{}接收一个表达式。前者对int类型的元素求和，并返回int。后者对Double类型的元素求和，并返回Double。
(2)fold()和reduce()。以及OrNull版本。
val numbers = listOf(5, 1, 3, 2)
//第一步的两个操作数分别是集合中第一个和第二个元素。(则第一个元素无法乘以2)
println(numbers.reduce { sum, element - sum + element * 2 })
//17
//为sum设置了初始值。每一次的操作数都是sum和当前的集合元素。(可以保证每一个元素都乘以2)
println(numbers.fold(0) { sum, element - sum + element * 2 })
//22
(3) reduceRight() 和 foldRight()从尾部开始进行计算。以及OrNull版本。
(4)foldIndexed()和reduceIndexed()将元素索引作为参数进行操作。以及OrNull版本。
val numbers = listOf(5, 2, 10, 4)
println(numbers.foldIndexed(0) { idx, sum, element - if (idx % 2 == 0) sum + element else sum })
//15
println(numbers.reduceIndexed { idx, sum, element - if (idx % 2 == 0) sum + element else sum })
//15
(5)reduceRightIndexed() 与 foldRightIndexed()从尾部开始进行计算。以及OrNull版本。
16、List操作
(1)getOrElse()、getOrNull()
val numbers = listOf(1, 2, 3, 4)
//越界时，返回null
println(numbers.getOrNull(5))
//越界时，返回表达式的结果，it等于index
println(numbers.getOrElse(6, { it }))
(2) indexOf() 返回元素第一个位置。 lastIndexOf() 返回元素最后一个位置。
(3)indexOfFirst() 和 indexOfLast() 可以接收一个表达式。
(4)二分查找 binarySearch()
要求该列表按照一定的顺序（自然排序或函数参数中提供的另一种排序）按升序排序过。
查询失败将返回 (-insertionPoint - 1)，其中 insertionPoint 为应插入此元素的索引，以便列表保持排序。
如果存在多个目标元素返回其任一索引。
val numbers = mutableListOf("one", "two", "three", "four")
numbers.sort()
println(numbers)
//four, one, three, two]
println(numbers.binarySearch("two"))
// 3
println(numbers.binarySearch("z"))
// -5
println(numbers.binarySearch("two", 0, 2))
// -3
(5)通过Comparator使用二分查找
data class Product(val name: String, val price: Double)
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), compareByProduct { it.price }.thenBy { it.name }))
(6)fill()将集合中所有元素更新为指定值
val numbers = mutableListOf(1, 2, 3, 4)
numbers.fill(3)
println(numbers)
//[3, 3, 3, 3]
17、set操作
(1)union()获取并集。对于有序集合，操作数顺序决定元素顺序。a union b
(2)intersect()获取交集。a intersect b
(3)subtract()获取差集。a subtract b?
18、map操作
filter()、filterKeys()、filterValues()
val numbersMap = mapOf("key1" to 1, "key2" to 2, "key3" to 3, "key11" to 11)
println(numbersMap.filter { (key, value) - key.endsWith("1") value 10 })
//{key11=11}
println(numbersMap.filterKeys { it.endsWith("1") })
//{key1=1, key11=11}
println(numbersMap.filterValues { it 10 })
//{key1=1, key2=2, key3=3}
kotlin数组和集合
kotlin 为数组增加了 Array 类，为元素是基本类型的数组增加了 XxxArray 类（其中Xxx 可以是 Byte、Short、Int 等基本类型）
kotlin 的集合体系抛弃了 Java 集合体系中的 Queue 集合，但增加了可变集合和不可变集合的概念，与java集合类似的是， kotlin的List 代表有序、集合元素可重复的集合 Set 代表无序、集合元素不可重复的集合，Map则采用 key-value 对的形式存储数据
kotlin 既可允许通过 ArrayT类的构造器来创建实例，也可通过arrayOf()等工具函数来创建实例
arrayOf()：无须显式指定数组的长度，但需要依次列出每个数组元素
arrayOfNulls()：需要显式指定数组的长度，数组元素全部被初始化null，需要用泛型指定数组元素的类型
emptyArray()：创建一个长度为0的空数组，需要用泛型指定数组元素的类型
Array(size:Int, init: (Int)-T)构造器：需要显式指定数组的长度，并可通过 Lambda 表达式来动态计算各数组元素的值
由于ArrayT类要求它的元素必须是引用类型，因此，如果程序将基本类型的值存入 ArrayT中 Kotlin 会将这些基本类型的值自动装箱成包装类，为此， kotlin 专门提供了 ByteArray、ShortArray、IntArray、LongArray、CharArray、FloatArray、DoubleArray、BooleanArray 用于存储基本类型，不会进行自动装箱
XxxArray 数组不支持使用将元素初始化为 null 方式来创建数组，因为基本类型的元素不允许为 null
访问数组元素都是通过在数组引用变量后紧跟一个方括号[]实现的，方括号里是数组元素的索引，索引值大于0，且小于数组的长度
程序还可使用in 、!in 来检查某个索引是否位于数组的索引区间内，Kotlin 还为数组提供了lastlndex 属性，用于返回数组最后一个元素的索引值，该索引值通常等于size-1
由于数组还提供了用 operator 修饰的 plus()、 contains()方法，因此数组可通过＋、 in 运算符进行运算
用一维数组的方式来处理多维数组
Kotlin 的集合类由两个接口派生：Collection和Map，又被分成两大类：可变集合和不可变集合，只有可变集合才能添加、删除、修改元素，不可变集合只能读取元素
Kotlin 只提供了 HashSet、HasMap、LinkedHashSet、LinkedHashMap、ArrayList 这几个集合实现类，而且它们都是可变集合，Kotlin 的不可变集合类并没有暴露出来，只能通过函数来创建不可变集合，依然可以使用 Java 集合框架提供的其他集合类
推荐使用 Kotlin 提供的工具函数来创建 Set 集合
其中 setOf()、mutableSetOf()、linkedSetOf()创建的 Set 集合能维护元素的添加顺序sortedSetOf()函数创建的 Set 集合会按照大小对元素排序，如果希望 Set 集合不维护元素顺序，只有通过 hashSetOf()函数创建 Set 集合才行
Set 集合中很多方法与 Array 的方法功能相似，例如 all （判断是否所有集合元素都满足指定规则）、 any（判断是否任一元素都满足指定规则）、associate（根据 Set 集合生成Map 集合）、drop（按规则去除集合的部分元素）、filter（对集合元素执行过滤）、 find（查找集合元素）
Set和MutableSet 都包含 Iterator()方法，但普通 Set的iterator()方法返回的是Iterator 对象，该 Iterator 对象只有 hasNextOf()、nextOf()两个方法：而 MutableSet的iterator()方法返回的是 Mutablelterator 对象，该对象除hasNextOf()、nextOf()两个方法之外，还提供了一个remove()方法，该方法可用于在遍历时删除元素
List 集合的最大特征有序可重复
推荐使用工具函数来创建List 集合
Set 支持的操作 List 一般都能支持，还增加了通过索引操作集合元素的方法
在可变的 Set 中介绍的方法，可变的 List 也完全支持，还增加了根据索引执行插入、删除、替换的方法
用于保存 key-value 对，也被分为可变的和不可变的
推荐使用 Kotlin 提供的工具函数来创建 Map 集合
Android开发-kotlin基本使用(一)
在app-manifests-AndroidManifest.xml添加网络访问权限:
在 app/build.gradle 的 dependencies 中添加下面的依赖
在http-HiOkHttp中
在MainActivity.kt中使用:
在 app/build.gradle 中添加以下依赖配置
在Account.kt中使用:
如果对象模型使用data class, 就可以不用指定初始值了:
使用插件快速生成复杂的数据模型 -- JsonToKotlin插件:
retrofit注解驱动型上层网络请求框架, 使用注解来简化请求, 大体分为以下几类:
在app/build.gradle中添加以下配置。使用Glide加载图片