Map
通常我们对一个数组操作
package com.yzdzy.kotlin.chapter5
fun main(args: Array<String>) {
val list= listOf(1,23,12,3,145)
val newList=ArrayList<Int>()
list.forEach{
val newElement=it*2+3
newList.add(newElement)
}
newList.forEach(::println)
}
使用map后
package com.yzdzy.kotlin.chapter5
fun main(args: Array<String>) {
val list = listOf(1, 23, 12, 3, 145)
val newList = list.map { it * 2 + 3 }
newList.forEach(::println)
}
结果都是一样的
5
49
27
9
293
转换double也可以这么写
val newList2 = list.map (Int::toDouble)
newList2.forEach(::println)
flatMap
package com.yzdzy.kotlin.chapter5
fun main(args: Array<String>) {
//int range的集合
val list= listOf(1..20,2..5,100..322)
//想变成[1,2,3,4,...20,2,3,4,5,100,101...321,322]、
val flatList=list.flatMap {
it
}
flatList.forEach(::println)
}
效果
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2
3
4
5
100
.....................
如果想拼接字符串No.并打印呢。需要嵌套一层map
package com.yzdzy.kotlin.chapter5
fun main(args: Array<String>) {
//int range的集合
val list= listOf(1..20,2..5,100..322)
val flatList=list.flatMap { inRange->
inRange.map {intElement->
"No.$intElement"
}
}
flatList.forEach(::println)
}
No.1
No.2
No.3
No.4
No.5
No.6
No.7
No.8
No.9
No.10
No.11
No.12
No.13
..................
reduce
求和或者是求阶乘
package com.yzdzy.kotlin.chapter5
fun main(args: Array<String>) {
//int range的集合
val list = listOf(1..20, 2..5, 100..322)
val flatList = list.flatMap { inRange ->
inRange
}
println(flatList.reduce { acc, i -> acc + i })
}
结果
47277
不信的话可以算小的
val list = listOf(1..100)
结果是5050
阶乘算法
可能会遇到得bug
package com.yzdzy.kotlin.chapter5
fun main(args: Array<String>) {
//int range的集合
(0..6).map ( ::factorial).forEach(::println)
}
fun factorial(n: Int): Int {
if (n == 0) return 1
val res = (1..n).reduce { acc, i -> acc * i }
return res
}
输出
1
1
2
6
24
120
720
Process finished with exit code 0
对阶乘再求和
package com.yzdzy.kotlin.chapter5
fun main(args: Array<String>) {
//int range的集合
//阶乘再想加
val res = (0..6).map(::factorial).reduce { acc, i -> acc + i }
println(res)
}
fun factorial(n: Int): Int {
if (n == 0) return 1
val res = (1..n).reduce { acc, i -> acc * i }
return res
}
结果
874
fold
可以用来计算
package com.yzdzy.kotlin.chapter5
fun main(args: Array<String>) {
//int range的集合
//阶乘再想加
val res = (0..6).map(::factorial).fold(5){acc, i ->
acc+i
}
println(res)
}
fun factorial(n: Int): Int {
if (n == 0) return 1
val res = (1..n).reduce { acc, i -> acc * i }
return res
}
结果:879 比上面多了5
可以用来拼接字符串 acc和i都变成了String格式
package com.yzdzy.kotlin.chapter5
import java.lang.StringBuilder
fun main(args: Array<String>) {
//int range的集合
//阶乘再想加
val res = (0..6).map(::factorial).fold(StringBuilder()){ acc, i ->
acc.append(i).append(",")
}
println(res)
}
fun factorial(n: Int): Int {
if (n == 0) return 1
val res = (1..n).reduce { acc, i -> acc * i }
return res
}
结果:1,1,2,6,24,120,720,
当然 真的想拼接字符串不需要这么复杂
只用
println((0..6).joinToString(","))
便可以得到
0,1,2,3,4,5,6
foldRight
倒叙使用
package com.yzdzy.kotlin.chapter5
import java.lang.StringBuilder
fun main(args: Array<String>) {
//int range的集合
//阶乘再想加
val res = (0..6).map(::factorial).foldRight(StringBuilder()) { i, acc ->
acc.append(i).append(",")
}
println(res)
}
fun factorial(n: Int): Int {
if (n == 0) return 1
val res = (1..n).reduce { acc, i -> acc * i }
return res
}
720,120,24,6,2,1,1,
filter 只保留奇数
package com.yzdzy.kotlin.chapter5
import java.lang.StringBuilder
fun main(args: Array<String>) {
//int range的集合
//阶乘再想加
var res = (0..6).map(::factorial)
val res2 = res.filter { it % 2 == 1 }
println(res2)
}
fun factorial(n: Int): Int {
if (n == 0) return 1
val res = (1..n).reduce { acc, i -> acc * i }
return res
}
[1,1]
只要奇数位置的阶乘
package com.yzdzy.kotlin.chapter5
import java.lang.StringBuilder
fun main(args: Array<String>) {
//int range的集合
//阶乘再想加
var res = (0..6).map(::factorial)
val res2 = res.filterIndexed { index, j -> index % 2 == 1 }
println(res2)
}
fun factorial(n: Int): Int {
if (n == 0) return 1
val res = (1..n).reduce { acc, i -> acc * i }
return res
}
[1, 6, 120]
takeWhile 遇到第一个指定的条件不符合否则退出。比如遇到偶数退出 奇数执行
package com.yzdzy.kotlin.chapter5
import java.lang.StringBuilder
fun main(args: Array<String>) {
//int range的集合
//阶乘再想加
var res = (0..6).map(::factorial)
val res2 = res.takeWhile { it % 2 == 1 }
println(res2)
}
fun factorial(n: Int): Int {
if (n == 0) return 1
val res = (1..n).reduce { acc, i -> acc * i }
return res
}
[1,1]
let 可以省略?得写法
通常
package com.yzdzy.kotlin.chapter5
import java.lang.StringBuilder
class Person(val name: String, val age: Int) {
}
fun main(args: Array<String>) {
val person = finderPerson()
println(person?.name)
println(person?.age)
}
fun finderPerson(): Person? {
return null
}
package com.yzdzy.kotlin.chapter5
class PersonA(val name: String, val age: Int) {}
fun main(args: Array<String>) {
finderPerson()?.let { person ->
println(person.name)
println(person.age)
}
}
fun finderPerson(): PersonA? {
return PersonA("a", 1)
}
打印 a 1
为空也不会报错什么都不会输出
package com.yzdzy.kotlin.chapter5
class PersonA(val name: String, val age: Int) {}
fun main(args: Array<String>) {
finderPerson()?.let { person ->
println(person.name)
println(person.age)
}
}
fun finderPerson(): PersonA? {
return null
}
apply
更加省略参数。。。
package com.yzdzy.kotlin.chapter5
class PersonA(val name: String, val age: Int) {
fun work() {
println("$name is working")
}
}
fun main(args: Array<String>) {
finderPerson()?.apply {
work()
println(age)
}
}
fun finderPerson(): PersonA? {
return PersonA("小米",2)
}
小米 is working
2
with 他是把内容包括起来
package com.yzdzy.kotlin.chapter5
import java.io.BufferedReader
import java.io.FileReader
class PersonA(val name: String, val age: Int) {
fun work() {
println("$name is working")
}
}
fun main(args: Array<String>) {
val br = BufferedReader(FileReader("hello.txt"))
with(br){
var line:String?
while (true){
line=readLine()?:break
println(line)
}
close()
}
}
fun finderPerson(): PersonA {
return PersonA("小米", 2)
}
close()是BufferedReader 得方法
就"hello.txt" 是在主工程目录下 而非当前java 目录下内容随便写 打印结果也是和他一样得
hwasda
adsjasd
实际的读取文件可不用这么麻烦啊。可以直接使用
fun main(args: Array<String>) {
val br = BufferedReader(FileReader("hello.txt")).readText()
println(br)
}
还可以
val br = BufferedReader(FileReader("hello.txt")).readLines()
println(br)
[hwasda, adsjasd]
use
在上面的案列当中 我们开启br后要关闭br 非常不方便
with(br){
var line:String?
while (true){
line=readLine()?:break
println(line)
}
close()
}
修改代码 加上了it 别忘了。。
fun main(args: Array<String>) {
val br = BufferedReader(FileReader("hello.txt"))
br.use {
var line: String?
while (true) {
line = it.readLine() ?: break
println(line)
}
close()
}
}
看使用到colose()得地方直接爆红 不给图了。
感兴趣的小伙伴可以点进去use源码看下
因为br是closeable得方法 所以可以使用use 而且不用id啊哦用use 它会自动帮我关闭
fun main(args: Array<String>) {
val br = BufferedReader(FileReader("hello.txt"))
br.use {
var line: String?
while (true) {
line = it.readLine() ?: break
println(line)
}
}
}